From 6ae5da042629d085a2410bcca68a4d697a44854a Mon Sep 17 00:00:00 2001 From: tv Date: Sun, 15 Nov 2026 20:25:37 +0000 Subject: federation: started by its genesis change; votes kept across a remake A federation starts with a swarm of its own, its genesis change writing the federated policy and the first version: nothing is from before it, so the time before, the federating change and values from before go, and nothing writes the policy's place after the genesis change. A running swarm doesn't become federated; that is left as a road not taken. A remake replays a party's votes before its key sets where neither saw the other, so a vote counts as cast across a remake too; a party that wrote two key sets at once is answered as one voting twice. A version is replayed in one change with the keys it sets, and a replay holds for any base. A `null` the epoch's first change holds goes only at a remake, and housekeeping deletes one only where this epoch's history holds what it covers. A node is a member while the party its own entry names lists it; another party's list does nothing. A proposal counts as written, like a vote. A fork is named by its first version and the heads it names, in its genesis change; `went/` says where to those who follow. Leftovers: the unsigned key envelope's meta; "can bring back" reaching deletions; the first link checked against the place as the deletion leaves it; "is left out"; the attack rows, renumbered. --- docs/federation.md | 254 ++++++++++++++++++++++++++++------------------------- 1 file changed, 134 insertions(+), 120 deletions(-) diff --git a/docs/federation.md b/docs/federation.md index 6099caf..0778374 100644 --- a/docs/federation.md +++ b/docs/federation.md @@ -14,9 +14,9 @@ are marked *(checked)* where they were read in it. ## Optional -A swarm is federated once its policy says so. It can say so from the genesis change, -or later (Becoming federated). Nothing else changes: a swarm that doesn't say so stays -as it is, its registry, rules, remakes and replay included. Continuum's wire version +A swarm is federated from its genesis change, or not at all (Starting a federation). +Nothing else changes: a swarm that isn't stays as it is, its registry, rules, remakes +and replay included. Continuum's wire version says only whether a node can take part in a federation at all; which federation a swarm follows is a number of its own, in its policy: this design is federation 1 (Changing the federation). A swarm leaves the federation as any group carries on: by @@ -101,8 +101,7 @@ federation's. ### What it asks of the document * **A change's history**, fixed by the change's hash: what its writer had seen. A - change is judged at its history and nothing else, but for one rule: nothing is - added to the time before the swarm was federated (Becoming federated). + change is judged at its history and nothing else. * **The document at a set of changes**: the tree its writes make, the same on every node for the same set. A deletion removes what its writer saw, and nothing written at the same time. @@ -118,7 +117,7 @@ worth knowing (Where Automerge sets limits). A federated swarm's `_continuum/access/policy` is `{"version": 2, "federated": true}`. What the policy says is in its **versions**, a chain: each is a string of JSON, named by the SHA-256 of its bytes, numbered, and naming the version it changes (none for -the first, number 0, which only the federating change writes; a fork's first, Forks): +the first, number 0, which only the genesis change writes; a fork's first, Forks): ```json { "federation": 1, "number": 7, "changes": "", @@ -173,21 +172,21 @@ version. | `_continuum/federation/nodes/` | its nodes' IDs | that party | | `_continuum/federation/went/` | the fork it went to | that party | -What a party writes is an envelope, signed by one of its keys. A version, and the -keys a version sets, are written unsigned, and count by the votes the version had. A -proposal's place takes only the proposal. Of continuum's own -data, a federated swarm keeps what nodes write for the protocol (member entries, -remakes and their acks, epochs), written by members as in every swarm; a member's -change carries its node's signature, as signatures are required in a strict swarm. It -has no user registry: `_continuum/users`, bans, and every other entry of -`_continuum/access` are closed, and nothing reads them. A party logs in to its own -nodes as its operator sets up, and a node takes tokens only from the nodes its own -party lists. +What a party writes is an envelope, signed by one of its keys. A version, and the keys a +version sets, are written unsigned, and count by the votes the version had. A proposal's +place takes only the proposal. Of continuum's own data, a federated swarm keeps what +nodes write for the protocol (member entries, remakes and their acks, epochs), written +by members as in every swarm; a member's change carries its node's signature, as +signatures are required in a strict swarm. It has no user registry: `_continuum/users`, +bans, and every other entry of `_continuum/access` are closed, and nothing reads them. A +party logs in to its own nodes as its operator sets up, and a node takes tokens only +from the nodes of its own party (Nodes). ### Changing the policy A **proposal** is a version a party writes at -`_continuum/federation/proposals//`, its hash the version's. +`_continuum/federation/proposals//`, its hash the version's. Like a vote, +it counts as written, by the keys its party had at its history, until it lapses. A party **votes** on a proposal by writing `true` or `false` at `_continuum/federation/votes///`: the version the proposal @@ -253,15 +252,18 @@ naming another (Changing the federation). A party's keys are at `_continuum/federation/keys/`: one envelope, the set, signed with a key of the set it replaces, numbered as any envelope. The change that -writes a version setting a party's keys writes them there too, and only that change: -an envelope without a signature (`cv2...`), the keys the version sets and -no others, its meta naming that version, `prev` and `seq` as any envelope's. It is +writes a version setting a party's keys writes them there too, and only that change, +or it is refused: an envelope without a signature (`cv2...`), the keys the +version sets and no others, its meta naming that version, the party as its user, `at` +0, `prev` and `seq` as any envelope's, so that its bytes are the version's. It is ahead of every set written under an earlier version, and the party's next set names it as the one it replaces. * **A value counts only while the key that signed it is among its party's keys**, - votes excepted, which count as cast. Changing keys is: write the new set, and sign - again what should stay (a client does that, its deletions too). + votes and proposals excepted, which count as written. Changing keys is: write the + new set, and sign again what should stay (a client does that, its deletions too). A + key added back, from a backup say, can bring back what it signed, and what a `null` + of its party covered once that `null` went (What counts). * **Only a version revokes a key.** A party changing its keys by itself adds keys and tidies; but a key it drops can still sign, at a history from before the drop, a set of its own numbered past the party's, and nothing in the document tells which of two @@ -283,16 +285,18 @@ whole. These count no more, and nothing else is stale: 1. a value at a place its party may not write by the current version: the party is no longer one, the place went to another, a rule changed; and of a party that is no longer one, its keys and its node list; -2. a value signed by a key that isn't among its party's, votes excepted; +2. a value signed by a key that isn't among its party's, votes and proposals + excepted; 3. a proposal on a version that isn't current, and the votes on that version; 4. a version behind the current one: of a lower number, or of its number with the higher hash; 5. an envelope behind another at its place; -6. the member entry of a node no party lists; -7. a value written before the swarm was federated, unless a party's key signed it and - the first version lets that party write there; -8. a party's `null` where everything its place ever held, as the deleting change's - history has it, was signed by keys its party no longer holds. +6. the member entry of a node its own party doesn't list (Nodes); +7. a party's `null` where the deleting change's history holds everything its place + held before it in this epoch, from empty, all signed by keys its party no longer + holds. A `null` the epoch's first change holds goes only at a remake (Remakes), as + what it covers isn't in this epoch's history to judge by. Judging it reads the + place's history: slow, not wrong. **Any member may delete what counts no more**, place by place, never a map holding places; every node judges the deletion by the document the deleting change makes. That @@ -306,17 +310,18 @@ at a history where the version it names is current, and counts if its key is amo party's and its party may write there: a place taken from a party and given back may show what the party had there. Whatever the party writes there under a later version is ahead of it. So a party's `null` stays while what it covers could come back and -count: it goes once that was all signed by keys its party dropped (8, above), or at a +count: it goes once that was all signed by keys its party dropped (7, above), or at a remake (Remakes). Neither happens by itself; either can, so that a swarm that never remakes can be kept from growing with every name ever deleted. ### Nodes A party lists the nodes that carry for it, by node ID, at -`_continuum/federation/nodes/`. Only a listed node is a member: it registers, -commits changes and syncs, and nodes sync with members only (Stages). A node's party is -its operator's, in its configuration, and it takes tokens only from the nodes its party -lists; another party listing it changes nothing for either. A node commits whatever +`_continuum/federation/nodes/`. A node's party is its operator's, in its +configuration, and its own member entry names it. A node is a member while that party +lists it: it registers, commits changes and syncs, and nodes sync with members only +(Stages); it takes tokens only from the nodes that party lists. Another party's list +does nothing. A node commits whatever envelopes it is given, its party's and others' alike: what counts is who signed a value, not which node committed it. So a party without nodes of its own writes through any node that takes its envelopes. @@ -335,11 +340,12 @@ the group won't follow passed, the parties can't agree, or it leaves the federat every party's keys; judged by none, as an epoch's first change is. Every proposal is a chance to fork: the version is usually one that didn't pass. To leave the federation, the genesis holds another policy instead, and what it needs. -2. A fork is named by its genesis change's hash, which nobody chooses: the first change - after it, by any member, writes it at `_continuum/swarm`, as every node checks, and - remakes carry it like any value. An envelope's meta names it. The genesis change - holds envelopes as the old document read them, and they count, whatever swarm they - name; beyond them, nothing signed for one swarm is taken in another. +2. A fork is named by the hash of its first version together with the heads it names, + which nobody can steer to a given name, the old swarm's least of all: its genesis + change writes it at `_continuum/swarm`, as every node checks, and an envelope's meta + names it. The genesis change holds envelopes as the old document read them, and they + count, whatever swarm they name; beyond them, nothing signed for one swarm is taken + in another. 3. The others join it as a node joins any swarm, by its genesis change's hash. A node that holds the old document checks the new one against it first, the same at those heads but for what step 1 leaves out; says what it holds that those heads lack; and @@ -352,10 +358,11 @@ nothing there, and what it had counts no more; to come back, the fork's parties in by a version, as they would anyone new. A fork's version may name parties that weren't among the first to go (every party its founders consider honest, say), so that they can follow whenever they like, without asking. A party that goes may say where, -at `went/`. +at `went/`: the fork's genesis change, for those who follow it. What a party's nodes do of themselves is their operators' business, written nowhere: -join a fork where parties their operator follows went, vote as those voted, vote by +join a fork where parties their operator follows went (`went/`), vote as those +voted, vote by bounds their operator set, or do nothing without their operator. So a federation that cooperates can have a group that leads without being named: the active parties the others follow. @@ -373,23 +380,14 @@ Routine work needs no vote: a version gives a party a zone or a block by one rul (`ip4/10/243/7/*`), and a new host is a write where its party may write. Votes are for parties, zones, blocks and names that are nobody's by their spelling. -### Becoming federated +### Starting a federation -A swarm becomes federated by one change: it writes the federated policy and the first -version, by one who may write the policy. From then on a change is taken only if that -change is in its history, or it is in that change's history; any other is refused, -received or held, and a node that held one beside it drops it, with what builds on -it, once a peer tells it so. It is continuum's rule for a swarm turned strict -*(checked: `access::rules`, `before_strict`)*, read for the federating change: the one -the writes of the policy lead back to. One written beside it, federating too, is -refused like any other, so a change made later to look as old can't take its place; -two at once split the nodes that took one from those that took the other, and the -parties fork from one. Nothing writes the policy's place after it: the federation -changes by versions. A swarm federated from its genesis change has no time before. - -What was written before counts only where a party's key signed it and the first -version lets that party write there: the parties sign again what they keep. An -envelope from before names no version, and is behind every one that does. +A federation starts with a swarm of its own: its genesis change writes the federated +policy and the first version, with the keys it sets, as a swarm strict from its start +records its policy (`--bootstrap-policy`) *(checked: `swarm::bootstrap`)*. So nothing is +from before the federation, and nothing writes the policy's place after the genesis +change: the federation changes by versions, and is left by a fork. A running swarm +doesn't become federated; its parties start one, and sign into it what they keep. ### Remakes @@ -401,29 +399,38 @@ is continuum's as in every swarm. What a federated node asks of a remake: document reads as the old one did at the base, at every place and every path of the federation, as continuum reads it. A node checks that before it switches, stays where it is otherwise, and never rejoins an epoch it refused. -* **Writes after the base** are replayed as the policy shapes them, as continuum replays - under a strict policy: at each place, the chain of envelopes that leads from what the - new document holds there to what the old one reads, each in a change of its own, - judged again in the new epoch, each after those its change builds on, clocks only - between changes neither of which saw the other *(checked: `remake::delta`)*. Versions - written after the base are replayed with them, and whatever names a version before - the next, each judged by the votes replayed before it. Whether a place is held - already goes by version number, then `seq`. What the new epoch refuses (its key was - dropped by a version, its place given to another) goes to the quarantine of the - node that holds it, and its party signs it again if it still may. +* **Writes after the base** are replayed as the policy shapes them: at each place, the + chain of envelopes that leads from what the new document holds there to what the old + one reads, each in a change of its own, judged again in the new epoch, the other + writes with them, each after those its change builds on, clocks only between changes + neither of which saw the other, as continuum replays under a strict policy + *(checked: `remake::delta`)*. Versions written after the base go with them, each in + one change with the keys it sets, whatever names a version before the next, each + judged by the votes replayed before it. Of changes neither of which saw the other, a + party's votes go before its key sets, so that a vote is replayed where its key is its + party's, as where it was cast. Whether a place is held already goes by version + number, then `seq`. What the new epoch refuses (its key was dropped by a version, its + place given to another) goes to the quarantine of the node that holds it, and its + party signs it again if it still may. * **Housekeeping after the base** isn't replayed: what it deleted is stale again, and is deleted again. But where a chain starts on an empty place (`prev` empty) and what - the new document holds there counts no more by the versions replayed so far, the + the new document holds there counts no more by what was replayed so far, the replaying node deletes that in the first link's own change, judged by the document - that change makes, as housekeeping is. -* **A party's `null`** may be left out of the snapshot once a version later than the - one it names is current: nothing naming an earlier one can be written in the new - epoch, and an empty place reads as one holding `null` does. - -So a remake decides nothing that counts, but what it can't hold: of two envelopes of -one version and `seq` at a place at the base, the snapshot keeps one, and a write after -the base on the other, or an envelope put back after it on one the snapshot lacks, goes -to the quarantine, and its party writes again. A swarm that never remakes stays as + that change makes, as housekeeping is; the link is checked against the place as the + deletion leaves it. +* **A party's `null`** is left out of the snapshot once a version later than the one + it names is current: nothing naming an earlier one can be written in the new epoch, + and an empty place reads as one holding `null` does. One the snapshot keeps goes + only at a later remake (What counts). + +A remake's base is its coordinator's word, so all this holds for any base, not only a +recent one. So a remake decides nothing that counts, but what it can't hold: of two +envelopes of one version and `seq` at a place at the base, the snapshot keeps one, and +a write after the base on the other, an envelope put back after it on one the snapshot +lacks, or a write after it on a `null` the snapshot left out, goes to the quarantine, +and its party writes again. So does a vote cast under a key set its party wrote beside +another, the one not read: a party writing two key sets at once is answered as one +voting twice. A swarm that never remakes stays as correct as one that remakes all the time; it only grows slower. A remake does end one thing: nothing is written at a history from before it, so what a dropped key or a node taken off its list could still write there ends with it. @@ -469,8 +476,9 @@ Recommendations, not rules: none of these breaks a promise, only how fast a node unless some party's `true` and `false` for it are both there. Without a party voting twice, at most one version changes a version. With one, nodes still read the same version once they hold the same changes, and the parties fork. -3. **Carrying on.** A fork is a swarm of its own, named by its genesis change, joined - by its operators' choice only. A party nobody follows carries on alone. +3. **Carrying on.** A fork is a swarm of its own, named by its first version and the + heads it names, joined by its operators' choice only. A party nobody follows carries + on alone. ## Attacks @@ -492,7 +500,7 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang | 11 | `true` and `false` on one proposal at once | Both held; a node that saw only one may write a version. As 10 | unit, every order | | 12 | A vote changed, or deleted while its version is current | Refused | unit | | 13 | A vote cast at a history from before, on a proposal made since | Refused: its proposal isn't written there | unit | -| 14 | A party changes keys after voting | Its vote counts as cast | unit | +| 14 | A party changes keys after voting, or beside its vote | Its vote counts as cast, at a remake too: replayed before the key set | unit | | 15 | Votes split, honestly or not | Nothing passes; nays make the proposals dead, and another passes | unit | | 16 | The parties beyond the share never vote, or vote `false` on everything | Nothing passes; the others fork | sim | | 17 | The party a version takes out writes that version itself | Written: a version counts by its votes, not its writer | unit | @@ -504,32 +512,33 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang | 23 | Housekeeping of something that counts | Refused, by the document the change makes | unit | | 24 | Housekeeping by a change that saw a time when it didn't count | Taken; the party writes again | unit | | 25 | A map holding places deleted, or a place written within | Refused | unit | -| 26 | A change from before the swarm was federated, sent later | Refused; held, dropped once told | unit, sim | -| 27 | A change written at once with the federating change | As 26, on every node alike | sim | -| 28 | A remake whose document reads otherwise than the base | Nodes holding the base stay, and never rejoin it | sim | -| 29 | Two envelopes at one place beyond a remake's base | The chain to the one read is replayed | unit | -| 30 | A version written after a remake's base, an envelope written beside it | Replayed, the envelope first, as it names the version before | unit | -| 31 | A joining node handed a made-up epoch | Taken. Not promised | sim | -| 32 | The party with most nodes remakes often, or never acks | Slow, not wrong; the others fork | sim | -| 33 | A writer forked: two changes, one number | Honest nodes split until a remake, or a fork. Not promised | sim | -| 34 | Different changes to different peers | Honest nodes agree once they sync | sim | -| 35 | A party withholding its changes or votes | Not promised | — | -| 36 | Flooding: namespace, proposals, history, writers | Slow, not wrong | bench | -| 37 | A node taken off its list writes changes at a history where it was on | Taken where valid there; behind what is written under later versions | unit | -| 38 | A token from another party's node | Refused: a node's party is its configuration's | unit | -| 39 | Envelopes the stayers sign after a fork, brought to the fork | Refused: signed for the other swarm | unit | -| 40 | A fork whose genesis change differs from the document it names | Nodes holding that document don't join, and say what differs | sim | -| 41 | A fork at heads of its founder's choosing | Joiners holding the document are told what those heads lack | sim | -| 42 | A federation, or a policy, a node doesn't know | It stops taking changes | unit | -| 43 | A party lists another party's nodes | Nothing changes for either | unit | -| 44 | The versions behind the current one deleted | The current one is still the highest number | unit | -| 45 | A vote cast on the side not read, before the sides met, sent after | That side may gain a version, and be read. Not promised: the parties fork | unit | -| 46 | A key set written under the version not read, of two with one number | Ahead of the set the other wrote, until a fork | unit | -| 47 | A place given to another and emptied after a base, its new holder writing after that | Replay deletes what counts no more there, then writes the new holder's chain | unit | -| 48 | Two envelopes of one version and `seq` at a base, a write after it on the one not kept | Quarantined; its party writes again | unit | -| 49 | A federating change made later to look as old | Refused: beside the one the policy leads back to | unit | -| 50 | A `null` deleted while what it covers could still count | Refused, by the deleting change's history | unit | -| 51 | A fork's version giving a party that didn't go keys of its founder's | Joiners holding the document are told, party by party | sim | +| 26 | A remake whose document reads otherwise than the base | Nodes holding the base stay, and never rejoin it | sim | +| 27 | Two envelopes at one place beyond a remake's base | The chain to the one read is replayed | unit | +| 28 | A version written after a remake's base, an envelope written beside it | Replayed, the envelope first, as it names the version before | unit | +| 29 | A joining node handed a made-up epoch | Taken. Not promised | sim | +| 30 | The party with most nodes remakes often, or never acks | Slow, not wrong; the others fork | sim | +| 31 | A writer forked: two changes, one number | Honest nodes split until a remake, or a fork. Not promised | sim | +| 32 | Different changes to different peers | Honest nodes agree once they sync | sim | +| 33 | A party withholding its changes or votes | Not promised | — | +| 34 | Flooding: namespace, proposals, history, writers | Slow, not wrong | bench | +| 35 | A node taken off its list writes changes at a history where it was on | Taken where valid there; behind what is written under later versions | unit | +| 36 | A token from another party's node | Refused: a node's party is its configuration's | unit | +| 37 | Envelopes the stayers sign after a fork, brought to the fork | Refused: signed for the other swarm | unit | +| 38 | A fork whose genesis change differs from the document it names | Nodes holding that document don't join, and say what differs | sim | +| 39 | A fork at heads of its founder's choosing | Joiners holding the document are told what those heads lack | sim | +| 40 | A federation, or a policy, a node doesn't know | It stops taking changes | unit | +| 41 | A party lists another party's nodes, or one its party dropped | Nothing changes: a node is its own party's | unit | +| 42 | The versions behind the current one deleted | The current one is still the highest number | unit | +| 43 | A vote cast on the side not read, before the sides met, sent after | That side may gain a version, and be read. Not promised: the parties fork | unit | +| 44 | A key set written under the version not read, of two with one number | Ahead of the set the other wrote, until a fork | unit | +| 45 | A place given to another and emptied after a base, its new holder writing after that | Replay deletes what counts no more there, then writes the new holder's chain | unit | +| 46 | Two envelopes of one version and `seq` at a base, a write after it on the one not kept | Quarantined; its party writes again | unit | +| 47 | A `null` deleted while what it covers could still count, or one the epoch's first change holds | Refused, by the deleting change's history | unit | +| 48 | A fork's version giving a party that didn't go keys of its founder's | Joiners holding the document are told, party by party | sim | +| 49 | A party writes two key sets at once and votes under the one not read | At a remake, the vote may be refused: as voting twice, the parties fork | unit | +| 50 | A coordinator records an old base | Everything after it is replayed, each as every node judges it | sim | +| 51 | A write after a base on a `null` the snapshot left out | Quarantined; its party writes again | unit | +| 52 | A version written without the keys it sets, or keys written by another change | Refused | unit | ## Roads not taken @@ -552,17 +561,21 @@ What an attacker does, and what happens. *Unit*: the judging, with crafted chang * **The longest chain from the first version.** It reads the same as the highest number, but needs every version kept, and a tie decided where two chains part, long behind both. -* **Of two federating changes at once, the lower hash.** A change made later to look as - old would win, and every node drop the federation with all that was built on it. +* **Becoming federated in a running swarm.** It needs the time before closed, as + continuum closes it for a swarm turned strict, values from before counting only + where a party signed them, and of two federating changes at once neither preferred, + as a tie broken by hash would let a change made later to look as old take the + place of the one every node took. A federation started by its genesis change needs + none of it. * **Freezing the policy once two versions share a number.** One party could stop the federation at every close vote; the lower hash keeps nodes agreeing until the parties fork. * **Forks within one document**, each side judging by its own chain of versions. It needs judging per chain, judging again when a node changes sides, node lists and remakes per chain. A swarm of its own needs none of it. -* **Leaving the federation by a version.** The closed registry, and the time before - and during the federation, would be read again by the next policy. A fork with that - policy starts clean. +* **Leaving the federation by a version.** The closed registry, and the time during + the federation, would be read again by the next policy. A fork with that policy + starts clean. * **Users below the parties.** A party's people and keys within it are its own matter: it may hand out its keys as it likes. The federation sees parties. @@ -572,8 +585,8 @@ Every node of a swarm runs the same version of continuum today. A federated swar parties can't be made to upgrade together, so what all its nodes must agree on is named by the federation's number: the rules of this design, the envelope and how the value of a place is read, what makes a change one Automerge writes, how a path and a version are -spelled and read, which version is current, the rule for the time before, the remake's -check, its replay and its order. The hash of a change and its encoding are Automerge's +spelled and read, which version is current, the remake's check, its replay and its +order. The hash of a change and its encoding are Automerge's version's. A change to the federation is a design like this one, with the next number. A swarm @@ -596,8 +609,9 @@ On a federated swarm: ## Stages -1. **The federated policy**: versions and what makes one valid, rules and paths, keys, - votes, passing and dead, the current version, judging by it; the meta's version +1. **The federated policy**: a swarm started federated by its genesis change; versions + and what makes one valid, rules and paths, keys, votes, passing and dead, the + current version, judging by it; the meta's version number and the order by it; node lists, a node's party in its configuration, and tokens from one's own party's nodes only; continuum's readings of a policy and of an envelope taking the federated policy and the meta's version beside the six fields @@ -605,14 +619,14 @@ On a federated swarm: 4, a federated swarm takes no remake. 2. **What counts**, read by the current version and the keys; shown in the API. Housekeeping. Reports of a party that voted twice. -3. **Nodes**: membership by the node lists, a node syncing with members only, as a - swarm key does today (a wire change). +3. **Nodes**: membership by the node lists and the party a node's own entry names, a + node syncing with members only, as a swarm key does today (a wire change). 4. **Remakes**: the check that a remake lost and added nothing; replay of versions with the envelopes. -5. **Forks**: a swarm started from another's document, named by its genesis change's - hash, and the check against it. -6. **Becoming federated** in a running swarm. -7. **The registry**: the rules for krebs, the tool. +5. **Forks**: a swarm started from another's document, named by its first version and + the heads it names, and the check against it. +6. **The registry**: the rules for krebs, the tool that signs kartei's entries in as + their parties', and the one that reads them out. Each stage's tests are its rows of Attacks. Each stage keeps every swarm that isn't federated as it is, its tests passing untouched. -- cgit v1.3.1