aboutsummaryrefslogtreecommitdiffstats
path: root/docs
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-14 12:16:15 +0000
committertv <tv@krebsco.de>2026-11-14 12:16:15 +0000
commit33db2b33d6f39b14c8ceee9c1f3cc6b8ff378d11 (patch)
treee1a0bd48d71c5043849300a6e3b19018fcf3edfd /docs
parent6a87b812fe65dfb23dc21d7634de3b6e58344322 (diff)
federation: brought along, and switch records
"Carried over" is continuum's word for replay: a node's writes written again by path, the last writer winning. The federated swarm does something else after a remake: envelopes written again as they were signed, and what each node held of them recorded. Envelopes are now "brought along", and a node's record of what it held when it switched is its "switch record" (`_continuum/switched/<node ID>`). The Remakes section says that continuum's replay doesn't run under the federated policy.
Diffstat (limited to 'docs')
-rw-r--r--docs/federation.md174
1 files changed, 88 insertions, 86 deletions
diff --git a/docs/federation.md b/docs/federation.md
index a2618b6..b9c3ef3 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -66,7 +66,7 @@ but for what the voters can do to a user, said with each and below):
2. **The same document.** Two honest nodes holding the same changes hold the same
document, and resolve it (Resolving, below) to the same registry. A remake changes
nothing that counts, whoever makes it and from whatever base: every node builds the
- next epoch itself, and carries over what it holds beyond the base.
+ next epoch itself, and brings along what it holds beyond the base.
3. **Signed by its user.** Whatever the resolved registry shows in a user's namespace
was signed with a key that was that user's when it signed, or is as the root
change has it. What it shows as held by a user, the user claimed with such a key,
@@ -377,24 +377,24 @@ grows. A statement is signed by one user and says one thing:
another is put off by every node that would take it from that user's nodes, until a
remake. A node's writers count for one user: the one its member entry names, of
those it carries for, where each writer starts (a writer counts for the user it was
- counted for, until a cut leaves it out), its own word, carried over a remake with
- the entry; naming none of them, the user of the `node` statement naming it with the
- lowest digest, of those that count there, so that its operator names one to choose.
- So a user past its limit puts off the nodes whose writers count for it, and no other
- that carries for it too. It is never refused: put off is each node's doing, its
- operator may take what it puts off (`POST /admin/put-off/take`, naming the user),
- and a change that reaches a node within another's history is taken. Writers a node
- started outside a cut it was stopped with count for nobody: a thief's node costs its
- victim nothing once cut off, and where the count falls back below the limit so,
- every node takes what it put off for that user, read again from the changes, nobody
- acting: late, with what was built on it. A writer is a run, not a write: 64 are a
- node restarting weekly for more than a year. Each costs every node 4 bytes for every
- change of the epoch, those before it started too *(measured upstream)*: 64 cost some
- 2.5 MB at `remakeChanges` changes. Where epochs last long (few nodes, writing
- little), a user whose nodes restart often reaches it first: such a swarm sets it
- higher. A node whose writers count for a user past it is put off as a whole, with
- what it carries for others and its records of proposals, until a remake or its
- operator takes what is put off; how many a user's nodes started shows
+ counted for, until a cut leaves it out), its own word, brought along across a remake
+ with the entry; naming none of them, the user of the `node` statement naming it with
+ the lowest digest, of those that count there, so that its operator names one to
+ choose. So a user past its limit puts off the nodes whose writers count for it, and
+ no other that carries for it too. It is never refused: put off is each node's doing,
+ its operator may take what it puts off (`POST /admin/put-off/take`, naming the
+ user), and a change that reaches a node within another's history is taken. Writers a
+ node started outside a cut it was stopped with count for nobody: a thief's node
+ costs its victim nothing once cut off, and where the count falls back below the
+ limit so, every node takes what it put off for that user, read again from the
+ changes, nobody acting: late, with what was built on it. A writer is a run, not a
+ write: 64 are a node restarting weekly for more than a year. Each costs every node 4
+ bytes for every change of the epoch, those before it started too *(measured
+ upstream)*: 64 cost some 2.5 MB at `remakeChanges` changes. Where epochs last long
+ (few nodes, writing little), a user whose nodes restart often reaches it first: such
+ a swarm sets it higher. A node whose writers count for a user past it is put off as
+ a whole, with what it carries for others and its records of proposals, until a
+ remake or its operator takes what is put off; how many a user's nodes started shows
(`GET /registry/users`), for a remake to come first.
* **A party's budget.** A node takes changes from a party's nodes no faster than a
budget, its own setting (`--party-budget`): changes, their bytes and their
@@ -420,7 +420,7 @@ grows. A statement is signed by one user and says one thing:
limit is the one that holds where the registry is read: lowered, it leaves out the
last. So for every limit: keys beyond the first, nodes, creations, vouches,
proposals, a kind's claims. Across a remake, what the snapshot holds comes first,
- then what is carried over, by the numbers it states, then what is signed in the new
+ then what is brought along, by the numbers it states, then what is signed in the new
epoch (Remakes).
* **Names** of users are 1 to 64 of `A-Z a-z 0-9 . _ @ -`, as today, less the
top-level keys the swarm uses otherwise (`_continuum`). Which of them may be
@@ -552,7 +552,7 @@ exactly:
the far side of a partition, is valid as written, so nodes hold it; it is past the
point, and doesn't count. A node takes changes of an unvouched user's nodes only as
part of another party's history, never from those nodes, so they can't make it work;
- but for their records of proposals and carry records, where the user is a voter
+ but for their records of proposals and switch records, where the user is a voter
(Decisions).
So whoever relied on a user that is out has that long to find another who vouches:
@@ -588,7 +588,7 @@ replaced as today, by an envelope naming the one it replaces (`prev`): the value
shows there where it is signed. Where several count there (written at once), it names
any one of them, and replaces them all, as a write in the document does. Nothing plain
is written anywhere but a node's own member entry, its own records of proposals and
-its carry record.
+its switch record.
Delegating (another user writing below `<name>/shared`, say) would be a statement in
the user's register granting a capability within its namespace: for later; the rule
@@ -979,7 +979,7 @@ take the proposal up as it reaches them, and it is decided as fast as they sync.
**The last holds.** Several proposals of one matter can be open, and voted on, at a
time, and more than one can come to be decided: voters change their minds. Of the
decisions of a matter, the one with the highest number **holds** (across a remake,
-those carried over come before those of the new epoch: Remakes). Two with the same
+those brought along come before those of the new epoch: Remakes). Two with the same
number, made out of each other's sight, are both decided only where the nodes of a
third of the voters took both up, which an honest node doesn't; then the one with the
lower digest holds. A decision closes the proposals of its matter with a lower number:
@@ -1073,7 +1073,9 @@ proposes and coordinates, the alive peers ack, and every node builds the next ep
itself and switches. Nothing the swarm decides goes through it, and nothing that
counts changes by it: it keeps the document small (Automerge: history), and the nodes
do it by themselves. What the federated policy adds is when, what the snapshot holds,
-what comes along, and which of two remakes the nodes go to.
+what comes along, and which of two remakes the nodes go to. Continuum's replay, which
+writes a node's writes again by path, the last writer winning, doesn't run under it:
+envelopes are brought along as they were signed (below).
* **Compaction only.** A node follows a remake of the kind `compact` alone: `replace`,
`import` and `strict` put content nobody signed, and start a new swarm.
@@ -1085,7 +1087,7 @@ what comes along, and which of two remakes the nodes go to.
and no faster, whoever proposes them.
* **Any base.** The base is the coordinator's heads when it commits, as in every swarm,
and the coordinator may be anyone's node. One that leaves out what others hold, or
- is old, loses nothing: every node carries over what it holds beyond the base, with
+ is old, loses nothing: every node brings along what it holds beyond the base, with
what it held of it (below). A node that lacks the base syncs it from a peer that
keeps the epoch.
* **By its result.** Every node builds the snapshot itself from the base, and follows
@@ -1130,15 +1132,15 @@ what comes along, and which of two remakes the nodes go to.
happened. Within an epoch nothing is removed: a release is a statement like any
other, signed, and a document keeps its history. The remake is what deletes.
* **Nothing it left out comes back.** An envelope is taken in the epoch it names and,
- carried over, in the next. So that what the base held and the remake left out (a
+ brought along, in the next. So that what the base held and the remake left out (a
stolen laptop's key and node, retired long since) can't be handed in again as signed
in the epoch before, the root change lists the digests of the envelopes the base
held that were signed there, and an envelope among them is refused. The epoch after
drops the list.
-* **Carried over.** A node that switches first catches up with the peers it keeps in
+* **Brought along.** A node that switches first catches up with the peers it keeps in
the epoch it leaves, as a node that comes back does. Then, before it takes anything
- in the new epoch, it commits its **carry record**, every node that switches, whoever
- it carries for (out voters too), `_continuum/carried/<node ID>`: the digests of the
+ in the new epoch, it commits its **switch record**, every node that switches, whoever
+ it carries for (out voters too), `_continuum/switched/<node ID>`: the digests of the
envelopes it holds that the base lacks, whoever signed them (statements, values,
proposals, votes and their releases), and what it held of them and of what the
snapshot holds: which claim it held as late against which, or as giving way to
@@ -1156,38 +1158,38 @@ what comes along, and which of two remakes the nodes go to.
refused for what stands in the new epoch: whether it counts is resolved. So an
envelope comes into the new epoch about once, and what each node witnessed comes as
32 bytes a node.
-* **A carry record witnesses** as the node's changes did in the epoch before: as a
+* **A switch record witnesses** as the node's changes did in the epoch before: as a
change with what it names in its history, standing or not as it says. Against a
claim, where a node of that claim's side committed it; for an unvouch, or a vouch or
a creation cut off, where a node of its signer or of a root did. So a claim that
turns up later as signed in the epoch before is late against what a root's node's
record names, and nothing rests on the order a node writes in.
-* **Carried over, and held by the snapshot.** What a claim carried over says its
+* **Brought along, and held by the snapshot.** What a claim brought along says its
signer saw isn't there to look at, so it and a claim the snapshot holds are ordered
- as two claims out of each other's sight: by the carry records, and by what the
+ as two claims out of each other's sight: by the switch records, and by what the
snapshot says of the one it holds. A claim settled at the base has every claim
- carried over late against it; one not yet settled, those of the users whose nodes
+ brought along late against it; one not yet settled, those of the users whose nodes
the snapshot lists as having had it standing.
* **Its order and its numbers.** Of a user's statements of one kind, and of the
proposals of a matter, those the snapshot holds come first, then those carried
over, by the numbers they state, then those signed in the new epoch. So a number
nobody could check (a statement signed after the switch as of the epoch before)
orders nothing but its own signer's statements among themselves, and a proposal
- carried over never outranks one of the new epoch.
-* **Its values.** A value carried over counts while no value its user signed in the
+ brought along never outranks one of the new epoch.
+* **Its values.** A value brought along counts while no value its user signed in the
new epoch is at its place: whoever writes in the new epoch has the last word over
- what the epoch before held, seen or not. Of several carried over to one place,
+ what the epoch before held, seen or not. Of several brought along to one place,
one that another replaces is left out (Resolving).
-* **A cut carried over** is the list its statement carries (Cuts).
+* **A cut brought along** is the list its statement carries (Cuts).
* **Decisions after the base** aren't in the snapshot. Their proposals and votes are
- carried over, and a node that held one decided takes it up again in the new epoch,
+ brought along, and a node that held one decided takes it up again in the new epoch,
whether its votes still run or not: it is decided there once the nodes of two thirds
of the voters switched. Until then the registry resolves without it, and what is
signed meanwhile with a key the decision cut off is outside that cut once it holds
again.
* **Lengths of time go on.** A node's stamps in the new epoch continue the one the
snapshot lists for it: a thing it held so there and at a stamp in the new epoch has
- been so all the while, unless its carry record says it saw the thing broken after
+ been so all the while, unless its switch record says it saw the thing broken after
the base. What its stamps in the epoch before showed after the base is read no other
way.
* **A node that was away** comes back as said below (Coming back after remakes).
@@ -1196,7 +1198,7 @@ what comes along, and which of two remakes the nodes go to.
**What a remake changes**, then, is nothing that counts, but for what it can't carry:
an envelope signed two epochs back comes no more (Coming back after remakes); what only
-a node witnessed after the base, and named in no carry record because it never
+a node witnessed after the base, and named in no switch record because it never
switched and doesn't come back, is lost with it; a decision decided after the base
waits in the new epoch for the nodes of two thirds of the voters to take it up again.
Who remakes, when, and from what base changes none of it: that is why the alive peers
@@ -1234,7 +1236,7 @@ in one of two ways:
Either way, what follows:
* **What it holds and the swarm never got.** What was signed in the epoch just before
- the one the node arrives in is carried over: the node commits its carry record
+ the one the node arrives in is brought along: the node commits its switch record
when it arrives, and writes again what the epoch lacks. What was
signed further back isn't: an envelope is taken in its epoch and the next, no
later. Its own user's go to the quarantine, and the client lists them for the
@@ -1249,7 +1251,7 @@ Either way, what follows:
A node in the other of two remakes of one epoch moves the same way, to the one with
the lower ID: it holds the epoch both came from, builds the snapshot from that base,
-and carries over what it holds, envelopes signed in the epoch it leaves among them
+and brings along what it holds, envelopes signed in the epoch it leaves among them
(What every node judges). To any other epoch a node moves only by its operator's word
(`POST /admin/epochs/rejoin`, `POST /admin/fork`).
@@ -1348,7 +1350,7 @@ What refusing does:
and no proposal there. Every node that refuses the same decision builds the same
epoch, whenever it does. So those who think alike meet there without arranging
it.
-* **What it takes along.** As with a remake, the node carries over what it holds
+* **What it takes along.** As with a remake, the node brings along what it holds
beyond that base, decisions among it but the one refused. So refusing costs what
a remake costs whose base is a window older than the proposal was taken up, and
however long the decision hung after.
@@ -1423,7 +1425,7 @@ is:
* **A record of a proposal**, `_continuum/decisions/<proposal>/<node ID>`: `proposal`;
of a fork, `base`, the proposer's node.
-* **A carry record**, `_continuum/carried/<node ID>`: `from` (the epoch it left),
+* **A switch record**, `_continuum/switched/<node ID>`: `from` (the epoch it left),
`digests` (of the envelopes it holds that the base lacks), and what it held of them
and of what the snapshot holds: `late` and `givesWay` (pairs of claims' digests),
`through` (statements that count through an unvouch or a cut: their digests),
@@ -1449,11 +1451,11 @@ A change is valid if, in the document at its dependencies:
hasn't stopped there, proven by the node's signature. Or the change is the one by
which a node comes to carry: it holds a `node` statement naming its committer, by a
user that isn't out there, the committer's member entry and, after a remake, its
- carry record, and nothing else. Or it holds nothing but the committer's own record
- of a proposal, or its carry record, and the committer carries for a voter that is
+ switch record, and nothing else. Or it holds nothing but the committer's own record
+ of a proposal, or its switch record, and the committer carries for a voter that is
out there.
3. Apart from the node's own member entry (of the shape the policy's version gives it,
- within `limits.entry`), its own records of proposals, its carry record, and what it
+ within `limits.entry`), its own records of proposals, its switch record, and what it
writes of a remake as in every swarm (its ack; a coordinator's proposal and
decision, of the kind `compact`), it writes only envelopes, each naming the swarm,
its epoch, its path and its user's ID, and for a statement what its signer saw
@@ -1466,7 +1468,7 @@ A change is valid if, in the document at its dependencies:
node's own record, once, of a proposal that is there: of a fork, its proposer's
node's own, naming the base, without votes; of any other, with votes for it in the
change's history by more than `fractions.decide` of the voters, none released
- there. Under `_continuum/carried`: only the node's own carry record, once an epoch.
+ there. Under `_continuum/switched`: only the node's own switch record, once an epoch.
Nothing replaced, nothing deleted, nor anything that holds a register.
5. A `create`: its name is one the kind `user` takes, and neither a creation of it nor
a user's claim of it as its own name stands there, a rule of the kind lets the
@@ -1495,12 +1497,12 @@ A change is valid if, in the document at its dependencies:
9. `_continuum/access`, the swarm ID, the epochs, and what the root change sets for
the swarm as a whole: never.
-**What is carried over**: an envelope naming the epoch before this one, or another
+**What is brought along**: an envelope naming the epoch before this one, or another
remake of that epoch, is held to less. Any node commits it, as any envelope (a `node`
statement only the node it names). What it says its signer saw isn't looked at, and
-its number orders only among what is carried over. Of 5 to 8 only what the envelope
+its number orders only among what is brought along. Of 5 to 8 only what the envelope
itself shows is asked: its signature by a key that is its user's there, its register,
-for a value that its `prev` is a value the snapshot or another carried over holds
+for a value that its `prev` is a value the snapshot or another brought along holds
there, and that the root change doesn't list its digest. Whether it counts is
resolved.
@@ -1562,7 +1564,7 @@ the steps before:
* one named by the decision that holds on whose the name is: the other gives way;
* both final: neither gives way, and they contest each other;
* one final: the other gives way;
- * one carried over, the other held by the snapshot: as neither in sight of the
+ * one brought along, the other held by the snapshot: as neither in sight of the
other, the snapshot saying whose nodes had the one it holds standing (Remakes);
* one signed in sight of the other: it gives way if the other stood where it was
signed, or is read as never down (Claims); else, where the other didn't stand
@@ -1575,9 +1577,9 @@ the steps before:
wait while it is out; else the name is contested. A kept name is held by the user
that has the user name.
5. **Values.** A value in a namespace counts if its envelope does and its user has the
- name. A value carried over is left out where its user signed one in the new epoch
+ name. A value brought along is left out where its user signed one in the new epoch
at that place. Where the document holds several at one place (written at once, or
- carried over by nodes that held different ones), one that another there replaces,
+ brought along by nodes that held different ones), one that another there replaces,
directly or along `prev`, is left out; of the rest, those that count, in the
document's order (Automerge: values written at once). Where the one there doesn't
count, the last that does, back along `prev` (read in the document at the
@@ -1617,7 +1619,7 @@ same holder, or contested. The users see it and one releases; nobody drops anyth
**Two epochs**, after a fork or a decision some refuse, are apart for good: each node
is where its operator put it (by word or by bounds), and moves to the other side by
-being told to (it builds that side's snapshot from the base it holds, and carries over
+being told to (it builds that side's snapshot from the base it holds, and brings along
what it holds). Two remakes of one epoch both committed are no such thing: every node
goes to the one with the lower ID (Remakes).
@@ -1731,14 +1733,14 @@ with the epoch (Automerge: writers, history).
|---|---|
| a change | its bytes, on disk and once on the wire; in memory 0.2 KB and its bytes, and 4 B for every writer of the epoch; when it was received, kept beside it |
| a writer | 4 B of heap for every change of the epoch, those before it too; a signature in every transfer of the whole history |
-| a statement | under a KiB; 32 B in the next root change's list where it was signed in the epoch before, in each retirement's list that keeps it, in each carry record that names it |
+| a statement | under a KiB; 32 B in the next root change's list where it was signed in the epoch before, in each retirement's list that keeps it, in each switch record that names it |
| a value | its envelope, a few hundred bytes for a host; kept replaced while not stopped counting for good |
-| a node | its member entry, `limits.entry` at most; a stamp each `stamp`, some 350 B; a writer a run; a record a proposal it takes up; a carry record a remake |
+| a node | its member entry, `limits.entry` at most; a stamp each `stamp`, some 350 B; a writer a run; a record a proposal it takes up; a switch record a remake |
| a user at its limits | some 470 statements standing (keys, nodes, users created, vouches, proposals, a kind's claims), under half a MiB, and `limits.writers` writers |
| a claim | its statement; while it has a rival, what each witness had seen, kept as the node goes; until it is final, a length watched for each voter's node |
| a cut | 32 B for each statement and value it keeps |
| a root's node | a change a `witness` at most while claims reach it |
-| a remake | the snapshot built by every node, the registry gone over once; 32 B in the root change for each envelope signed in the epoch left; a carry record a node, 32 B for each envelope beyond the base it holds; each such envelope written once more; the epoch left, on disk for `archiveRetention` |
+| a remake | the snapshot built by every node, the registry gone over once; 32 B in the root change for each envelope signed in the epoch left; a switch record a node, 32 B for each envelope beyond the base it holds; each such envelope written once more; the epoch left, on disk for `archiveRetention` |
| a signature | some 30 µs to check *(docs)* |
What bounds it:
@@ -1912,7 +1914,7 @@ its swarm, epoch, path and user ID *(checked for swarm, path and the user's name
`access::envelope::check`)*, so it counts nowhere else and for nobody else. A name is
held by a claim so signed, by a rule, or by a decision. Across a remake: every node
builds the snapshot from changes it judged, so the snapshot holds only what counted or
-could, as envelopes with their signatures, and what is carried over is signed as it
+could, as envelopes with their signatures, and what is brought along is signed as it
was.
**Promise 4.** Steps 3 and 4 name a holder only where exactly one claim remains.
@@ -2010,7 +2012,7 @@ a write is refused only by what its own history holds, and counts from the start
which every node holds and judged itself, and holds whatever can still count: the next
epoch resolves at its root as the base did, and nothing it leaves out could have
counted again (For good, under Cuts). What a node holds beyond the base comes along
-with what it held of it, by its carry record, whatever base the coordinator chose: an
+with what it held of it, by its switch record, whatever base the coordinator chose: an
honest node witnesses there as its changes would have. Lengths of time go on from the
stamps the snapshot lists. So a remake from any base, by any node, at any time, moves
nothing that counts; and of two, every node goes to the one with the lower ID, which
@@ -2159,7 +2161,7 @@ far as the roots' nodes' witness.
as the document grows. What stopped counting for good is what was seen so for
`final`, remake or not.
* **The epoch for those who refuse built wherever a proposal says it was signed**:
- its signer would choose what refusing costs, up to a whole epoch carried over.
+ its signer would choose what refusing costs, up to a whole epoch brought along.
Nobody takes up a proposal that says it saw less than its node held a window
before.
* **A late claim standing in wait** for the name: whoever signed, in time, a claim
@@ -2186,7 +2188,7 @@ far as the roots' nodes' witness.
| Write or delete any user data | Only envelopes, signed by their users; nothing plain, nothing deleted from a register |
| Write as any user | An envelope needs the user's key |
| Edit the member and user registries | Its own member entry, of a shape and a size; users come and go by statements, which only add |
-| Forge votes, commit a remake alone | Votes are users', signed; a decision takes two thirds of the voters, and every node judges the records. A remake it commits alone changes nothing that counts: every node builds the snapshot itself, and carries over what it holds |
+| Forge votes, commit a remake alone | Votes are users', signed; a decision takes two thirds of the voters, and every node judges the records. A remake it commits alone changes nothing that counts: every node builds the snapshot itself, and brings along what it holds |
| Make the swarm forget peers | A forget record of another's node is refused; whom a node talks to is its own |
| Advertise an epoch a rejoining node follows | A node follows a remake it sees committed, or an epoch its operator gave it |
| Be a joining node's first sync | Judged from the root change on, by the policy in it |
@@ -2228,7 +2230,7 @@ document, keeps its writer over a clean stop, stamps as often as the policy says
keeps its seeds and its user's other nodes as neighbours, keeps the document of an
epoch it left on disk and answers for it, keeps when it received each change (for
`window`, over a restart), keeps a quarantine on disk that holds envelopes, commits
-its carry record after a remake and writes again what the epoch lacks, takes compact
+its switch record after a remake and writes again what the epoch lacks, takes compact
remakes only, by `remakeChanges` or `remakeWriters`, and of two the lower ID, rejoins
no epoch because peers advertise it, and refuses what its bounds say. For every swarm:
the wire's version, with a handshake that says which epochs its node keeps, and a node
@@ -2237,7 +2239,7 @@ that speaks the wire version before its own too. [`trust.md`](trust.md),
federated case: party, statement, in sight of, line, root, the seats', voter, claim,
cut, late, giving way, contested, settled, final (of a claim, and of a decision),
stopped counting for good, out, gone, uncovered, seen for, taking a proposal up, a
-decision that holds, what hangs, the voters before, carried over, a carry record, a
+decision that holds, what hangs, the voters before, brought along, a switch record, a
party (for a budget), refusing a decision, bounds, the numbers; and continuum's own,
as the design names them: the alive peers, and their acks.
@@ -2344,7 +2346,7 @@ Unvouching:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
| 24 | Unvouches a user it didn't vouch for; a root unvouches the users the root change holds, or those a root before it created | Refuse the first. What is the seats' is taken back once every root unvouched it: one root puts nobody out, where there are several | 3 | unit: `only_the_voucher_unvouches`, `the_seats_take_back_together` |
-| 25 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and carry records, and nothing else: who votes is the voters' word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` |
+| 25 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and switch records, and nothing else: who votes is the voters' word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` |
| 26 | Unvouches saying it saw little, to undo what the user did since | What its own nodes or a root's had seen of the user stays | as said under Unvouching | unit: `an_unvouch_undoes_nothing_seen` |
| 27 | The unvouched user signs on, saying it saw nothing of the unvouch, or across a partition | Hold it as part of another's history only; it doesn't count; once the partition is over every node finds the same | 2, 3 | unit: `past_an_unvouch`; sim: `an_unvouch_across_a_partition` |
| 28 | A user is unvouched: what of those it brought in, and its names? | One that another vouched for stays in, without doing anything. The others are out from the same point; a vouch after brings them back whole. Their names wait | 4 | unit: `a_second_line_keeps_it`, `those_it_brought_in`, `a_vouch_brings_back` |
@@ -2430,13 +2432,13 @@ Decisions and remakes:
| 88 | A user is out and stays out: what of its names? | A decision frees them, or gives them to another, whatever `gone` says | 7 | unit: `a_decision_frees_or_gives` |
| 89 | The voters decide a policy that covers a user's names no more; another user writes over what is uncovered; a third of the voters stamp to drop it at once | It doesn't count where the policy holds, and shows aside. Only its user takes it away, nobody changes it; it is dropped once seen there for `uncovered` | not promised | unit: `what_a_policy_no_longer_covers`, `uncovered_is_only_taken_away` |
| 90 | The voters decide a policy that stops keeping names for their users | A kept name its user claimed stays its claim. One it didn't is the first comer's | not promised | unit: `a_kept_name_claimed` |
-| 91 | Runs most of the alive nodes: commits remakes from bases of its choosing, as often as it may; serves a snapshot of its own | Nothing that counts changes: every node builds the snapshot itself, carries over what it holds beyond the base, and follows a remake only once its base holds `remakeChanges` changes or `remakeWriters` writers. Each costs every node a snapshot | 2; not promised (how often) | sim: `every_node_builds_the_snapshot`, `remakes_no_sooner_than_the_changes` |
-| 92 | As a remake's coordinator, commits a base that leaves out a claim settled minutes before, and holds its accomplice's rival | The nodes that held the claim carry it over with what they held of it: a root's node's carry record has the rival late against it, as its change would have | 5 | sim: `a_base_that_leaves_out` |
+| 91 | Runs most of the alive nodes: commits remakes from bases of its choosing, as often as it may; serves a snapshot of its own | Nothing that counts changes: every node builds the snapshot itself, brings along what it holds beyond the base, and follows a remake only once its base holds `remakeChanges` changes or `remakeWriters` writers. Each costs every node a snapshot | 2; not promised (how often) | sim: `every_node_builds_the_snapshot`, `remakes_no_sooner_than_the_changes` |
+| 92 | As a remake's coordinator, commits a base that leaves out a claim settled minutes before, and holds its accomplice's rival | The nodes that held the claim carry it over with what they held of it: a root's node's switch record has the rival late against it, as its change would have | 5 | sim: `a_base_that_leaves_out` |
| 93 | Commits a remake of another kind (`replace`, `import`, `strict`), with content of its own | No node follows it: a federated swarm compacts only | 3 | unit: `compaction_only` |
-| 94 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | A root's node named the real claim in its carry record, before it took anything in the new epoch: the pretender's claim is late against it | 5 | unit: `a_carry_record_witnesses`; sim: `a_pretender_after_a_remake` |
-| 95 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Taken from any node, as within an epoch: a value carried over has no word against one its user signed in the new epoch, and is left out where another carried over replaces it; a claim is late against what a root's node's record named; a number orders only among what is carried over | 3 | unit: `carried_over_from_any_node`, `the_new_epoch_has_the_last_word` |
-| 96 | Signs after the switch, as of the epoch before, statements and a proposal with numbers of its choosing | Carried over comes after what the snapshot holds and before what the new epoch signs: such a number orders only its signer's statements among what is carried over, and the proposal outranks none of the new epoch | 6, 7 | unit: `carried_over_in_between` |
-| 97 | Writes a carry record naming what it likes, or several, or one of its own after taking from peers | One a node and epoch. What it names is its node's word, as a change of that node would have been: a contest where it is a root's or the claimant's, no more | 5 | unit: `one_carry_record_a_node` |
+| 94 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | A root's node named the real claim in its switch record, before it took anything in the new epoch: the pretender's claim is late against it | 5 | unit: `a_switch_record_witnesses`; sim: `a_pretender_after_a_remake` |
+| 95 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Taken from any node, as within an epoch: a value brought along has no word against one its user signed in the new epoch, and is left out where another brought along replaces it; a claim is late against what a root's node's record named; a number orders only among what is brought along | 3 | unit: `brought_along_from_any_node`, `the_new_epoch_has_the_last_word` |
+| 96 | Signs after the switch, as of the epoch before, statements and a proposal with numbers of its choosing | Brought along comes after what the snapshot holds and before what the new epoch signs: such a number orders only its signer's statements among what is brought along, and the proposal outranks none of the new epoch | 6, 7 | unit: `brought_along_in_between` |
+| 97 | Writes a switch record naming what it likes, or several, or one of its own after taking from peers | One a node and epoch. What it names is its node's word, as a change of that node would have been: a contest where it is a root's or the claimant's, no more | 5 | unit: `one_switch_record_a_node` |
| 98 | Signs a claim on a branch of its own, retires the key that signed it from before the claim, and shows both together; another claims the name in sight of both; then cuts off the key that retired | The first comes back over nothing: no root's node saw it hold. The two are ordered by the roots' nodes alone, which had the later one standing and the first down: the first is late, for good, and its claimant's own old stamps count for nothing | 5 | unit: `a_claim_in_sight_past_a_cut_by_the_roots_alone` |
| 99 | Unvouched a user, then has a node of its own stamp, weeks later, a change that has the user's claim and not the unvouch, to bring the claim back over one made in sight of it | The two are ordered by the roots' nodes alone: the unvoucher's own node counts for nothing. A root's node doing so, on old heads, makes the later claim late against the first, in the open: a root's word, until the claim is final; where another root's node had the later one standing and not the first, the two contest | 5 | unit: `a_witness_after_the_fact` |
| 100 | Cuts its own device key off from before a user's creation it signed, to take the user's final name | The creation stops counting as its signer's unvouch would, from where the retirement was signed: what the user signed before counts, and its claim of its own name, with its own key, holds the name on. Without another vouch the user is out, its names waiting, final ones too, until it is gone or a vouch comes | 5 | unit: `a_users_own_name_by_its_own_key` |
@@ -2445,15 +2447,15 @@ Decisions and remakes:
| 103 | Cuts the creation's key off from before it on old dependencies, then claims the user's settled names, or creates a user of its name, in a change whose history holds the user's claims and the cut and nothing else | Where the user's claim didn't stand there only by the cut, the two are ordered as claims out of each other's sight, over all the changes, with the roots' nodes alone as witnesses: they had the user's claim count first, so the new claim is late, for good, and the user keeps its names | 5 | unit: `a_claim_in_sight_past_a_cut_is_ordered_by_lateness` |
| 104 | A root cuts off the key it created users with, from before the creations, to take their names, final ones too, where only the roots create users; or a thief of a root's key gives a moved-in user first keys | A root's creation another root's node had seen stays the claim of the name, and its first keys, past a cut the root or a thief sets: a turned root takes back only what the other roots hadn't seen, never a settled or final name; the only root, all it created. The voters' cut of a stolen root key takes back what it created outside the cut, whoever saw it: one decision | 5; not promised (one root) | unit: `a_roots_creation_outlasts_its_cut_where_another_root_saw_it`, `the_voters_cut_takes_a_roots_creations` |
| 105 | A root's node, beside a thief, commits with a fresh writer on heads without the retirement a change holding what the thief's sock signed, to keep it in past the cut | A root's node witnesses past a cut, as against an unvouch: the sock stays in by it, in the open, shown with the root (`GET /registry/users/<name>`). An accomplice's vouch keeps it in too | not promised | unit: `a_cut_has_its_signers_witnesses` |
-| 106 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several carried over to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
-| 107 | Signs a claim "in the epoch before" of a name the snapshot holds | It is late against the snapshot's claim where that was settled at the base, or where a node of its side had that standing; else the two contest, as claims out of each other's sight do | 5 | unit: `carried_over_against_the_snapshot` |
+| 106 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several brought along to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
+| 107 | Signs a claim "in the epoch before" of a name the snapshot holds | It is late against the snapshot's claim where that was settled at the base, or where a node of its side had that standing; else the two contest, as claims out of each other's sight do | 5 | unit: `brought_along_against_the_snapshot` |
| 108 | Hands in again what a remake left out: a stolen laptop's `node` and `key` statements, retired since | Refuse: the root change lists the digests of the statements the base held | 3 | unit: `what_a_remake_dropped_stays_out` |
-| 109 | Commits a remake from a base a month old | Every node goes there, and its carry record names what it holds beyond the base and what it held of it (who saw what first, decisions since); each envelope comes once. A key retired since keeps what its list names. Lengths of time go on from the stamps the snapshot lists, each node's record saying what it saw broken | 2 | sim: `a_remake_from_an_old_base`; unit: `a_retirement_lists_what_it_keeps` |
-| 110 | Commits a second remake of an epoch beside another, its ID ground lower; or many | Every node goes to the one with the lower ID that it builds, carrying over what it holds, envelopes of the other among them: nothing is lost, and no count of nodes decides. Each costs every node a snapshot, lowest ID first, until one comes out | 2; not promised (how often) | sim: `two_remakes_go_to_the_lower` |
+| 109 | Commits a remake from a base a month old | Every node goes there, and its switch record names what it holds beyond the base and what it held of it (who saw what first, decisions since); each envelope comes once. A key retired since keeps what its list names. Lengths of time go on from the stamps the snapshot lists, each node's record saying what it saw broken | 2 | sim: `a_remake_from_an_old_base`; unit: `a_retirement_lists_what_it_keeps` |
+| 110 | Commits a second remake of an epoch beside another, its ID ground lower; or many | Every node goes to the one with the lower ID that it builds, bringing along what it holds, envelopes of the other among them: nothing is lost, and no count of nodes decides. Each costs every node a snapshot, lowest ID first, until one comes out | 2; not promised (how often) | sim: `two_remakes_go_to_the_lower` |
| 111 | A thief's statements are in the base of a remake | They are as they were: the snapshot holds them with their signatures, and a cut set after takes them back as it would have. A remake makes nothing final | 3 | unit: `a_cut_reaches_across_a_remake` |
| 112 | Releases a user's claim with a stolen key, and an accomplice claims; the user cuts the key off two months later | What was seen given up for `final` has stopped counting for good: the release stands, as the accomplice's claim does, final by then. A remake or none changes nothing of it | not promised (protection from a stolen key) | unit: `stopped_counting_for_good` |
| 113 | Tells a node that was away of an epoch that isn't the swarm's | The node rejoins no epoch that peers advertise: it finishes the old one from archives and builds the next itself, or takes the ID its operator gave | 1 | sim: `away_over_a_remake`, `back_by_an_id` |
-| 114 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `carried_over_one_epoch_only` |
+| 114 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `brought_along_one_epoch_only` |
| 115 | A version builds another snapshot from a remake's base | Its node gets another ID than the remake was committed for, stays, and says so: two IDs for one base show | 2 | sim: `a_remake_by_its_result` |
| 116 | A decision on the roots names its proposer the only root, or leaves a root out; the root left out signs on as one, and its node witnesses on | The voters see whom a proposal names before they vote for it. A root is one where the decision naming it holds, read where each thing it did was done: what it signs after it is left out is an ordinary user's, its node's changes after witness as no root's, and it is out unless someone vouches for it | 7 | unit: `roots_by_a_decision`, `a_root_where_it_is_one` |
| 117 | With the keys of two thirds of voters since replaced, stolen later, makes up a decision of then; or a list of voters of its own, with the number of the one that replaced them and a lower digest | What voters that others replaced decide counts only in sight of the proposal that replaced them: the first decides nothing. The second holds only until the list it would replace is final: no decision of its matter proposed out of sight of a final one holds | 7; not promised before final | unit: `the_voters_before`, `a_final_decision` |
@@ -2480,7 +2482,7 @@ Nodes and syncing:
| 133 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party (changes, bytes and operations an hour): put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` |
| 134 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` |
| 135 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_the_user_an_entry_names_beside_others` |
-| 136 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` |
+| 136 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, brought along across a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` |
| 137 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` |
| 138 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` |
| 139 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it, against its party's budget, which counts operations: the party's next changes wait until it is paid | 6; not promised (a bound on what an epoch's document costs) | argued; sim: `a_party_past_its_budget_waits` |
@@ -2532,8 +2534,8 @@ genesis change has it.
What to weigh, moving in. With one maintainer as the only root and voter, that one
settles every claim, decides alone, and sees alone what a third of the voters see,
-until it decides on others: more than one from the start is better, and a first
-list of voters once the users that take part are there. A user that comes later is created
+until it decides on others: more than one from the start is better, and a first list
+of voters once the users that take part are there. A user that comes later is created
by one root, who takes that back alone; another's vouch makes it stand without that
root's word.
@@ -2618,9 +2620,9 @@ their vectors. At every stage the existing tests pass untouched (147).
12. **Remakes.** Compaction only; a node proposing and acking by `remakeChanges` and
`remakeWriters`, and following such a remake only, by its result; the snapshot
every node builds, with whatever can still count and how far each length of time
- ran, what it leaves out and what can't be written again; carrying over: every
- node's carry record, then each envelope from any node, in its order, with the new
- epoch's word last on values, and a claim carried over against the snapshot's; a
+ ran, what it leaves out and what can't be written again; bringing along: every
+ node's switch record, then each envelope from any node, in its order, with the new
+ epoch's word last on values, and a claim brought along against the snapshot's; a
retirement's list as its cut; decisions over a remake; lengths of time going on;
two remakes of an epoch, to the lower ID. A node keeping the epochs it left on
disk, peers answering for them and saying which; a node walking them, or rejoining
@@ -2678,8 +2680,8 @@ Checked in the code:
(`document::meta`, `swarm::members`); the genesis change doesn't set them. A
federated node reads them from its configuration alone (`--libp2p-relays` exists).
* A snapshot records the highest number per actor in its base, by which a node tells
- what it holds beyond it (`remake::snapshot`, `remake::delta`). A federated node tells it
- from the changes beyond the base, which it holds.
+ what it holds beyond it (`remake::snapshot`, `remake::delta`). A federated node
+ tells it from the changes beyond the base, which it holds.
Checked upstream, in Automerge 0.12: a second change at an actor's number is refused,
with the whole batch it came in (`DuplicateSeqNumber`); the change that made an
@@ -2711,7 +2713,7 @@ refused member shows; the cost of checking a signature; a node keeps the documen
epochs it left for a while (`archiveRetention`: 2 epochs, 30 days), and every node
builds a remake's snapshot itself today; a coordinator fixes the electorate in its
proposal; a node that was away rejoins the epoch enough ready members advertise, and
-has its own writes carried over within the replay window, the rest quarantined; a
+has its own writes replayed within the replay window, the rest quarantined; a
member votes for one remake of its epoch at a time, and a compaction's base is fixed
by the coordinator when it commits.
@@ -2738,7 +2740,7 @@ Assumed, to be shown as it is built:
* The snapshot of a federated remake, built from the resolved registry, comes out
byte for byte the same on every node, as today's does from the document.
* A node can keep on disk, and answer sync for, an epoch it left.
-* A node can commit its carry record (the digests of what it holds beyond a base, and
+* A node can commit its switch record (the digests of what it holds beyond a base, and
what it held of it) before it takes anything from a peer, at a registry's size.
* What was seen for long is kept as the node goes, per voter's node and per thing
watched (a user out, a claim holding its name, a decision holding, a thing