diff options
| -rw-r--r-- | docs/federation.md | 357 |
1 files changed, 185 insertions, 172 deletions
diff --git a/docs/federation.md b/docs/federation.md index 96e1a87..7a9b6f6 100644 --- a/docs/federation.md +++ b/docs/federation.md @@ -85,19 +85,19 @@ but for what the voters can do to a user, said with each and below): other party's consent; it counts at once, and reaches every honest node its nodes reach. -And for what the swarm decides together, with the fractions the design recommends -and fewer than a third of the voters malicious (the voters are the users an epoch's -root change names; a voter is honest here if its user is and the nodes that carry -for it are): +And for what the swarm decides together, with the fractions the design recommends and +fewer than a third of the voters malicious (the voters are the users the genesis +change names, or the decision that holds on who votes; a voter is honest here if its +user is and the nodes that carry for it are): -7. **Decisions by two thirds.** A proposal (a remake, a number, the policy, first - keys for a user that lost its own, a name) is decided only once more than two - thirds of all the voters voted for it, and nodes of that many held those votes - together. So none is decided that no honest voter voted for, and a side of a - partition decides only with nodes of that many voters on it. Of the decisions of - one matter every node acts on the same one, the last. A remake changes nothing - in what counts: every node builds the next epoch itself, from the changes it - holds. Nobody is moved against its will: a decision is refused by choice. +7. **Decisions by two thirds.** A proposal (who votes, who the roots are, a remake, a + number, the policy, first keys for a user that lost its own, a name) is decided + only once more than two thirds of all the voters voted for it, and nodes of that + many held those votes together. So none is decided that no honest voter voted for, + and a side of a partition decides only with nodes of that many voters on it. Of the + decisions of one matter every node acts on the same one, the last. A remake changes + nothing in what counts: every node builds the next epoch itself, from the changes + it holds. Nobody is moved against its will: a decision is refused by choice. What is not promised: @@ -169,9 +169,9 @@ What is not promised: * **Decisions without the voters.** With a third of an epoch's voters not taking part (gone, silent, without a node that carries for them), nothing more is decided there; what users write goes on. Those left go apart (Going apart). -* **Anything of 7 with one voter.** A swarm that one user starts has that user as - its only root and voter until a remake names others: it decides alone, and what - a third of the voters see, it sees alone. +* **Anything of 7 with one voter.** A swarm that one user starts has that user as its + only root and voter until it decides on others: it decides alone, and what a third + of the voters see, it sees alone. * **Time across a remake.** A length of time that had begun when a remake came starts anew after it. What became gone, final or dropped after a remake's base stays so where the nodes of a third of the voters carried it over (Remakes). @@ -419,10 +419,12 @@ Bringing someone in means handing over, out of the document, what a party needs connect and to start (the root change, some seeds, the swarm key where there is one), and writing the `create`. -**The roots** are the users the epoch's root change names as such: in a genesis -change the user who starts the swarm, or those the file it starts from names; then -those a remake names (Remakes). They change with a remake only, so a root is one -for its whole epoch. What sets a root apart: +**The roots** are the users the genesis change names as such (the user who starts the +swarm, or those the file it starts from names), and then those a decision names +(Decisions). A user is a root where such a decision names it, and that is read where +each thing it does was done: its nodes' change witnesses as a root's where the +change's history has it a root, and what it signed is a root's where it was signed. +What sets a root apart: * It is in by its seat: it needs nobody's vouch while it holds one, and nobody's unvouch puts it out. A user that held a seat and holds none any more is in like @@ -436,7 +438,7 @@ for its whole epoch. What sets a root apart: alone puts out a user the root change holds. * Its nodes' changes witness every claim, which is what settles one. * It creates users without a limit. What is the seats' counts toward nobody's limit. -* It holds the names a rule gives to a root, while it holds its seat. A remake that +* It holds the names a rule gives to a root, while it holds its seat. A decision that leaves a root out says which root has each of them from then on: its claim is made over, and no such name is ever without a holder. What a user signed before it was a root stays its own. @@ -444,8 +446,8 @@ for its whole epoch. What sets a root apart: A root can't write in another's namespace, nor take a name that is final. It can contest any name that isn't, in the open. With several roots, any one that is up settles claims, any one that lies contests them, and none takes a name alone. A root -that is away, or turns on the others, is left out by the voters at the next remake; -what is final stays as it is meanwhile. +that is away, or turns on the others, the voters leave out (Decisions); what is final +stays as it is meanwhile. ### Lengths of time @@ -495,11 +497,11 @@ exactly: * **Another vouch keeps the user.** With another line, the user stays in, with everything it has. * **Else the user is out, from there.** Nothing of it counts: its namespace doesn't, - its nodes witness nothing, and what they commit in sight of the unvouch is - refused. Its names **wait** for it, its user name among them: its claims stand, - so nobody else claims them, and nobody holds them. One thing it keeps: where it - is a voter, it votes on, and its nodes record proposals (Decisions). Who votes is - a remake's word, not its vouchers'. + its nodes witness nothing, and what they commit in sight of the unvouch is refused. + Its names **wait** for it, its user name among them: its claims stand, so nobody + else claims them, and nobody holds them. One thing it keeps: where it is a voter, it + votes on, and its nodes record proposals (Decisions). Who votes is the voters' word, + not its vouchers'. * **Those it brought in go with it,** from the same point: a user all of whose lines ran through it is out too, with the same consequences, unless another user that counts vouches for it, before or after. @@ -735,8 +737,8 @@ What this gives: So within a minute a name is its claimant's against any claim that says it saw nothing, as far as a root's node had the claim first. And within `final` against everything else: until then a root can still contest it, in the open, and so can -whoever hands a node of a root or of the claimant a rival before the claim. A root -that does is left out at the next remake. +whoever hands a node of a root or of the claimant a rival before the claim. The voters +leave out a root that does. A user's name is claimed the same way: the `create` statement is the claim, its side the nodes of its creator, of the new user and of the roots. Two creations of one @@ -844,32 +846,30 @@ and refuses as peers whom its operator says. Some things are the swarm's to decide: its numbers and the rest of its policy, a user's first keys where it lost its own, the names of a user that is out, whose a -contested name is, names the rules leave to the voters, and when to compact, with -who votes and who the roots are from then on. They are decided by votes of users, -signed by them, over days. +contested name is, names the rules leave to the voters, when to compact, who votes and +who the roots are. They are decided by votes of users, signed by them, over days. -**Who votes.** The **voters** are the users the epoch's root change names. A genesis -change names the user who starts the swarm, or those the file it starts from says. -A remake names those of the next epoch: its proposal lists them, by their IDs. So -who votes is decided by those who vote, with each remake; nothing that happens after -a proposal is signed takes a user off its list or puts one on; and a swarm that one -user started is that one's to decide until its first remake. A voter votes for its -epoch, with the keys the document has for it, whether it is in, out or gone: who is -in is its vouchers' word, who votes is the remake's. +**Who votes.** The **voters** are the users the genesis change names (the user who +starts the swarm, or those the file it starts from says), and from a decision on who +votes, those it lists, by their IDs. So who votes is decided by those who vote; +nothing that happens after a proposal is signed takes a user off its list or puts one +on; and a swarm that one user started is that one's to decide until it decides on +others. A voter votes with the keys the document has for it, whether it is in, out or +gone: who is in is its vouchers' word, who votes is the voters'. What to weigh in a list: -* Every voter named counts toward what a decision takes, whether it takes part or - not: more than two thirds of all of them. One that never votes stands in the way - like one voting against. With a third of them not voting nothing is decided, and - no remake either, which is what would name others. +* Every voter named counts toward what a decision takes, whether it takes part or not: + more than two thirds of all of them. One that never votes stands in the way like one + voting against. With a third of them not voting nothing is decided, a list naming + others neither. * So a list names those who take part: recommended, the users who voted or signed anything in the epoch, which a client makes from the document. All users may be on it; in a registry of many of whom few care, that is the last thing decided. -* A swarm remakes while two thirds of its voters still take part. Past that, those - left go apart, naming who votes among them (Going apart). So that the line is - seen coming, `GET /registry/decisions` shows for each voter when it last voted - and when a node of its last stamped. +* A swarm names its voters anew while two thirds of them still take part. Past that, + those left go apart, naming who votes among them (Going apart). So that the line is + seen coming, `GET /registry/decisions` shows for each voter when it last voted and + when a node of its last stamped. * What is seen for long takes a third of the voters each with a node of their own. A voter without one is whoever carries for it: where one node carries for a third of a list, that node has the say a third has. @@ -877,8 +877,13 @@ What to weigh in a list: created sixteen is seventeen of it. The voters see a list before they vote for it (`GET /registry/decisions`), and -propose one of their own where they don't like it. A change in who votes takes a -remake because a remake is what puts the votes of before out of reach (below). +propose one of their own where they don't like it. + +**The voters before.** A decision of voters that a decision on who votes replaced +counts only where that decision's proposal was signed in sight of it decided. So once +others vote, votes of before, kept back or made up with keys stolen later, decide +nothing; and what the voters before decided while the list that replaced them was +voted on, they propose again to those who vote now. **How.** @@ -927,7 +932,9 @@ those carried over come before those of the new epoch: Remakes). Two with the sa number, made out of each other's sight, are both decided only where the nodes of a third of the voters took both up, which an honest node doesn't; then the one with the lower digest holds. A decision closes the proposals of its matter with a lower number: -clients offer no vote on them. +clients offer no vote on them. A decision that holds is **final** once it has been +seen holding for `final` (Lengths of time): from then on no decision of its matter +holds instead whose proposal wasn't signed in sight of it, whatever its number. **A node carrying for many.** A record counts for every voter its node carries for. So a node that carries for a third of the voters, and keeps its records back, holds @@ -964,11 +971,12 @@ page, paper) is the application's. **From the past.** Votes kept back until they ran out, or crafted to look old, are held while they run by no honest node, so nothing takes their proposal up but its makers' nodes, and their records are judged like any: they need the votes of two -thirds of the voters. With that many keys stolen later, a decision of then is made -up within the epoch, and holds if it gets the highest number of its matter; the -voters decide a later one. A remake puts everything before its base out of reach. A -remake's vote doesn't run out: kept back, it counts when it comes, as its signer -wrote. +thirds of the voters. With that many keys stolen later, a decision of then is made up +within the epoch, and holds if it gets the highest number of its matter, until the +decision of that matter that holds is final; the voters decide a later one. Of voters +that others replaced, it decides nothing (The voters before). A remake puts everything +before its base out of reach. A remake's vote doesn't run out: kept back, it counts +when it comes, as its signer wrote. The votes are the users' own, signed with their keys, and take the days people take. Taking up is their nodes', and takes as long as syncing does. One time is compared @@ -1001,8 +1009,12 @@ clocks. A window of days bears clocks that are minutes apart. * **A name the rules leave to the voters** (`"{voters}"`): given to a user, who holds it as by a claim and releases it like one; it doesn't count toward its limit. Released, it is given anew. -* **A remake**, and with it who votes and who the roots are in the next epoch - (below). An epoch has one. +* **Who votes**: the list of voters, by their IDs, one matter. Recommended, as said + above, those who take part. +* **Who the roots are**: their IDs, one matter, and for each root it leaves out which + root has each name a rule gives a root. One that names no root is no proposal: + nobody would be in. +* **A remake** (below). An epoch has one. A decision stays, whatever is cut off after: a vote signed with a key that is retired later, from before, stays in it. The days a vote takes are the time to cut a stolen @@ -1010,16 +1022,12 @@ key off. ### Remakes -A federated swarm compacts by a remake its voters decide. A remake throws history -away and names who votes and who the roots are in the next epoch, and does nothing -else: what the next epoch holds isn't voted on. It is the registry as it resolves, -which every node works out itself. +A federated swarm compacts by a remake its voters decide. A remake throws history away +and does nothing else: what the next epoch holds isn't voted on. It is the registry as +it resolves, which every node works out itself. -* **The proposal** lists the voters of the next epoch by their IDs, names its roots - (those there are, unless it names others; and for a root it leaves out, which root - has each name a rule gives a root), names the node of its proposer that is to be its - **coordinator**, and the switch delay. One that names no root is no proposal: nobody - would be in. +* **The proposal** names the node of its proposer that is to be its **coordinator**, + and the switch delay. * **The base.** The coordinator names the base in its record of the proposal, by its heads, at once. * **Taking the base up.** Every node takes the base up where the base holds all that @@ -1064,7 +1072,7 @@ which every node works out itself. as it holds it, and switches after the switch delay its proposal names. The snapshot holds the registry as it resolves at the base: * the policy that holds, with its numbers; - * the voters and the roots, as the proposal says; + * the voters and the roots, as the decisions that hold say; * the users that count, and those out and not gone, each with its name (or that it is contested, and with which), ID, keys, nodes, and who created and who vouches for it, or that it is in by the seats; @@ -1167,9 +1175,7 @@ which every node works out itself. For the registry the document is small: a statement is under a KiB, a node's alive stamp with its digest and signature some 350 bytes, so a hundred nodes stamping -daily write some 13 MiB a year. A remake a year is plenty for its size. What a -remake also does is name the voters and the roots; a swarm whose users come and go -remakes for that. +daily write some 13 MiB a year. A remake a year is plenty for its size. ### Coming back after remakes @@ -1211,7 +1217,7 @@ Either way, what follows: and names: the node carries for it as before, and writes its member entry anew. Or out, its names waiting. Or gone, and so not in the snapshot: then no node takes the node's changes, it shows why, and its user comes in again as anyone does. -* **As a voter or a root** the user is what the epoch it arrives in names it. +* **As a voter or a root** the user is what the decisions that hold there name it. * **Its old document** goes to the archive, as today. A node moves to an older epoch, or to another of the same age that doesn't hold by the @@ -1261,13 +1267,13 @@ policy changes the rules, and neither needs the other. ### Going apart: a fork by choice Whoever the swarm's decisions leave behind goes on apart, with those who want the -same: with an only root that went before the first remake, with a third of the +same: with an only root that went before it decided on others, with a third of the voters gone so that nothing is decided, with two thirds of them turned against the rest, or for a policy the others won't have. A fork is proposed, and binds nobody: * Any user proposes it, one at a time: the policy to go on with (the one that holds, or another), and, if it likes, who votes there and who the roots are. - Where it names none, they are as in a remake. Voters may vote for it: that shows + Where it names none, they are as they hold. Voters may vote for it: that shows who would go, and decides nothing. * The proposer's node names the base, as a remake's coordinator does, when its user says so, votes or none. @@ -1280,10 +1286,9 @@ rest, or for a policy the others won't have. A fork is proposed, and binds nobod neighbours. A statement signed on one side counts for nothing on the other: it names its epoch. What was signed in the epoch both came from counts on both, and a node carries for its user on a side only by writing there. -* On each side the voters are those its epoch names, the ones that went the other - way among them. A side that keeps two thirds of them remakes, and names those who - stayed. A side with fewer decides nothing until it names its own, by a fork of - its own. +* On each side the voters are those its decisions name, the ones that went the other + way among them. A side that keeps two thirds of them decides on those who stayed. A + side with fewer decides nothing until it names its own, by a fork of its own. It moves nobody, and takes nothing along but the history: each party chooses its side. @@ -1321,10 +1326,10 @@ What refusing does: beyond that base, decisions among it but the one refused. So refusing costs what a remake costs whose base is a window older than the proposal was taken up, and however long the decision hung after. -* **After**, as after any fork: the same swarm ID and the same history up to the - base, different epochs, no syncing between them. On each side the voters are - those the epoch names, and a side with too few of them names its own, by a fork. - A node moves to the other side by its operator's word. +* **After**, as after any fork: the same swarm ID and the same history up to the base, + different epochs, no syncing between them. On each side the voters are those its + decisions name, and a side with too few of them names its own, by a fork. A node + moves to the other side by its operator's word. * **A remake** is refused by staying: the epoch a node is in goes on as it was. So every number is the swarm's to set, and each party's to bear or not. A decision @@ -1375,7 +1380,9 @@ A proposal's `matter` and what it `holds`: | `name`, naming an out user and the name | free, or the user ID it is given to | | `whose`, naming a kind and a name | the digest of the claim that is to hold it | | `votersName`, naming a kind and a name | the user ID it is given to | -| `remake` | `voters` (IDs), `roots` (IDs, and for each root left out which root has each name a rule gives it), `coordinator` (a node's ID), `switchDelay` | +| `voters` | the voters' IDs | +| `roots` | the roots' IDs, and for each root left out which root has each name a rule gives it | +| `remake` | `coordinator` (a node's ID), `switchDelay` | | `fork` | the policy to go on with, and, if it likes, `voters` and `roots` | A fork is no matter: a vote for one counts toward nothing, shows who would go, and @@ -1835,6 +1842,12 @@ a write is refused only by what its own history holds, and counts from the start * *Not from the past.* So votes crafted later, or kept back until they ran out, bring no honest node to take anything up, and the nodes of fewer than a third decide nothing. +* *Not by the voters before.* A decision of voters that a decision on who votes + replaced counts only in sight of that decision's proposal, which was signed before + any key stolen later: the voters before decide nothing more. And a decision seen + holding for `final` by a third of the voters, an honest one among them, is replaced + only by one proposed in its sight: one of its matter made up later, with whatever + number, isn't. * *The same one everywhere.* Whether a proposal is decided is read from its records and their histories; which decision of a matter holds, from the proposals' numbers, which follow from what each says its signer saw, and their digests. No @@ -1858,11 +1871,10 @@ a write is refused only by what its own history holds, and counts from the start holds and judged itself. An honest voter's node takes up no base that leaves out what it held `baseAge` before, unless records of it count for a third of V, an honest one among them; and it records the ID it built: a remake is decided for one - ID. Who votes next and who the roots are is in the proposal, for all to see before - they vote for it. What a node holds beyond the base it carries over itself, by its - carry record, so what any honest node held comes along. And a voter's vote names its - base, once an epoch: two bases are both decided only where more than a third of the - voters signed for both. + ID. What a node holds beyond the base it carries over itself, by its carry record, + so what any honest node held comes along. And a voter's vote names its base, once an + epoch: two bases are both decided only where more than a third of the voters signed + for both. * *Nobody is moved.* A node refuses any decision by its operator's word or bounds, and follows a fork by its operator's word alone; going back refuses the remake. A node that waits by `remakeAge` follows once the new epoch's carry records count for more @@ -1912,9 +1924,10 @@ far as the roots' nodes' witness. * **One root.** One user's nodes would settle every claim, nothing would be settled while it is away, and it alone would stand between a claim and whoever backdates. Several roots cost a contest where two of them saw two claims in two orders. -* **A root seated by a decision, within the epoch**: what the root before it settled, - and whom it created, would change its standing after the fact, between the - proposal and the decision. The roots are an epoch's, named with its voters. +* **Roots for a whole epoch**, changed only by a remake: a root that turns would keep + its seat until one. A decision changes them, and whether a user is a root is read + where each thing it did was done: what a root settled and whom it created keep the + standing they had. * **Votes by nodes**: a party runs as many nodes as it likes. * **Voters by a rule** (the users a root itself created, whom nobody else can multiply): who takes part and who doesn't is known to people, not to a rule. So @@ -1923,7 +1936,7 @@ far as the roots' nodes' witness. neither votes nor counts): those who stay could go on deciding whoever left. But silence is shown by stamps, and whoever stamps together shows the rest silent: a majority would decide at once what is to take two thirds, and a proposal crafted - to look old would choose who counts. Every voter counts; a remake names those who + to look old would choose who counts. Every voter counts; a decision names those who take part, and where a third are gone before one, those left go apart. * **Recommending a majority, not two thirds**: a third that votes both ways must not get two proposals of one matter decided, to choose between them. Two thirds stand @@ -1965,10 +1978,10 @@ far as the roots' nodes' witness. think alike. * **Users voting as soon as they are created**: whoever creates users carries every decision. -* **Voters let in by a decision, without a remake**: nobody fills the votes, and - nobody waits for a remake. But the voters of before make a decision "of then" - later (the first root alone, for the time it was the only one). A remake is what - puts that out of reach. +* **Voters named by a remake**, the votes of before put out of reach by throwing + history away: the voters before would still decide "of then" within the epoch (the + first root alone, for the time it was the only one), and who votes would wait for a + remake. Sight of the proposal that replaced them puts it out of reach. * **A snapshot of only what its users' own nodes write again**: every node carries over what it holds, whoever signed it. Else what a root's node saw first after the base would be nowhere in the next epoch, and whoever wrote first there would @@ -2074,11 +2087,11 @@ the party. In continuum, as rules every node judges by and data that parametrizes them: users by statements (creating, vouching and unvouching, lines, keys, cuts, nodes that carry), the namespace rule, claims by kind with their rules and limits, late, contested, -settled and final, lengths of time read from the stamps, decisions by the -voters (the numbers, the policy, a user's first keys, names), remakes that every -node builds and that name the voters and the roots, going apart and refusing a -decision, resolving and its API, the drop an operator asks for. All of it is -general: a swarm with other kinds, or none, uses the same. +settled and final, lengths of time read from the stamps, decisions by the voters (who +votes, the roots, the numbers, the policy, a user's first keys, names), remakes that +every node builds, going apart and refusing a decision, resolving and its API, the +drop an operator asks for. All of it is general: a swarm with other kinds, or none, +uses the same. In the application, for the registry: which kinds there are and their rules (data in the genesis change), what a host's entry holds, the client that signs (an extension of @@ -2117,15 +2130,14 @@ what the registry is, and, byte for byte, the snapshot a remake builds. Whether versions do can't be told by looking at them, and a version's number says what its author remembered to say. So the design goes by what nodes compute: -* **Every stamp says what its node computes.** With its alive stamp a node records - the digest of the registry as it resolves at that change's dependencies: what a - snapshot would hold there, less the members' entries and what a remake's proposal - names. A node that holds those changes resolves there and compares: as it goes - where it holds exactly those, else for the latest stamp of each other party once - in a while. Two digests for the same changes prove that two nodes resolve - differently, signed by both, at the first input where they do: it shows - (`GET /peers`, the dashboard) long before a remake would have sent them to two - epochs. +* **Every stamp says what its node computes.** With its alive stamp a node records the + digest of the registry as it resolves at that change's dependencies: what a snapshot + would hold there, less the members' entries. A node that holds those changes + resolves there and compares: as it goes where it holds exactly those, else for the + latest stamp of each other party once in a while. Two digests for the same changes + prove that two nodes resolve differently, signed by both, at the first input where + they do: it shows (`GET /peers`, the dashboard) long before a remake would have sent + them to two epochs. * **A remake is taken up by its result.** A voter's node builds the snapshot from the base before it takes the remake up, and records the ID of the epoch it got. The remake is decided for the ID that the nodes of two thirds of the voters got. A @@ -2211,7 +2223,7 @@ Unvouching: | # | The adversary | Honest nodes | Promise | Shown by | |---|---|---|---|---| | 22 | Unvouches a user it didn't vouch for; a root unvouches the users the root change holds, or those a root before it created | Refuse the first. What is the seats' is taken back once every root unvouched it: one root puts nobody out, where there are several | 3 | unit: `only_the_voucher_unvouches`, `the_seats_take_back_together` | -| 23 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and nothing else: who votes is the remake's word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` | +| 23 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and nothing else: who votes is the voters' word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` | | 24 | Unvouches saying it saw little, to undo what the user did since | What its own nodes or a root's had seen of the user stays | as said under Unvouching | unit: `an_unvouch_undoes_nothing_seen` | | 25 | The unvouched user signs on, saying it saw nothing of the unvouch, or across a partition | Hold it as part of another's history only; it doesn't count; after healing every node finds the same | 2, 3 | unit: `past_an_unvouch`; sim: `an_unvouch_across_a_partition` | | 26 | A user is unvouched: what of those it brought in, and its names? | One that another vouched for stays in, without doing anything. The others are out from the same point; a vouch after brings them back whole. Their names wait | 4 | unit: `a_second_line_keeps_it`, `those_it_brought_in`, `a_vouch_brings_back` | @@ -2276,8 +2288,8 @@ Decisions and remakes: | # | The adversary | Honest nodes | Promise | Shown by | |---|---|---|---|---| | 67 | Forges a vote; votes as a user that isn't a voter, or one that is gone | Refuse | 7 | unit, decisions: `a_vote_is_a_voters` | -| 68 | Brings in many users to vote, also while a remake's votes run | They vote only if a remake's list names them, which those who vote saw | 7 | unit: `who_votes` | -| 69 | A remake's list of voters with the many users one user brought in; users put out between the votes and the base, to shrink the list | The voters see the list, by IDs, before they vote for it, and propose one of their own instead. Nothing after the proposal changes it | 7 | unit: `voters_are_the_remakes`, `a_list_is_fixed_when_signed` | +| 68 | Brings in many users to vote, also while a list's votes run | They vote only if a decided list names them, which those who voted saw | 7 | unit: `who_votes` | +| 69 | A list of voters with the many users one user brought in; users put out between the votes and the decision, to shrink the list | The voters see the list, by IDs, before they vote for it, and propose one of their own instead. Nothing after the proposal changes it | 7 | unit: `voters_by_a_decision`, `a_list_is_fixed_when_signed` | | 70 | Records taking a proposal up without the votes, or with released ones | Refuse: every node judges a record against the votes in its history. A remake's record needs none: a remake is decided only by votes naming its base | 7 | unit: `a_record_needs_the_votes` | | 71 | Carries for many voters that have no node, and records with votes that ran out | Taken: nobody but the recording node reads a vote's end. A voter without a node is the party that carries for it, for a record; what is seen for long counts that node once | not promised | unit: `a_record_counts_for_its_voters`; argued (Decisions) | | 72 | Carries for a third of the voters, and keeps its records back: every decision waits, and comes on its day | The voters name another node, which records for them; their votes count meanwhile. A voter carried by nodes of two parties never waits for one. How many each node carries for shows | not promised | sim: `a_carrier_keeps_back` | @@ -2328,46 +2340,47 @@ Decisions and remakes: | 117 | Tells a node that was away of an epoch that isn't the swarm's | The node rejoins no epoch that peers advertise: it finishes the old one from archives and builds the next itself, or takes the ID its operator gave | 1 | sim: `away_over_a_remake`, `back_by_an_id` | | 118 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `carried_over_one_epoch_only` | | 119 | A version builds another snapshot from a remake's base | Its node records another ID. The remake is decided for the ID two thirds got; the node stays, and says so | 7 | sim: `a_remake_by_its_result` | -| 120 | A remake names its proposer the only root, or leaves a root out; the root left out signs on as one | The voters see whom a remake names before they vote for it. A root is one in the epoch that names it: what it signs after is an ordinary user's, and it is out unless someone vouches for it | 7 | unit: `roots_are_the_remakes`, `a_root_for_its_epoch` | -| 121 | Two thirds of the voters turn on the rest | They remake, name the roots and who votes, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) | -| 122 | Offers a statement signed on the other side of a fork | Refuse: it names its epoch | 3 | unit: `signed_for_its_user_id_and_epoch` | -| 123 | A fork naming its proposer the only voter and root | A node follows only by its operator's word, which names the proposal; what that says shows | 7 | sim: `a_fork_by_choice` | -| 124 | A decision breaks a node's bounds: the voters let one of them decide for all | The node refuses it and moves to the epoch built without it, the same for every node that refuses, with what it held: they go on together | 7 | unit: `bounds_on_the_numbers`; sim: `those_who_refuse_meet` | -| 125 | Proposes saying it saw only the epoch's root, so that those who refuse carry the whole epoch over | No honest node takes up a proposal that says it saw less than the node held a window before: it isn't decided | 7 | unit: `a_proposal_says_it_saw_enough` | -| 126 | Says it refuses a decision, or hands out the ID of an epoch without it, to draw nodes there | A node goes there by its own bounds or its operator's word only | 1 | unit: `refusing_is_ones_own` | +| 120 | A decision on the roots names its proposer the only root, or leaves a root out; the root left out signs on as one, and its node witnesses on | The voters see whom a proposal names before they vote for it. A root is one where the decision naming it holds, read where each thing it did was done: what it signs after it is left out is an ordinary user's, its node's changes after witness as no root's, and it is out unless someone vouches for it | 7 | unit: `roots_by_a_decision`, `a_root_where_it_is_one` | +| 121 | With the keys of two thirds of voters since replaced, stolen later, makes up a decision of then; or a list of voters of its own, with the number of the one that replaced them and a lower digest | What voters that others replaced decide counts only in sight of the proposal that replaced them: the first decides nothing. The second holds only until the list it would replace is final: no decision of its matter proposed out of sight of a final one holds | 7; not promised before final | unit: `the_voters_before`, `a_final_decision` | +| 122 | Two thirds of the voters turn on the rest | They name the roots and who votes, remake, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) | +| 123 | Offers a statement signed on the other side of a fork | Refuse: it names its epoch | 3 | unit: `signed_for_its_user_id_and_epoch` | +| 124 | A fork naming its proposer the only voter and root | A node follows only by its operator's word, which names the proposal; what that says shows | 7 | sim: `a_fork_by_choice` | +| 125 | A decision breaks a node's bounds: the voters let one of them decide for all | The node refuses it and moves to the epoch built without it, the same for every node that refuses, with what it held: they go on together | 7 | unit: `bounds_on_the_numbers`; sim: `those_who_refuse_meet` | +| 126 | Proposes saying it saw only the epoch's root, so that those who refuse carry the whole epoch over | No honest node takes up a proposal that says it saw less than the node held a window before: it isn't decided | 7 | unit: `a_proposal_says_it_saw_enough` | +| 127 | Says it refuses a decision, or hands out the ID of an epoch without it, to draw nodes there | A node goes there by its own bounds or its operator's word only | 1 | unit: `refusing_is_ones_own` | Nodes and syncing: | # | The adversary | Honest nodes | Promise | Shown by | |---|---|---|---|---| -| 127 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` | -| 128 | 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` | -| 129 | 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` | -| 130 | 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` | -| 131 | 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` | -| 132 | Signs a token for any user with its node's key | Taken only by a node whose operator named the signing node | 3 | unit: `a_token_of_ones_party` | -| 133 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` | -| 134 | Lies in its member entry (ready, reached, stable); publishes a short window there to make every node stamp hourly; writes an entry of any size | Sync and trees bend; nothing gets in that way. How often nodes stamp is the policy's; an entry has a shape and a size, or the change is refused | 6 | unit: `an_entry_has_a_shape`, `stamps_by_the_policy`; argued (Reaching the others) | -| 135 | Sends envelopes that don't check, without end | Refuse each (a signature costs about 30 µs to check *(docs)*); the node is refused as a whole after the first of its own | 6 | sim: `a_refused_node_costs_little` | -| 136 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` | -| 137 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` | -| 138 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_the_user_an_entry_names_beside_others` | -| 139 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` | -| 140 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` | -| 141 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` | -| 142 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it: nothing bounds a change's operations | not promised (a bound on what an epoch's document costs) | argued | -| 143 | Crafts a change Automerge won't take, or that writes in an object nowhere to be found | Refuse *(checked: the rules refuse the second today)*; only the message that brought it fails | 1 | unit: `a_change_writing_nowhere` | -| 144 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, operations numbered against its dependencies', a gap in its actor's changes, an operation named that is elsewhere or outside its history, an operation Automerge's transactions never write (an element written over naming the one inserted after it, an insert that replaces, a deletion or an increment inserted, a deletion named as replaced), a table written into, a value written at a mark's begin | Refuse before Automerge sees it, by the change and its own history alone: applied, such a change makes a node panic, save a document that doesn't load, or part from nodes it reached in another order | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `a_gap_in_an_actors_changes_is_refused`, `operations_named_at_the_wrong_place_are_refused`, `operations_outside_a_changes_history_are_refused`, `only_what_transactions_write_passes`, `only_what_holds_a_value_is_replaced`, `no_table`, `no_mark`, `what_passes_leaves_automerge_sound`, `a_batch_is_checked_against_itself`, `a_change_refused_after_its_check_stands_in_for_nothing` | +| 128 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` | +| 129 | 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` | +| 130 | 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` | +| 131 | 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` | +| 132 | 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` | +| 133 | Signs a token for any user with its node's key | Taken only by a node whose operator named the signing node | 3 | unit: `a_token_of_ones_party` | +| 134 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` | +| 135 | Lies in its member entry (ready, reached, stable); publishes a short window there to make every node stamp hourly; writes an entry of any size | Sync and trees bend; nothing gets in that way. How often nodes stamp is the policy's; an entry has a shape and a size, or the change is refused | 6 | unit: `an_entry_has_a_shape`, `stamps_by_the_policy`; argued (Reaching the others) | +| 136 | Sends envelopes that don't check, without end | Refuse each (a signature costs about 30 µs to check *(docs)*); the node is refused as a whole after the first of its own | 6 | sim: `a_refused_node_costs_little` | +| 137 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` | +| 138 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` | +| 139 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_the_user_an_entry_names_beside_others` | +| 140 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` | +| 141 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` | +| 142 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` | +| 143 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it: nothing bounds a change's operations | not promised (a bound on what an epoch's document costs) | argued | +| 144 | Crafts a change Automerge won't take, or that writes in an object nowhere to be found | Refuse *(checked: the rules refuse the second today)*; only the message that brought it fails | 1 | unit: `a_change_writing_nowhere` | +| 145 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, operations numbered against its dependencies', a gap in its actor's changes, an operation named that is elsewhere or outside its history, an operation Automerge's transactions never write (an element written over naming the one inserted after it, an insert that replaces, a deletion or an increment inserted, a deletion named as replaced), a table written into, a value written at a mark's begin | Refuse before Automerge sees it, by the change and its own history alone: applied, such a change makes a node panic, save a document that doesn't load, or part from nodes it reached in another order | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `a_gap_in_an_actors_changes_is_refused`, `operations_named_at_the_wrong_place_are_refused`, `operations_outside_a_changes_history_are_refused`, `only_what_transactions_write_passes`, `only_what_holds_a_value_is_replaced`, `no_table`, `no_mark`, `what_passes_leaves_automerge_sound`, `a_batch_is_checked_against_itself`, `a_change_refused_after_its_check_stands_in_for_nothing` | Rules, and the swarm as it is: | # | The adversary | Honest nodes | Promise | Shown by | |---|---|---|---|---| -| 145 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from the nodes of more than two thirds of the other voters at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` | -| 146 | Stamps a wrong digest, to keep the nodes that upgrade from writing; one of three voters does | A node stops only where it differs from the nodes of more than two thirds of the other voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody`, `of_three_voters` | -| 147 | A policy version a node doesn't know: in the root, or decided | It doesn't sync, and takes no such proposal up: a policy is decided only with two thirds of the voters' nodes knowing it | 1 | unit: `no_sync_under_an_unknown_policy`, `an_unknown_policy_isnt_taken_up` | -| 148 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number | 7 | sim: `one_side_decides`; unit: `the_last_holds` | -| 149 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` | +| 146 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from the nodes of more than two thirds of the other voters at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` | +| 147 | Stamps a wrong digest, to keep the nodes that upgrade from writing; one of three voters does | A node stops only where it differs from the nodes of more than two thirds of the other voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody`, `of_three_voters` | +| 148 | A policy version a node doesn't know: in the root, or decided | It doesn't sync, and takes no such proposal up: a policy is decided only with two thirds of the voters' nodes knowing it | 1 | unit: `no_sync_under_an_unknown_policy`, `an_unknown_policy_isnt_taken_up` | +| 149 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number | 7 | sim: `one_side_decides`; unit: `the_last_holds` | +| 150 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` | ## The registry on it ``` @@ -2397,14 +2410,13 @@ a user without keys, its hosts as they are, plain, and their addresses as claims its name. The genesis change is trusted as it is (every party is given its hash), so what it holds counts without signatures: a host it holds counts until its user signs over it, and a claim it holds is its user's. One of the roots gives each user its -first keys as it comes; from then on the user signs its own, and votes from the next -remake that lists it. A namespace whose user never comes stays as the genesis change -has it. +first keys as it comes; from then on the user signs its own, and votes once a decision +lists it. A namespace whose user never comes stays as the genesis change has it. What to weigh, moving in. With one maintainer as the only root and voter, that one settles every claim, decides alone, and sees alone what a third of the voters see, -until a remake names others: more than one from the start is better, and a first -remake once the users that take part are there. A user that comes later is created +until it decides on others: more than one from the start is better, and a first +list of voters once the users that take part are there. A user that comes later is created by one root, who takes that back alone; another's vouch makes it stand without that root's word. @@ -2424,7 +2436,7 @@ it trusts for that. ## Stages Each leaves the system working, and is a few patches with its tests, which leave -their vectors. At every stage the existing tests pass untouched (149). +their vectors. At every stage the existing tests pass untouched (150). 1. **A federated swarm's frame.** `--genesis-policy` (a file, written into the genesis change with the roots, the voters and the users it starts with); a federated node @@ -2432,7 +2444,7 @@ their vectors. At every stage the existing tests pass untouched (149). yet, takes tokens and logins by key as its operator says, keeps ended sessions to itself, stamps as the policy says, and writes a member entry of the policy's shape and size. What the genesis change sets for the swarm as a whole is read from the - policy. Tests: 131 to 134, 141, 144, 147, 149, and the policy's existing tests + policy. Tests: 132 to 135, 142, 145, 148, 150, and the policy's existing tests under a policy from the genesis change. Those of a crafted change, and of a crafted committer, exist already: screening refuses those in every swarm. 2. **Statements.** The users' registers (`create`, `key`, `node`, `vouch`, `release`); @@ -2454,8 +2466,8 @@ their vectors. At every stage the existing tests pass untouched (149). read from the stamps; final. `GET /registry/claims` with what makes a claim late; values marked in `GET /store`. A node keeps its seeds and its user's other nodes as neighbours, leaves out members that name another epoch, and shows a claim long - unsettled. Tests: 7, 9, 10, 13, 15, 16, 36, 38, 39, 43 to 46, 49, 52, 53, 127, 129, - 130. + unsettled. Tests: 7, 9, 10, 13, 15, 16, 36, 38, 39, 43 to 46, 49, 52, 53, 128, 130, + 131. 6. **Cuts.** `retire` and the keys above, a node that stops, a cut never reaching its own statement, what a cut takes back, what doesn't count left out, the value before read again, the client listing what stopped counting. Tests: 14, 20, 47, 48, 51, 54 @@ -2468,7 +2480,7 @@ their vectors. At every stage the existing tests pass untouched (149). 8. **Coming back.** The drop an operator asks for, a forked actor 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: 128, 135 to 140, 142, 143. + writer over a clean stop. Tests: 129, 136 to 141, 143, 144. 9. **The registry.** Import, export, and a federated swarm of the simulations with the registry's kinds and a few hundred hosts. From here it can be tried: users, hosts, names, a root that settles, names that become final. It isn't to be relied on yet. @@ -2477,33 +2489,34 @@ their vectors. At every stage the existing tests pass untouched (149). after the last stage, by an import of what it holds. 10. **Decisions.** `propose` and `vote`, signed by the client and taken from any node, the nodes' records and how they are judged, taking up, decided, the decision that - holds, what hangs; `GET /registry/decisions`. What is decided: a number, a user's - first keys, the names of a user that is out, whose a contested name is, a name the - rules leave to the voters. The simulations start from a root change naming several - voters, as a remake's does. Tests: 23, 63, 67, 70 to 86, 148. + holds, what hangs; `GET /registry/decisions`. What is decided: who votes, who the + roots are, a number, a user's first keys, the names of a user that is out, whose a + contested name is, a name the rules leave to the voters; a decision of the voters + before counted only in sight of the list that replaced them; a final decision. The + simulations start from a root change naming several voters. Tests: 23, 63, 67 to + 86, 120, 121, 149. 11. **Versions.** The digest with every stamp, a node checking itself before it writes; for every swarm, a node that speaks the wire version before its own, and a - handshake that says which epochs its node keeps. Tests: 145, 146. -12. **Remakes.** The proposal with its list of voters, its roots and its coordinator; - the base, every one a node finds holding what it held `baseAge` before, however - old where records count for a third, one record a proposal, judged without votes; - votes naming it, one a voter and epoch, offered by clients only where records - count for two thirds; taking a remake up by its result, the snapshot every node - builds, what it leaves out and what can't be written again; carrying over: every - node's carry record, then each envelope once, in its order, with the new epoch's - word last on values; a retirement's list as its cut; decisions and what was seen - for long, over a remake; what becomes final. A node keeping the epochs it left on - disk, peers answering for them and saying which; a node walking them, or rejoining - by an ID its operator gave, and by none that peers advertise. Tests: 68, 69, 89 to - 95, 103 to 110, 116 to 120. + handshake that says which epochs its node keeps. Tests: 146, 147. +12. **Remakes.** The proposal with its coordinator; the base, every one a node finds + holding what it held `baseAge` before, however old where records count for a + third, one record a proposal, judged without votes; votes naming it, one a voter + and epoch, offered by clients only where records count for two thirds; taking a + remake up by its result, the snapshot every node builds, what it leaves out and + what can't be written again; carrying over: every node's carry record, then each + envelope once, in its order, with the new epoch's word last on values; a + retirement's list as its cut; decisions and what was seen for long, over a remake; + what becomes final. A node keeping the epochs it left on disk, peers answering for + them and saying which; a node walking them, or rejoining by an ID its operator + gave, and by none that peers advertise. Tests: 89 to 95, 103 to 110, 116 to 119. 13. **The policy by a decision.** The policy as a matter, a node that doesn't know it, what it no longer covers: shown aside, taken away by its user only, dropped after - a time, moved at a remake. Tests: 30, 50, 87, 88, 147. + a time, moved at a remake. Tests: 30, 50, 87, 88, 148. 14. **Going apart, and refusing.** A fork followed by an operator's word, with who votes and who the roots are on its side. Refusing a decision: a node's bounds, how late a remake it follows at once (`remakeAge`) and how the split heals, a waiting node's fetch of the new epoch's carry records, going back as refusing, the epoch - without the decision, what a node takes along. Tests: 111 to 115, 121 to 126. From + without the decision, what a node takes along. Tests: 111 to 115, 122 to 127. From here it can be relied on: the rules change by decisions. ## What was checked, and what is assumed |
