From 0bfe07af92a775b0e896e0fc5a989a1d9b65f7b3 Mon Sep 17 00:00:00 2001 From: tv Date: Wed, 18 Nov 2026 12:41:10 +0000 Subject: docs: references to a section of the same document linked to it Where a document names one of its own sections in parentheses ("(What counts, 5)", "(Joining, below)"), the name links to the section by its GitHub-style ID; paragraphs that grew past the width are wrapped anew, links and code kept on one line each. References to another document's sections stay as they are. --- docs/federation.md | 266 +++++++++++++++++++++++++++-------------------------- 1 file changed, 138 insertions(+), 128 deletions(-) (limited to 'docs/federation.md') diff --git a/docs/federation.md b/docs/federation.md index 5faa478..2b76fdf 100644 --- a/docs/federation.md +++ b/docs/federation.md @@ -1,18 +1,17 @@ # Federation: a design -A design, built stage by stage (Stages): so far, the store it builds on, held in memory -and in a swarm's document, members by the federation and the store at a node's API, as -[`store.md`](store.md) says; the federation as its fold (`federation::fold`), with the -byte formats; a party's client (`continuum-party`, `federation::client`), which signs +A design, built stage by stage ([Stages](#stages)): so far, the store it builds on, held +in memory and in a swarm's document, members by the federation and the store at a node's +API, as [`store.md`](store.md) says; the federation as its fold (`federation::fold`), with +the byte formats; a party's client (`continuum-party`, `federation::client`), which signs its party's events, votes by its record, signs again what a move refused, and names a party that voted twice; and votes a node casts by itself (`federation::vote`), following parties and proposing checkpoints, which back a checkpoint by the voters' rule, and through which its party votes by hand. It says how a swarm can be kept by parties that don't trust each other, for a first use: the krebs registry ([krebs/kartei](https://github.com/krebs/kartei)), today plain files in a git repository -that one maintainer merges into. What it is for is narrow: to hand out identifiers -(names, addresses, keys), and to give every party a namespace of its own that everyone -reads. +that one maintainer merges into. What it is for is narrow: to hand out identifiers (names, +addresses, keys), and to give every party a namespace of its own that everyone reads. It asks as little as it can of continuum and promises the least that makes a federation possible. A federation that cooperates settles fast; one that doesn't comes apart, and @@ -21,11 +20,12 @@ whoever wants to carry on with whom does so. Claims about the code are marked ## Optional -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. Which federation a swarm follows is a number of its own, in each -version of its policy: this design is federation 1 (Changing the federation). Any group -carries on with the policy it wants by forking (Forks), and leaves the federation by +A swarm is federated from its genesis change, or not at all +([Starting a federation](#starting-a-federation)). Nothing else changes: a swarm that +isn't stays as it is, its registry, rules, remakes and replay included. Which federation a +swarm follows is a number of its own, in each version of its policy: this design is +federation 1 ([Changing the federation](#changing-the-federation)). Any group carries on +with the policy it wants by forking ([Forks](#forks)), and leaves the federation by starting a swarm of another kind, with what it takes along. ## Parties and the adversary @@ -64,10 +64,11 @@ nothing coming from any node breaks a promise for the others. 2. **The policy changes only by the votes of two thirds of its parties**, as one history saw their votes; and nodes that hold the same events read the same policy. Without keys voting twice, a version that passed stays, on every node; with them, the nodes - part, and the parties fork (Changing the policy). + part, and the parties fork ([Changing the policy](#changing-the-policy)). 3. **Any group carries on as it chooses.** Its parties fork with the policy they want, and whoever wants to follow does; groups that parted come together as parties come - in, one letting the other's in (Forks). Nobody is held by parties it doesn't follow. + in, one letting the other's in ([Forks](#forks)). Nobody is held by parties it doesn't + follow. Not promised: @@ -78,14 +79,15 @@ Not promised: writers without end or keep remakes from committing ([`store.md`](store.md)), makes nodes slow, or runs them out of memory, not wrong: denial of service breaks no promise here, and the others fork away from it; -* that honest nodes stay together where keys voted twice (Changing the policy): each - node keeps the version it took, until its operator has it drop it, and one that had - taken neither of two (it lagged behind, or joins) may be shown either first; +* that honest nodes stay together where keys voted twice + ([Changing the policy](#changing-the-policy)): each node keeps the version it took, + until its operator has it drop it, and one that had taken neither of two (it lagged + behind, or joins) may be shown either first; * that what isn't above a checkpoint's heads is taken once nodes moved to it: its party - signs it again (Checkpoints); + signs it again ([Checkpoints](#checkpoints)); * that a node joining from the root, in a federation that never passed a checkpoint, isn't shown a chain old keys grew: of two versions changing one it takes neither, but - where its seeds are all the adversary's it is shown one (Checkpoints); + where its seeds are all the adversary's it is shown one ([Checkpoints](#checkpoints)); * that a checkpoint, or a fork's root, that a node takes on its operator's word is the one the others built ([`store.md`](store.md), Pinned checkpoints). @@ -133,13 +135,14 @@ Spread out: key set are spelled so too, and node IDs as continuum spells them: `continuum:` and the 64 lower-case hex digits of the node's Ed25519 public key. * **What it does**, one field of: - * `write`, `{"path": "", "value": }`: a value at a place (The policy); - * `keys`, `["", …]`: the party's key set (Keys); - * `nodes`, `["", …]`: its node list (Nodes); - * `proposal`, a version, the object (Changing the policy); + * `write`, `{"path": "", "value": }`: a value at a place + ([The policy](#the-policy)); + * `keys`, `["", …]`: the party's key set ([Keys](#keys)); + * `nodes`, `["", …]`: its node list ([Nodes](#nodes)); + * `proposal`, a version, the object ([Changing the policy](#changing-the-policy)); * `vote`, `{"on": "", "proposal": "", "yes": true}`, `"yes"` `true` or - `false` (Changing the policy): a version's hash, the SHA-256 of its JCS bytes, - written as an ID is. + `false` ([Changing the policy](#changing-the-policy)): a version's hash, the SHA-256 + of its JCS bytes, written as an ID is. * **`sig`**: an SSH signature (`ssh-keygen -Y sign`, namespace `continuum-federation`) over the event's bytes without `sig`: the SSHSIG blob of version 1, hashed with `sha512`, its key the event's `key`, its reserved field empty, as `ssh-keygen` writes @@ -153,8 +156,8 @@ Spread out: makes either; a party's client makes `s` low. Three things no party signs, as their bytes need no signer, each without `party`, `key` -and `sig`: a version event (Changing the policy), and a federation's root and a fork's, -which are checkpoints (Checkpoints). +and `sig`: a version event ([Changing the policy](#changing-the-policy)), and a +federation's root and a fork's, which are checkpoints ([Checkpoints](#checkpoints)). An event is none if its bytes aren't the JCS encoding of the JSON they read as, if a field is missing or more, if its `key` or `sig` doesn't read back to itself spelled as @@ -171,14 +174,15 @@ another event of what a party signed. Of an event, federation 1 allows: It names no swarm, no version and no ID of its own: its history says the first two. An event signed in a federation, or in a fork once it forked, has that store's root in its history, and no other store takes it ([`store.md`](store.md), Forks). An event is -**written under** the version current at its history (Changing the policy). +**written under** the version current at its history +([Changing the policy](#changing-the-policy)). ### The policy What the policy says is in its **versions**, a chain: each is a JSON object, named by the SHA-256 of its JCS bytes, numbered, and naming the version it changes (`null` for the first, number 0, which only the federation's root holds; a fork's changes the one -current at its heads, Forks). Spread out: +current at its heads, [Forks](#forks)). Spread out: ```json { "federation": 1, "number": 7, "changes": "", @@ -201,19 +205,19 @@ current at its heads, Forks). Spread out: it changes. * **The parties and their keys** (`keys`): one party at least, each by name, as continuum's user names, 1 to 64 of `A-Z a-z 0-9 . _ @ -`, with one key or more - (`ssh-ed25519` or `ecdsa-sha2-nistp256`, Events), none twice in the version. With them - the party signs its votes and proposals on this version, its key set and its node list - (Keys, Nodes). Its `since` is the number of the version that named them anew: this - one's where it does (a party new in it, keys the parties replace, or the same keys - named anew), else the `since` the version it changes gives the party, whose keys it - then names unchanged. + (`ssh-ed25519` or `ecdsa-sha2-nistp256`, [Events](#events)), none twice in the version. + With them the party signs its votes and proposals on this version, its key set and its + node list ([Keys](#keys), [Nodes](#nodes)). Its `since` is the number of the version + that named them anew: this one's where it does (a party new in it, keys the parties + replace, or the same keys named anew), else the `since` the version it changes gives the + party, whose keys it then names unchanged. * **The node lists** (`nodes`): every party's, a list of node IDs, none twice, with its `since` as keys have one. The version that lets a party in names its list anew, empty where it gives it no nodes, so that a list it wrote before it was taken out counts no more; a later version may name it anew again; the first version and a fork's name - those of the parties that start it (Nodes). + those of the parties that start it ([Nodes](#nodes)). * **The checkpoint** (`checkpoint`), where the version names one: the heads at which the - store moves to a checkpoint once the version is current (Checkpoints). + store moves to a checkpoint once the version is current ([Checkpoints](#checkpoints)). * **The rules**, in order: the first whose path matches a path says who writes there. A path is segments separated by `/`, none empty. A rule's first segment is literal, and not `_continuum`; any other is literal, `{party}` (the name of a party of the version, @@ -224,13 +228,13 @@ current at its heads, Forks). Spread out: A **place** is a path a rule matches. A party writes there by a `write` event, `{"path": …, "value": …}`: any JSON value, `null` emptying the place. Its value is the -latest its party signed there that counts (What counts). A place is a path, not a key in -a tree: a version may give a place and places below it alike, and nothing is both a -value and the way to others. How names and addresses are spelled as paths is the -application's: the registry writes a name by its labels, last first -(`names/r/tv/toaster` for `toaster.tv.r`, `names/r/tv` for `tv.r`), and an address by -its parts, so that a party's zone or block takes a rule or two. Rules go by first match, -so a party named like a shared name takes it where a `{party}` rule comes before it: the +latest its party signed there that counts ([What counts](#what-counts)). A place is a +path, not a key in a tree: a version may give a place and places below it alike, and +nothing is both a value and the way to others. How names and addresses are spelled as +paths is the application's: the registry writes a name by its labels, last first +(`names/r/tv/toaster` for `toaster.tv.r`, `names/r/tv` for `tv.r`), and an address by its +parts, so that a party's zone or block takes a rule or two. Rules go by first match, so a +party named like a shared name takes it where a `{party}` rule comes before it: the application keeps party names apart from its spelling (no party named `wiki` while `wiki.r` is lass's). @@ -242,7 +246,7 @@ whatever it holds: whether it is a version is asked where a version event names that nodes knowing more of what a version may say don't part from those knowing less. A node shows whether a proposal is a version by the federation it knows, and a party's client backs none that isn't: two thirds backing one that can never be written bind the -federation to its version, as a yes binds (Changing the policy). +federation to its version, as a yes binds ([Changing the policy](#changing-the-policy)). What the swarm's document holds beyond the events, and what a node takes at its API, is the store's ([`store.md`](store.md), On Automerge). @@ -270,7 +274,8 @@ A party **votes** on a proposal by a `vote` event, naming the version the propos dead, so that, once a checkpoint left them out, nothing names its party as voting twice. A party votes from one client: two of its clients backing two proposals at once is voting twice, as two of its nodes each voting by itself is, or a vote by hand - beside the node that votes for it (Votes a node casts by itself). + beside the node that votes for it + ([Votes a node casts by itself](#votes-a-node-casts-by-itself)). * **A proposal passes** once at least two thirds of its version's parties voted `true` (3·yes ≥ 2·parties). It is **dead** once so many voted `false` that the rest can't pass it (3·(parties − no) < 2·parties). A party whose `true` and `false` on one @@ -332,7 +337,7 @@ chain the node took. policy, and an event whose history holds both is refused, as no version is current there; the sides are apart, and a node that lagged behind, or joins, may be shown either first. The parties answer by forking, without the party that voted twice, or - with its keys named anew (Forks). + with its keys named anew ([Forks](#forks)). * **A party that voted twice shows** in the votes alone, both signed with keys their version names for it: its `true` and `false` on one proposal, or its `true` on two proposals of one version where neither is dead by all the votes cast. Where in history @@ -350,7 +355,8 @@ chain the node took. Everything the federation decides is a change of the policy: who the parties are, their keys where they lost them, and their node lists where they have none; who writes where, which is giving an identifier, taking it back and giving it to another; and the -federation itself, by naming another (Changing the federation). +federation itself, by naming another +([Changing the federation](#changing-the-federation)). ### Keys @@ -358,13 +364,13 @@ A party votes and proposes with the keys its version names for it, and signs wit its key set and its node list. Everything else it signs with the keys of its **key set**: a `keys` event, the list of its keys, none twice, signed with a key the version it is written under names for the party. A set is checked only where it is written, -never by the keys of a set (What counts, 2). +never by the keys of a set ([What counts](#what-counts), 2). -A party's keys are those of its set (What counts, 5) where the set is written under a -version numbered at least the `since` its version gives the party's keys; otherwise, and -while it has written none, those its version names. So once a version names a party's -keys anew, no set written under an earlier version counts, and the party's next set -does. Nothing is written for it: the version says it. +A party's keys are those of its set ([What counts](#what-counts), 5) where the set is +written under a version numbered at least the `since` its version gives the party's keys; +otherwise, and while it has written none, those its version names. So once a version names +a party's keys anew, no set written under an earlier version counts, and the party's next +set does. Nothing is written for it: the version says it. * **A value counts only while the key that signed it is among its party's keys**, as above: votes, proposals, sets and node lists aside, which go by the keys their version @@ -394,7 +400,7 @@ else does: longer one, the place went to another, a rule changed; and of a party that is no longer one, its key set and its node list; 2. a write signed by a key that isn't among its party's; and a key set or node list - written under a version before the `since` its version gives it (Keys); + written under a version before the `since` its version gives it ([Keys](#keys)); 3. a proposal on a version that isn't current, and the votes on that version; 4. a version behind the current one; 5. of the writes at a place that 1 and 2 leave, one another of them has in its history, @@ -405,22 +411,23 @@ So a place's value, a party's set and its list are each the latest its party sig counts: what the party signed after replaces what it signed before, whatever order the events came in, and what counts no more replaces nothing. Nothing is deleted: a party empties its place by writing `null`, and what counts no more stays in the store until a -checkpoint leaves it out (Checkpoints). A place given back to its party, or a key added -back, shows what the party signed before where nothing replaced it since and no -checkpoint left it out, until the party writes there again. Two writes of one party at -one place, neither in the other's history (two of its clients at once), leave the one +checkpoint leaves it out ([Checkpoints](#checkpoints)). A place given back to its party, +or a key added back, shows what the party signed before where nothing replaced it since +and no checkpoint left it out, until the party writes there again. Two writes of one party +at one place, neither in the other's history (two of its clients at once), leave the one with the lower ID; the party writes again, after both, to choose. ### Checkpoints A **checkpoint** writes down what counts at some heads: those heads, a version (the one current there, or a fork's), and the IDs of the events that count there with that -version current, version events aside, as it holds the version itself (What counts), as -the JCS encoding of `{"at": [], "keeps": [], "version": }`, its IDs -ascending and its version the version itself, the object, named by its SHA-256 -([`store.md`](store.md), Checkpoints). Every node holding the history up to those heads -builds the same one, and its version counts as written: a version event of it that comes -later is one the node took. +version current, version events aside, as it holds the version itself +([What counts](#what-counts)), as the JCS encoding of +`{"at": [], "keeps": [], "version": }`, its IDs ascending and its +version the version itself, the object, named by its SHA-256 ([`store.md`](store.md), +Checkpoints). Every node holding the history up to those heads builds the same one, and +its version counts as written: a version event of it that comes later is one the node +took. A version names a checkpoint by its heads (`checkpoint`): events after the current checkpoint, at which it is current too, none in another's history, their IDs ascending, @@ -435,26 +442,26 @@ they held for a while before it was proposed is among its heads, in their histor above them: a move refuses what isn't above its heads, and heads a proposer made up, built on little, would take back what was written since, a key set dropping a stolen key among it. A node shows, for a proposed checkpoint, what it holds that its heads lack, as -for a fork (Forks). This is the voter's rule, by its own clock: nothing more is judged. -It is a version only where its proposal is above those heads, and a version event -writing it is taken only where it is above them too, and so is every vote it is written -on ([`store.md`](store.md), Events): so moving to the checkpoint refuses nothing that -decided it. A party's client, and a node voting by itself, vote on the events proposing -what they vote on, and a node proposes a checkpoint on its heads: so their votes are -above those heads wherever the proposal is. A vote beside them binds its party as any -yes does, until the move refuses it. A node that takes the version moves to the -checkpoint: it builds it, forgets everything before those heads that it doesn't keep, -and every event not above them, and refuses such events from then on. Judging an event -after them needs nothing it forgot: the version, every party's keys and node list, and -the proposals on the current version with their votes all count, and are kept. A node -starting from a checkpoint reads what it keeps as written under its version, as it holds -none of their histories: each was written under that one or an earlier, counting there, -a kept proposal is on it, and a later `since` that leaves one out is past it. A node -that can't build a checkpoint, as it was away across a move and a remake after it, or as -it joins, takes it only where its operator pins it ([`store.md`](store.md), Pinned -checkpoints). What it can't check of its heads it takes on its operator's word: that -they are after the checkpoint current at the version naming them, at which that one is -current too; so it judges that version as every node does. +for a fork ([Forks](#forks)). This is the voter's rule, by its own clock: nothing more is +judged. It is a version only where its proposal is above those heads, and a version event +writing it is taken only where it is above them too, and so is every vote it is written on +([`store.md`](store.md), Events): so moving to the checkpoint refuses nothing that decided +it. A party's client, and a node voting by itself, vote on the events proposing what they +vote on, and a node proposes a checkpoint on its heads: so their votes are above those +heads wherever the proposal is. A vote beside them binds its party as any yes does, until +the move refuses it. A node that takes the version moves to the checkpoint: it builds it, +forgets everything before those heads that it doesn't keep, and every event not above +them, and refuses such events from then on. Judging an event after them needs nothing it +forgot: the version, every party's keys and node list, and the proposals on the current +version with their votes all count, and are kept. A node starting from a checkpoint reads +what it keeps as written under its version, as it holds none of their histories: each was +written under that one or an earlier, counting there, a kept proposal is on it, and a +later `since` that leaves one out is past it. A node that can't build a checkpoint, as it +was away across a move and a remake after it, or as it joins, takes it only where its +operator pins it ([`store.md`](store.md), Pinned checkpoints). What it can't check of its +heads it takes on its operator's word: that they are after the checkpoint current at the +version naming them, at which that one is current too; so it judges that version as every +node does. What a checkpoint loses: what counted no more before it, so that a key added back, or a place given back, brings back nothing signed before it, and a party that voted twice on @@ -475,8 +482,9 @@ what old keys can do to the versions after it. A version that changes nothing but its number, what it changes and its checkpoint only moves the store on. Like any version, it lapses the proposals on the version before, so a party proposes one where nothing that can still pass is proposed on the current -version. A federation's root is its first checkpoint, without heads (Starting a -federation), and a fork's root a checkpoint at the heads it forks at (Forks). +version. A federation's root is its first checkpoint, without heads +([Starting a federation](#starting-a-federation)), and a fork's root a checkpoint at the +heads it forks at ([Forks](#forks)). ### Votes a node casts by itself @@ -487,10 +495,11 @@ as it judges any vote or proposal. The design has two in mind: * **Following**: back a proposal where a party the rule names backed it, and vote `false` where that party did; a proposal binds its proposer to nothing, so following one would bind the node where that party is free. By default it follows only on a - version that only moves to a checkpoint (Checkpoints), a `true` as a `false`; its - operator may have it follow on any version, which hands that party the node's vote, - its `false` among it: a party followed so by more than a third of the parties, its key - kept on a node, ends every proposal, the one naming that key anew among them. + version that only moves to a checkpoint ([Checkpoints](#checkpoints)), a `true` as a + `false`; its operator may have it follow on any version, which hands that party the + node's vote, its `false` among it: a party followed so by more than a third of the + parties, its key kept on a node, ends every proposal, the one naming that key anew among + them. * **Proposing a checkpoint**: propose a version that only moves to a checkpoint, at heads the node has held for a while, once conditions its operator sets are met: so many events or bytes held beyond its checkpoint, so many versions since it, or so long @@ -505,33 +514,33 @@ Such a node keeps to what a party's client keeps to: one yes at a time; never `t each voting by itself can vote twice; none for a proposal that is no version; and, by a rule for checkpoints, none for a version that changes more than its number, what it changes and its checkpoint, which it checks against the current one, nor for one whose -heads leave out what it held for a while (Checkpoints). Where two checkpoints are -proposed at once, the votes split, as any do; a rule may vote `false` on the one it -doesn't back, so that one dies and its backers are free. +heads leave out what it held for a while ([Checkpoints](#checkpoints)). Where two +checkpoints are proposed at once, the votes split, as any do; a rule may vote `false` on +the one it doesn't back, so that one dies and its backers are free. It signs with a key the party's version names, which the party keeps on that node, not apart: one stolen there votes, and writes the party's key set and node list, as the -party's, until a version names its keys anew (Keys). A party that won't keep one there -votes by hand. A party that has a node vote by itself votes by hand only through that -node, which keeps the party's one record of its votes and refuses a vote that record +party's, until a version names its keys anew ([Keys](#keys)). A party that won't keep one +there votes by hand. A party that has a node vote by itself votes by hand only through +that node, which keeps the party's one record of its votes and refuses a vote that record forbids: a party votes from one client, and that node is it. ### Nodes A party lists the nodes that carry for it, by node ID, in its **node list**: a `nodes` event, the list of its nodes' IDs, none twice, signed with a key the version it is -written under names for the party. A party's list is that one (What counts, 5) where it -is written under a version numbered at least the `since` its version gives the party's -list, otherwise the list its version gives, if any, as with keys (Keys). The store's -members are the nodes each party's list names, each as its party's -([`store.md`](store.md), Members); another party's list does nothing for a node. A -party's list counts until the party writes another or a version names one anew, whatever -keys its version names since, so that no change of keys leaves a swarm without members; -a list a stolen key wrote stays until the party writes one under the version that -replaced that key, which it can at once, through any member. A node puts whatever events -it is given, its party's and others' alike: what counts is who signed an event, not -which node put it. So a party without nodes of its own writes through any node that -takes its events. +written under names for the party. A party's list is that one +([What counts](#what-counts), 5) where it is written under a version numbered at least the +`since` its version gives the party's list, otherwise the list its version gives, if any, +as with keys ([Keys](#keys)). The store's members are the nodes each party's list names, +each as its party's ([`store.md`](store.md), Members); another party's list does nothing +for a node. A party's list counts until the party writes another or a version names one +anew, whatever keys its version names since, so that no change of keys leaves a swarm +without members; a list a stolen key wrote stays until the party writes one under the +version that replaced that key, which it can at once, through any member. A node puts +whatever events it is given, its party's and others' alike: what counts is who signed an +event, not which node put it. So a party without nodes of its own writes through any node +that takes its events. ### Forks @@ -540,13 +549,13 @@ the group won't follow passed, or the parties can't agree. It **forks**: it star store of its own from the federation's ([`store.md`](store.md), Forks). 1. One of the group makes the fork's root, a checkpoint at the heads it forks at, which - no party signs, so that one version and one set of heads make one fork (Checkpoints). - Its version changes the version current at those heads, is numbered one past it, and - names anew the keys of any party whose keys it changes; a root whose version doesn't - is no fork. Its founders name their own node lists anew in it, so that their nodes - are members there. It keeps the events that count at those heads with that version - current. Every proposal is a chance to fork: the version is usually one that didn't - pass. + no party signs, so that one version and one set of heads make one fork + ([Checkpoints](#checkpoints)). Its version changes the version current at those heads, + is numbered one past it, and names anew the keys of any party whose keys it changes; a + root whose version doesn't is no fork. Its founders name their own node lists anew in + it, so that their nodes are members there. It keeps the events that count at those + heads with that version current. Every proposal is a chance to fork: the version is + usually one that didn't pass. 2. A fork is named by its root's ID, which nobody can steer to a given name, the federation it came from least of all. It takes only events with its root in their history: what the stayers sign after it isn't taken there, nor what the fork's @@ -570,9 +579,10 @@ keep, as a party's client signs again what a move refused. What one side signed on the other only once it is signed there. What a party's nodes do of themselves is their operators' business, written nowhere: -join a fork their operator follows, vote by rules their operator set (Votes a node casts -by itself), 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. +join a fork their operator follows, vote by rules their operator set +([Votes a node casts by itself](#votes-a-node-casts-by-itself)), 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. ### Shared identifiers @@ -590,15 +600,15 @@ parties, zones, blocks and names that are nobody's by their spelling. ### Starting a federation A federation starts with a store of its own: its root, a checkpoint without heads that -keeps nothing, its version the first, which no party signs (Checkpoints), so one first -version makes one federation, named by the root's ID. Among the node lists the version -gives, one names a node of its founders', so the federation starts with members, and -other nodes come in as their parties list them. Its swarm's genesis change holds the -root, built byte for byte from it, its policy naming the fold `federation` +keeps nothing, its version the first, which no party signs ([Checkpoints](#checkpoints)), +so one first version makes one federation, named by the root's ID. Among the node lists +the version gives, one names a node of its founders', so the federation starts with +members, and other nodes come in as their parties list them. Its swarm's genesis change +holds the root, built byte for byte from it, its policy naming the fold `federation` (`{"version": 2, "store": "federation"}`, [`store.md`](store.md), On Automerge). So -nothing is from before the federation: it changes by versions, and any group carries on -by a fork. A running swarm doesn't become federated; its parties start one, and sign -into it what they keep. +nothing is from before the federation: it changes by versions, and any group carries on by +a fork. A running swarm doesn't become federated; its parties start one, and sign into it +what they keep. ## Why it holds @@ -732,7 +742,7 @@ crafted events. *Sim*: a simulation. *Bench*: measured, not judged. * **The longest chain from the first version.** Old keys could still grow a chain longer than the one nodes took. * **A share each federation sets.** Two thirds is the federation's number's: another - share is another federation (Changing the federation). + share is another federation ([Changing the federation](#changing-the-federation)). * **Becoming federated in a running swarm.** It needs the time before closed, which continuum doesn't do for a swarm turned strict either, values from before counting only where a party signed them, and of two federating changes at once neither -- cgit v1.3.1