aboutsummaryrefslogtreecommitdiffstats
path: root/docs
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-14 12:15:16 +0000
committertv <tv@krebsco.de>2026-11-14 12:15:16 +0000
commit6a87b812fe65dfb23dc21d7634de3b6e58344322 (patch)
tree5aff510a35efa566fd1bf053a8b55a367be12558 /docs
parent9c9dd8ad7a339be4434efee9bb6c0d144b1a8c91 (diff)
federation: what it asks of the document, and where Automerge sets limits
The design leaned on Automerge in places it didn't say: writers that cost memory, one change per writer and number, changes Automerge applies and shouldn't, the order of values written at once, maps made at one key, history held in memory, bytes that versions must agree on. A section near the start says what the design asks of the document, and nothing else of it is read: changes named by their hashes, each judged at its history; the document at a set of changes, the same on every node; a writer for each change; history kept as long as the store keeps it, and remakes. A section at the end says, for each of Automerge's seven limits, what Automerge does, what the design does about it, and what would go without it. Every rule that is there only for one of them points to it in place. "Writer" is the design's word for the identity a node writes under; "actor" stays with Automerge.
Diffstat (limited to 'docs')
-rw-r--r--docs/federation.md283
1 files changed, 170 insertions, 113 deletions
diff --git a/docs/federation.md b/docs/federation.md
index ce5f2f2..a2618b6 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -36,7 +36,7 @@ party may be malicious, alone or together with others, a root too.
What an adversary can do:
* run nodes, and once it is in, bring in users of its own;
-* craft any change: under any actor, with any dependencies (so "made long ago", as
+* craft any change: under any writer, with any dependencies (so "made long ago", as
the document sees it), any operations;
* send different changes to different peers, send none, or pass on only some;
* delay or drop messages between any nodes for as long as it likes, short of forever
@@ -164,8 +164,8 @@ What is not promised:
of the voters see, it sees alone. And as the only root, its cut takes back a name
only its creation holds, final or not (Cuts).
* **A bound on what an epoch's document costs.** What is valid as written every node
- holds until a remake: statements past a limit, writers started past
- `limits.writers`, a change of a few bytes that holds a million operations, a
+ holds until a remake: statements past a limit, writers started past `limits.writers`
+ (Automerge: writers), a change of a few bytes that holds a million operations, a
snapshot built for every remake a node is offered. Each costs memory and time, and
nothing bounds how many reach a node as part of others' histories: a limit and a
party's budget bound how fast a node takes them from the party itself. Who did it
@@ -176,10 +176,10 @@ What is not promised:
allow; but each
remake of an epoch a node is offered costs it a snapshot, the lowest ID first,
until one comes out to the ID it was committed for.
-* **A swarm that never splits.** A node that forks its own actor (two changes with one
- number) splits the honest nodes that took one from those that took the other, until
- one side drops its own (Partitions). It is found, proven and named; it isn't
- prevented.
+* **A swarm that never splits.** A node that forks its own writer (two changes with
+ one number) splits the honest nodes that took one from those that took the other,
+ until one side drops its own (Partitions; Automerge: one change a number). It is
+ found, proven and named; it isn't prevented.
How sure: 1 to 4 follow from how changes are judged today plus rules of the same
shape, and from Kleppmann's result that a hash-linked change graph whose validity
@@ -200,6 +200,28 @@ go by being unvouched; each has its namespace; names of declared kinds are held
user each; what a key signed can be cut off after the fact; and the swarm decides by
its voters' votes.
+### What the design asks of the document
+
+The design reads one thing: a set of changes, each naming the changes before it by
+their hashes (its dependencies), committed and signed by a node, and writing to paths
+in one tree of maps. Of it, the design asks:
+
+* **A change's history**: the changes it names, theirs, and so on, fixed by its hash:
+ what its writer had seen. Every rule reads a change at its history and nothing else
+ (Why it holds).
+* **The document at a set of changes**: the tree its writes make, the same on every
+ node for the same set; where two changes wrote one place at once, both writes held,
+ in an order every node finds alike.
+* **A writer for each change**: the identity a node writes changes under, the node's
+ (its signature proves it), each of its changes numbered after the one before.
+* **History kept** as long as the store keeps it, and a remake that starts the
+ document anew from a set of changes, every node building the same (Remakes).
+
+Nothing else of the document is read. Continuum's document is an Automerge document,
+which gives all of it and sets limits the design works around. Each is said under
+Where Automerge sets limits, and a rule that is there only for one of them says so in
+place, as (Automerge: writers).
+
### The policy, in the genesis change
A federated swarm's policy is
@@ -344,36 +366,36 @@ grows. A statement is signed by one user and says one thing:
for the swarm, such a user is the party that carries for it. Nothing is signed in
its place. It names nodes of more than one party where it can: each records for it,
so no one of them alone keeps it from counting, nor chooses the day.
-* **Writers.** A node writes as a writer (an Automerge actor), a fresh one each time
- it starts, rejoins or drops *(docs)*, and when a change of its own writer that it
- didn't make reaches it signed with its own key: a copy of its files writes as it
- too. Unsigned, such a change is anyone's forgery, and switches nothing *(checked:
- `access::screen`)*. Every writer costs every node memory while the epoch lasts, in
- proportion to the document's history: about 4 bytes per change *(measured
- upstream)*. So a federated node keeps its writer over a clean stop, and each node
- counts the writers each user's nodes start in the epoch: past `limits.writers`, a
- change that starts 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 (`GET /registry/users`), for a remake to come first.
+* **Writers.** A node writes as a writer (What the design asks of the document), a
+ fresh one each time it starts, rejoins or drops *(docs)*, and when a change of its
+ own writer that it didn't make reaches it signed with its own key: a copy of its
+ files writes as it too. Unsigned, such a change is anyone's forgery, and switches
+ nothing *(checked: `access::screen`)*. Every writer costs every node memory while
+ the epoch lasts, in proportion to the document's history (Automerge: writers). So a
+ federated node keeps its writer over a clean stop, and each node counts the writers
+ each user's nodes start in the epoch: past `limits.writers`, a change that starts
+ 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
+ (`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
operations an hour, recommended 600 changes, 4 MiB and 100 000 operations a party.
@@ -1048,19 +1070,19 @@ key off.
A federated swarm remakes as every swarm does ([`remakes.md`](remakes.md)): a node
proposes and coordinates, the alive peers ack, and every node builds the next epoch
-itself and switches. Nothing the swarm decides goes through it, and nothing that counts
-changes by it: it keeps the document small, 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.
+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.
* **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.
* **When.** A node proposes a remake by itself once the epoch's history holds
`remakeChanges` changes beyond its root change, or its changes started
- `remakeWriters` writers, after a random wait, unless one is under way; and acks one
- whose proposal has that in its history. It follows only a remake whose base holds
- that. So remakes come as the document grows, nobody asking, and no faster, whoever
- proposes them.
+ `remakeWriters` writers (Automerge: writers), after a random wait, unless one is
+ under way; and acks one whose proposal has that in its history. It follows only a
+ remake whose base holds that. So remakes come as the document grows, nobody asking,
+ 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
@@ -1416,18 +1438,8 @@ is:
### What every node judges
-A change is first of all one that Automerge itself writes, or it is refused before
-Automerge sees it, in every swarm *(checked: `document::changes::Written`)*: its bytes
-are the ones Automerge encodes for it; its first operation is numbered one after the
-highest of its dependencies; it is its actor's first, or builds on the one before;
-every operation it names was made in its history and is what it is named as (the
-object written into, the element of that list, a value or an object at that place);
-and every operation is one Automerge's transactions write, but for tables and marks,
-which continuum doesn't write and are refused too *(checked, and generated:
-`what_passes_leaves_automerge_sound`)*. Automerge 0.12 applies changes that are none
-of these, and then panics, saves a document that doesn't load, or holds another change
-than it was given *(measured upstream)*. All of it is asked of the change and its
-history, as the rules are.
+A change is first of all one the document itself writes, or it is refused before the
+document takes it, in every swarm (Automerge: changes it shouldn't apply).
A change is valid if, in the document at its dependencies:
@@ -1564,12 +1576,12 @@ the steps before:
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
- 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, directly or along `prev`, is left out; of the rest, those that count,
- in Automerge's order. Where the one there doesn't count, the last that does, back
- along `prev` (read in the document at the dependencies of the change that
- replaced it).
+ 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,
+ 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
+ dependencies of the change that replaced it).
A node keeps the resolved registry as it goes (a statement changes it around its own
name), and answers from it:
@@ -1620,12 +1632,12 @@ it. That happens by three things, and each shows:
refuses what the other takes; a node told so judges what it holds again and logs
that the policies disagree *(docs)*. Where they only resolve differently, their
stamps show it (Continuum changing under a swarm).
-* **An actor forked.** A node committed two changes under one actor and number and
- gave each to some. Automerge holds one change per actor and number, so a node
- holding one can't take the other, nor anything built on it *(checked upstream)*.
- Both carry the same node's signature: a node offered the second holds proof, shows
- it, and refuses the forking node from then on. (Today it refuses the second as
- forged, by whoever brought it *(checked: `document::signatures`)*.)
+* **A writer forked.** A node committed two changes under one writer and number and
+ gave each to some. A node holding one can't take the other, nor anything built on it
+ (Automerge: one change a number). Both carry the same node's signature: a node
+ offered the second holds proof, shows it, and refuses the forking node from then on.
+ (Today it refuses the second as forged, by whoever brought it *(checked:
+ `document::signatures`)*.)
Coming back is the side's own choice, never forced: an operator has the node **drop**
what the others refuse (`POST /admin/refused/drop`, naming the peer whose word it
@@ -1637,7 +1649,7 @@ that has in its history what its signer saw. Those that no longer fit stay there
for the user to sign again: one replacing a value that is gone, or naming a change
that was dropped.
-Which side drops, for a fork of an actor? No rule can say: the forking node may have
+Which side drops, for a fork of a writer? No rule can say: the forking node may have
ground the hash of the change it kept back, and a rule by hash would let it make
everyone drop a year's work. A node shows which of the two the roots' nodes hold,
and the operator follows them or doesn't. A node that just joined and got the lone
@@ -1711,9 +1723,9 @@ takes along those of the nodes that carry for a user it holds.
What every node pays, per thing: in memory, on disk, on the wire and in time. Measured
where it says so; else from the design's own numbers. Automerge 0.12.0 holds a
document of small writes at about 0.2 KB of heap a change, its bytes besides, and 4
-bytes for every change and writer of the epoch, whenever the writer started
-*(measured upstream)*: the heap goes by changes × (0.2 KB + 4 B × writers), and both
-factors grow with the epoch.
+bytes for every change and writer of the epoch, whenever the writer started *(measured
+upstream)*: the heap goes by changes × (0.2 KB + 4 B × writers), and both factors grow
+with the epoch (Automerge: writers, history).
| What | What it costs every node |
|---|---|
@@ -1775,7 +1787,7 @@ the design recommends; who acts, and how. A node shows each where it waits on it
| the age of the last change of the roots' nodes the node holds | twice `stamp` | its seeds; tell the roots |
| peers in another epoch (`GET /peers`) | longer than a switch delay and `catchUp` | a peer that keeps the epoch, or the ID (`POST /admin/epochs/rejoin`) |
| a committed remake whose ID the node doesn't get | at once | versions differ: upgrade, or report it |
-| a refused peer, a forked actor proven (`GET /peers`, `sync.refusedPeers`) | at once | drop (`POST /admin/refused/drop`), or not |
+| a refused peer, a forked writer proven (`GET /peers`, `sync.refusedPeers`) | at once | drop (`POST /admin/refused/drop`), or not |
| two digests for the same changes; a check of itself that differed | at once | upgrade, or write on (`POST /admin/check/accept`) |
| a policy the node doesn't know | at once | upgrade, or refuse the decision |
| a proposal its bounds would refuse, or a policy that breaks them (`GET /registry/decisions`) | while the votes run | tell the voters; refuse it when decided, or change the bounds |
@@ -1809,6 +1821,52 @@ the design recommends; who acts, and how. A node shows each where it waits on it
| a moved-in user without keys that came to it | at once | give it its first keys |
| its own keys | stolen | ask the voters for first keys with a cut |
+### Where Automerge sets limits
+
+Automerge 0.12 gives what the design asks of the document, with seven limits. For each:
+what Automerge does, what the design does about it, and what would go without it.
+
+* **Writers.** Every writer costs every node 4 bytes of heap for every change of the
+ epoch, whenever it started *(measured upstream)*: the heap grows with changes times
+ writers. For it: a node keeps its writer over a clean stop; `limits.writers`, the
+ count of writers, what is put off past the limit and `writersFor` (Users);
+ `remakeWriters` (Remakes); the heap under What it costs; the rows of writers. With
+ clocks that cost nothing per writer all of it would go, and a writer for every
+ change would end the next limit.
+* **One change a number.** Automerge holds one change per writer and number, where
+ Kleppmann's construction names a change by its hash *(checked upstream)*. So a node
+ that commits two changes under one writer and number parts the honest nodes that
+ took one from those that took the other, until one side drops (Partitions; what is
+ not promised). A writer for every change, named by the change's hash, would end it;
+ under the limit before, it costs the square of the changes (Roads not taken).
+* **Changes it shouldn't apply.** Automerge 0.12 applies changes it never writes
+ itself, and then panics, saves a document that doesn't load, or holds another change
+ than it was given *(measured upstream)*. So a change is refused before Automerge
+ sees it, in every swarm, unless it is one Automerge writes *(checked:
+ `document::changes::Written`)*: its bytes are the ones Automerge encodes for it; its
+ first operation is numbered one after the highest of its dependencies; it is its
+ writer's first, or builds on the one before; every operation it names was made in
+ its history and is what it is named as (the object written into, the element of that
+ list, a value or an object at that place); and every operation is one Automerge's
+ transactions write, but for tables and marks, which continuum doesn't write and are
+ refused too *(checked, and generated: `what_passes_leaves_automerge_sound`)*. All of
+ it is asked of the change and its history, as the rules are.
+* **Values written at once.** Of two values written at one place at once, Automerge
+ shows first the one whose operation is numbered higher, and a writer numbers its
+ operations as high as it likes. So whose value counts never rests on that order
+ alone: one another replaces along `prev` is left out, and a value of the new epoch
+ has the last word over one of an epoch before (Resolving 5).
+* **Maps made at one key.** Two changes that make a map at one key at once make two,
+ and reads show them as one *(docs)*: judging and resolving read them so. Two claims
+ of a name nobody claimed yet each make its register (Why it holds).
+* **History.** Automerge holds every change of the document in memory, and loading a
+ document or taking a sync message walks them. So a swarm remakes as its document
+ grows (`remakeChanges`, Remakes). A store that kept history on disk would remake for
+ disk only, or never: nothing that counts rests on a remake.
+* **Bytes.** Automerge encodes a change, and the document it builds from the same
+ changes, to the same bytes within a version. Versions must agree on them, and on
+ what Automerge makes of the same changes (Continuum changing under a swarm).
+
## Why it holds
**Promise 1**, by how a change is judged: every node judges a change before applying
@@ -1818,13 +1876,13 @@ at the change's dependencies alone.
**Promise 2.** Whether a change is valid depends on the change and its history; its
hash covers both. So honest nodes agree on every change, hold the same valid changes
-once each has what the other has, and Automerge gives the same document for the same
-changes. Resolving is a function of the changes. Everything it reads is fixed by
-hashes: a statement's place is what it says it saw, a witness's word is its change's
-history, and a proposal is decided by its records' histories. A node's clock, and the
-order things reached it in, enter only into what its own node writes (its stamps,
-taking a proposal up, its acks, and as a coordinator the base), never into what it
-reads from the document. What must hold for this, and doesn't everywhere today:
+once each has what the other has, and the document is the same for the same changes.
+Resolving is a function of the changes. Everything it reads is fixed by hashes: a
+statement's place is what it says it saw, a witness's word is its change's history,
+and a proposal is decided by its records' histories. A node's clock, and the order
+things reached it in, enter only into what its own node writes (its stamps, taking a
+proposal up, its acks, and as a coordinator the base), never into what it reads from
+the document. What must hold for this, and doesn't everywhere today:
* the root change given, never learned;
* no window without a policy (it is in the genesis change), and no syncing under a
@@ -1835,17 +1893,15 @@ reads from the document. What must hold for this, and doesn't everywhere today:
have the registers of users and claims, the decisions and what is uncovered;
* nothing a node keeps a bounded number of decides validity: a change pushed out of
the waiting ones comes again *(checked: `MAX_WAITING`)*;
-* a change being what Automerge itself writes. Automerge 0.12 applies some that
- aren't, and then holds another change than the one it was given: under the hash
- received it gives back a change with another hash, and its save doesn't load
- *(measured upstream)*. Screening refuses those before Automerge sees them;
-* a register made by two changes at once holding what both put there. Two claims of
- a name nobody claimed yet each make its register, and after a remake every node
- makes the same registers; reads show maps made at one key as one *(docs)*, and
- judging and resolving must read them so;
-* one change per actor and number. A forked actor breaks "hold the same changes"
- until one side drops. Automerge names a change by actor and number where
- Kleppmann's construction needs the hash.
+* a change being one the document itself writes: Automerge applies some that aren't,
+ and then holds another change than the one it was given, under the hash received
+ (Automerge: changes it shouldn't apply);
+* a register made by two changes at once holding what both put there. Two claims of a
+ name nobody claimed yet each make its register, and after a remake every node makes
+ the same registers; reads show maps made at one key as one, and judging and
+ resolving must read them so (Automerge: maps made at one key);
+* one change per writer and number: a forked writer breaks "hold the same changes"
+ until one side drops (Automerge: one change a number).
**Promise 3.** A value counts only with an envelope whose signature checks against a
key that step 2 gives its user for the change that carries it. A key is a user's only
@@ -2072,17 +2128,17 @@ far as the roots' nodes' witness.
* **A registry of only what is signed**, from the start: nothing unsigned ever
counts, but it is incomplete for as long as users take to come, and what reads it
needs the repository beside it meanwhile.
-* **An actor for every change, made from the change** (the hash of its bytes with the
- actor left out, 32 bytes, number 1): two changes could never share an actor and a
- number, so a fork of an actor would be two changes that every node holds, shown
- and parting nobody. It is what Kleppmann's construction asks for, and a receiver
- checks it with one hash. But Automerge 0.12 keeps a slot per actor in every clock
- it caches, and moves its indices for every actor that comes, so memory and time
- grow with the square of the changes: 10^4 changes take 32 to 257 MB of heap and 2
- to 20 ms to apply one more, 10^5 take 2.7 GB at least and 0.16 s *(measured
- upstream)*. A hundred nodes stamping daily write 10^4 changes in a hundred days.
- So a fork of an actor is proven and named, and not prevented, for as long as
- Automerge's clocks grow with its actors.
+* **A writer for every change, made from the change** (the hash of its bytes with the
+ writer left out, 32 bytes, number 1): two changes could never share a writer and a
+ number, so a fork of a writer would be two changes that every node holds, shown and
+ parting nobody. It is what Kleppmann's construction asks for, and a receiver checks
+ it with one hash. But Automerge 0.12 keeps a slot per writer in every clock it
+ caches, and moves its indices for every writer that comes (Automerge: writers), so
+ memory and time grow with the square of the changes: 10^4 changes take 32 to 257 MB
+ of heap and 2 to 20 ms to apply one more, 10^5 take 2.7 GB at least and 0.16 s
+ *(measured upstream)*. A hundred nodes stamping daily write 10^4 changes in a
+ hundred days. So a fork of a writer is proven and named, and not prevented, for as
+ long as Automerge's clocks grow with its writers.
* **Saying what was held by the order of a node's first changes** after a remake: an
order says one thing, and what a node held of a claim, an unvouch and a value are
three. The node states them.
@@ -2116,10 +2172,10 @@ far as the roots' nodes' witness.
votes, would decide for all of them. Its own nodes record, and commit nothing
else.
* **A document per user**, each written by one party, a claim counted across them (as
- in Secure Scuttlebutt's feeds). A fork of an actor then spoils only the forker's
- own document, not the swarm, which is the one thing this design can't give. It
- needs what continuum doesn't have: many documents, and what one had seen of the
- others recorded by hand. One Automerge document records that by itself.
+ in Secure Scuttlebutt's feeds). A fork of a writer then spoils only the forker's own
+ document, not the swarm, which is the one thing this design can't give. It needs
+ what continuum doesn't have: many documents, and what one had seen of the others
+ recorded by hand. One document records that by itself.
## What members are trusted with, then
@@ -2229,10 +2285,11 @@ author remembered to say. So the design goes by what nodes compute:
What can't change under a swarm, whatever is decided: how an envelope is read and what
its signature covers (a snapshot carries envelopes as they were signed, from epoch to
-epoch); a statement's digest; a change's hash, and what Automerge makes of the same
-changes; the bytes Automerge encodes a change to (screening refuses a change whose
-bytes its own Automerge wouldn't write); a snapshot's bytes for the same base and
-policy. A new form of any of them comes beside the old one, under a policy.
+epoch); a statement's digest; a change's hash, and what the document makes of the same
+changes; the bytes a change is encoded to (screening refuses a change whose bytes its
+own Automerge wouldn't write); a snapshot's bytes for the same base and policy
+(Automerge: bytes). A new form of any of them comes beside the old one, under a
+policy.
What changes freely: everything a node does for itself. Its API, its storage, how it
syncs and with whom. The wire is between two nodes, not the swarm's: a version
@@ -2412,7 +2469,7 @@ Nodes and syncing:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
| 124 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
-| 125 | Forks its node's actor | The nodes that took each split; one offered both holds proof and refuses the node; a side drops by its operator's choice | not promised | sim: `a_forked_actor_is_proven`, `a_side_drops_a_fork` |
+| 125 | Forks its node's writer | The nodes that took each split; one offered both holds proof and refuses the node; a side drops by its operator's choice | not promised | sim: `a_forked_actor_is_proven`, `a_side_drops_a_fork` |
| 126 | Holds changes back, or passes on some | They come by other nodes; a joiner caught up with it syncs on | 6 | sim: `withheld_changes_arrive` |
| 127 | Places its nodes around a victim by choosing their keys | The victim's node keeps its seeds and its user's other nodes as neighbours; a claim not settled for long shows. It costs time, not names | 5, 6 | sim: `around_a_victim` |
| 128 | Hands a joining node another root change, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
@@ -2537,7 +2594,7 @@ their vectors. At every stage the existing tests pass untouched (147).
it, the names of a user that is out waiting, gone, nothing taken from an unvouched
user's nodes, what comes back with a vouch. Tests: 24, 26 to 31, 33, 34, 61 to 64,
66, 98 to 105.
-8. **Coming back.** The drop an operator asks for, a forked actor proven and shown
+8. **Coming back.** The drop an operator asks for, a forked writer proven and shown
with what the roots' nodes hold, the budget and the share per party, the writers
counted per user, for the one a node's member entry names, a node keeping its
writer over a clean stop. Tests: 125, 132 to 137, 139 to 141.