aboutsummaryrefslogtreecommitdiffstats
path: root/docs
diff options
context:
space:
mode:
Diffstat (limited to 'docs')
-rw-r--r--docs/federation.md389
1 files changed, 228 insertions, 161 deletions
diff --git a/docs/federation.md b/docs/federation.md
index 9b12c55..b1cadad 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -127,7 +127,8 @@ What is not promised:
that covers a name no more. And a third of them, stamping as they like, make a
user that is out gone, a claim final, and what a policy uncovered dropped, at
once. A third is one where there are up to three voters: a few maintainers at the
- start are each that third.
+ start are each that third. And a limit lowered for a day gives the names claimed
+ meanwhile, in sight of what fell past it, to their claimants for good.
* **A name through a long partition.** A user unvouched on one side of a partition
that outlasts `gone` is gone, though someone vouched for it in time on the other.
Two claims that each became final on a side of one that outlasts `final` are
@@ -140,7 +141,8 @@ What is not promised:
vouched for it say so: one root, for a user only that root created.
* **Decisions against a third of the voters.** A third or more of them keep anything
from being decided, and by voting both ways get two proposals of one matter
- decided and choose which is the later.
+ decided and choose which is the later. So does a node that carries for a third of
+ them, until they name another (Decisions).
* **When a proposal is decided.** One that had the votes and lacks records of nodes
hangs over its matter: whoever holds the last record chooses the day. The voters
end that by deciding a later proposal of the matter (Decisions).
@@ -300,18 +302,20 @@ grows. A statement is signed by one user and says one thing:
* **A user without a node** names another party's, which carries for it too if it
agrees. That node's changes witness for both, and it takes proposals up for both:
for the swarm, such a user is the party that carries for it. Nothing is signed in
- its place.
+ its place. It names nodes of more than one party where it can: each records for it,
+ so no one of them alone keeps it from counting, nor chooses the day.
* **Writers.** A node writes as a writer (an Automerge actor), a fresh one each time
- it starts, rejoins or drops *(docs)*. Every writer costs every node memory while
- the epoch lasts, in proportion to the document's history: about 4 bytes per change
- *(measured upstream)*. So a federated node keeps its writer over a clean stop, and
- a party's budget (below) counts the writers its nodes start: past `limits.writers`
- in an epoch, a change that starts another is put off by every node that would
- take it from the party's own nodes, until a remake. It is never refused: put off
- is each node's doing, and a change that reaches a node within another's history
- is taken. A writer is a run, not a write: with a thousand, three nodes each crash
- or rejoin daily for most of a year. How many a party started shows
- (`GET /registry/users`), for a remake to come first.
+ it starts, rejoins or drops *(docs)*. Every writer costs every node memory while the
+ epoch lasts, in proportion to the document's history: about 4 bytes per change
+ *(measured upstream)*. So a federated node keeps its writer over a clean stop, and a
+ party's budget (below) counts the writers its nodes start: past `limits.writers` in
+ an epoch, a change that starts another is put off by every node that would take it
+ from the party's own nodes, until a remake. It is never refused: put off is each
+ node's doing, and a change that reaches a node within another's history is taken.
+ Writers a node started outside a cut it was stopped with count for nobody: a thief's
+ node costs its victim nothing once cut off. A writer is a run, not a write: with a
+ thousand, three nodes each crash or rejoin daily for most of a year. How many a
+ party started shows (`GET /registry/users`), for a remake to come first.
* **A party's budget.** A node takes changes from a party's nodes no faster than a
budget, its own setting: what is over waits, and nothing is refused for it. For a
budget a party is a user with the users below it that no line reaches but through
@@ -320,15 +324,17 @@ grows. A statement is signed by one user and says one thing:
* **Past a limit.** A user's statements of one kind are counted from the first: each
has, and states, the number after the highest of those it was signed in sight of,
and of two with one number the one with the lower digest comes first. A statement is
- past its limit if as many of that kind come before it as the limit allows. What
- was given up (a key retired, a node stopped, a claim released, a proposal decided
- or released) or is left out by a cut comes before nothing, whenever that was: so
- what a thief signed with a stolen key stands in nobody's way once the key is cut
- off. What comes to count that way, later than it was signed, gets nothing by it: a
- claim gives way to what was claimed in sight of it meanwhile (Claims). It doesn't
- count while it is past its limit. The limit is the one that holds where the
- registry is read: lowered, it leaves out the last. So for every limit: keys beyond
- the first, nodes, creations, vouches, proposals, a kind's claims.
+ past its limit if as many of that kind come before it as the limit allows. What was
+ given up (a key retired, a node stopped, a claim released, a proposal decided or
+ released) or is left out by a cut comes before nothing, whenever that was: so what a
+ thief signed with a stolen key stands in nobody's way once the key is cut off. What
+ comes to count that way, later than it was signed, gets nothing by it: a claim gives
+ way to what was claimed in sight of it meanwhile (Claims). It doesn't count while it
+ is past its limit. The limit is the one that holds where the registry is read:
+ lowered, it leaves out the last. So for every limit: keys beyond the first, nodes,
+ creations, vouches, proposals, a kind's claims. Across a remake, what the snapshot
+ holds comes first, then what is carried over, by the numbers it states, then what is
+ signed in the new epoch (Remakes).
* **Names** of users are 1 to 64 of `A-Z a-z 0-9 . _ @ -`, as today, less the
top-level keys the swarm uses otherwise (`_continuum`). Which of them may be
created, and by whom, the kind `user` says (Claims).
@@ -759,6 +765,8 @@ What to weigh in a list:
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.
* Whoever brought users in brought voters in, where the list has them: a user that
created sixteen is seventeen of it.
@@ -783,15 +791,16 @@ remake because a remake is what puts the votes of before out of reach (below).
decided with a vote whose release was on its way. A vote is meant when signed.
3. A node that carries for a voter **takes the proposal up** once it holds votes for
it by more than two thirds of all the voters (`fractions.decide`), none released,
- each still running by the node's clock. It records so, once, under
- `_continuum/decisions/<proposal>/<node ID>`. It takes up only a proposal with a
- higher number than any of the matter that it took up, or that it holds as taken
+ each still running by the node's clock, and the proposal says its signer saw all
+ that the node held `window` before the proposal reached it. It records so, once,
+ under `_continuum/decisions/<proposal>/<node ID>`. It takes up only a proposal with
+ a higher number than any of the matter that it took up, or that it holds as taken
up by another node of its voters. Every node judges the record: its history must
hold votes for the proposal by that many voters, none released there. A record
counts for each voter its node carries for, and a voter once, however many of its
- nodes record. The node of a voter that is out commits its records all the same,
- and nothing else, and peers sync with it for that: every voter has nodes of its
- own, and nobody's record stands in for another's.
+ nodes record. The node of a voter that is out commits its records all the same, and
+ nothing else, and peers sync with it for that: every voter has nodes of its own,
+ and nobody's record stands in for another's.
4. The proposal is **decided**, and is a **decision**, once a record of it has in its
history, itself among them, records that count for more than two thirds of all
the voters. Who carried for whom and what the fraction was are read where each
@@ -803,12 +812,20 @@ take the proposal up as it reaches them, and it is decided as fast as they sync.
**The last holds.** Several proposals of one matter can be open, and voted on, at a
time, and more than one can come to be decided: voters change their minds. Of the
-decisions of a matter, the one with the highest number **holds**. Two with the same
+decisions of a matter, the one with the highest number **holds** (across a remake,
+those carried over come before those of the new epoch: Remakes). Two with the same
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.
+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.
+
+**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
+up every decision, and chooses the day of those it is needed for. Its voters end
+that by naming another node, which commits the `node` statement naming it and
+records for them; a voter carried by nodes of two parties depends on neither alone.
+Nothing is lost meanwhile: the votes count, with the records of any node the voter
+names after. `GET /registry/decisions` shows how many voters each node carries for.
**What hangs.** A proposal that had the votes and is short of records (nodes were
down, or keep theirs back) can still be decided, and whoever holds the last record
@@ -935,29 +952,48 @@ which every node works out itself.
removed: a release is a statement like any other, signed, and a document keeps its
history. The remake is what deletes.
* **Nothing it dropped is written again.** An envelope is taken in the epoch it names
- and in the next. So that what a remake left out (a stolen laptop's key and node,
- retired since) can't be handed in again in the next epoch as signed in the one
- before, the root change lists the digests of all the statements the base held,
- and of the values deleted there, and an envelope among them is refused. The epoch
- after drops the list.
-* **Carried over.** A node that switches writes again, as they are, the envelopes it
- holds that the base lacks, whoever signed them: statements, values, proposals and
- votes with their releases. Before it switches it catches up with the peers it
- keeps in the epoch it leaves, as a node that comes back does; then it writes, in
- its first changes of the new epoch, before it takes anything there. Any node
- commits what names the epoch before (a `node` statement only the node it names).
- It is taken as it is signed, and never refused for what stands in the new epoch:
- whether it counts is resolved.
-* **What it held of them** the node states beside them, in its member entry, as the
- snapshot states it for the base: which claim it held as late against which, or as
- giving way to which; which statements of a user since unvouched count through the
- unvouch; which value replaced which. That is the node's word, as the order of its
- changes was in the old epoch, and it counts where the node's change would have:
- against a claim, where a node of that claim's side states it; for an unvouch,
- where a node of the unvoucher or of a root does. So a claim that turns up later as
- signed in the epoch before is late against what a root's node carried over, and
- nothing rests on the order a node happens to write in. Against a claim the
- snapshot holds, what is carried over gives way.
+ and, carried over, in the next. So that what a remake left out (a stolen laptop's
+ key and node, retired since) can't be handed in again in the next epoch as signed in
+ the one before, the root change lists the digests of all the statements the base
+ held, and of the values deleted there, and an envelope among them is refused. The
+ epoch after drops the list.
+* **Carried over.** A node that switches first catches up with the peers it keeps
+ in the epoch it leaves, as a node that comes back does. Then, before it takes
+ anything in the new epoch, it commits its **carry record**,
+ `_continuum/carried/<node ID>`: the digests of the envelopes it holds that the
+ base lacks, whoever signed them (statements, values, proposals, votes and their
+ releases), and what it held of them, as the snapshot states it for the base:
+ which claim it held as late against which, or as giving way to which; which
+ statements of a user since unvouched count through the unvouch; which users it
+ held as gone, which claims as final and what as dropped, beyond the snapshot. One
+ record a node and epoch, of digests and of what the node held. A node that came
+ to carry after the base commits, with its record, the `node` statement that named
+ it (rule 2).
+* **Then the envelopes, once.** After its record the node takes from its peers, and
+ writes again, as they are, the envelopes its record names that the epoch doesn't
+ hold yet. Any node commits such an envelope (a `node` statement only the node it
+ names), and only where a carry record in the change's history names it: what no
+ node held when it switched isn't taken in the new epoch. It is taken as it is
+ signed, and never refused for what stands in the new epoch: whether it counts is
+ resolved. So an envelope comes into the new epoch about once, and what each node
+ witnessed comes as 32 bytes a node.
+* **A carry record witnesses** as the node's changes did in the epoch before: as a
+ change with what it names in its history, standing or not as it says. Against a
+ claim, where a node of that claim's side committed it; for an unvouch, where a
+ node of the unvoucher or of a root did. So a claim that turns up later as signed
+ in the epoch before is late against what a root's node's record names, and
+ nothing rests on the order a node writes in. Against a claim the snapshot holds,
+ what is carried over gives way.
+* **Its order and its numbers.** Of a user's statements of one kind, and of the
+ proposals of a matter, those the snapshot holds come first, then those carried
+ over, by the numbers they state, then those signed in the new epoch. So a number
+ nobody could check (a statement signed after the switch as of the epoch before)
+ orders nothing but its own signer's statements among themselves, and a proposal
+ carried over never outranks one of the new epoch.
+* **Its values.** A value carried over counts while no value its user signed in the
+ new epoch is at its place: whoever writes in the new epoch has the last word over
+ what the epoch before held, seen or not. Of several carried over to one place,
+ one that another replaces is left out (Resolving).
* **A cut carried over** is the list its statement carries (Cuts): what the key
signed within the cut since the root change counts on, and nothing else of that
key that the snapshot doesn't hold.
@@ -969,14 +1005,12 @@ which every node works out itself.
once it holds again. Where the remake changed the voters so that its votes are
too few, it is proposed again.
* **Seen for long, over a remake.** What was gone, final or dropped at the base is so
- in the snapshot. What came to be so after the base: each node that carries for a
- voter says in its member entry, in its first change of the new epoch, which users it
- held as gone, which claims as final and what as dropped, beyond the snapshot. What
- the nodes of a third of the voters say, a node counted for one voter, is so. Every
- other length starts anew.
-* **A remake decided late** sends every node to a base that old. What was signed
- since comes along: every node carries over what it holds and states what it held
- of it, decisions among it. What it costs is the lengths of time that had begun,
+ in the snapshot. What came to be so after the base, each node that carries for a
+ voter says in its carry record. What the nodes of a third of the voters say, a node
+ counted for one voter, is so. Every other length starts anew.
+* **A remake decided late** sends every node to a base that old. What was signed since
+ comes along, about once: every node's carry record names what it holds and what it
+ held of it, decisions among it. What it costs is the lengths of time that had begun,
and whatever only a node witnessed that didn't come along.
* **What a remake makes final.** A cut reaches no further back than the snapshot.
What a key signed that counted at the base counts for good, though the key be cut
@@ -1025,7 +1059,8 @@ in one of two ways:
Either way, what follows:
* **What it holds and the swarm never got.** What was signed in the epoch just before
- the one the node arrives in is carried over: written again as it is. What was
+ the one the node arrives in is carried over: the node commits its carry record
+ when it arrives, and writes again what the epoch lacks. What was
signed further back isn't: an envelope is taken in its epoch and the next, no
later. Its own user's go to the quarantine, and the client lists them for the
user to sign again. A claim signed again is a new claim, after what was claimed
@@ -1127,7 +1162,9 @@ What refusing does:
* **Before.** While a proposal's votes run, a node whose bounds it breaks says so in
its member entry, so the voters see who would go (`GET /registry/decisions`).
* **The epoch without it.** A node that refuses a decision moves to the epoch built
- where its proposal was signed (at the changes the proposal says its signer saw):
+ where its proposal was signed (at the changes the proposal says its signer saw,
+ which no honest node took it up without holding all it had held `window`
+ before):
the registry as it resolves there, the policy, the voters and the roots as they
are there, and the digest of the proposal refused, which makes it no other epoch
and no proposal there. Every node that refuses the same decision builds the same
@@ -1135,7 +1172,8 @@ What refusing does:
it.
* **What it takes along.** As with a remake, the node carries over what it holds
beyond that base, decisions among it but the one refused. So refusing costs what
- a remake costs, however old the proposal is.
+ 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.
@@ -1173,23 +1211,24 @@ A change is valid if, in the document at its dependencies:
the epoch's snapshot). Else:
2. Its committer is a node that carries for a user there, one that isn't out and
hasn't stopped there, proven by the node's signature. Or the change is the one by
- which a node comes to carry: it holds a `node` statement naming its committer, by
- a user that isn't out there, the committer's member entry, and nothing else. Or
- it holds nothing but the committer's own record of a proposal, and the committer
- carries for a voter that is out.
+ which a node comes to carry: it holds a `node` statement naming its committer, by a
+ user that isn't out there, the committer's member entry and, after a remake, its
+ carry record, and nothing else. Or it holds nothing but the committer's own record
+ of a proposal, and the committer carries for a voter that is out.
3. Apart from the node's own member entry (of the shape the policy's version gives it,
- within `limits.entry`) and its own records of proposals, it writes only envelopes,
- each naming the swarm, its epoch, its path, its user and user ID, and for a
- statement what its signer saw (`seen`, changes in this change's history) and, where
- statements of its kind are numbered, the number that gives it, signed with a key
- that is that user's there and not retired there. The committer carries for that
- user, but for a proposal, a vote and their release, which any node commits, and a
- `node` statement, which the node it names does.
+ within `limits.entry`), its own records of proposals and its carry record, it
+ writes only envelopes, each naming the swarm, its epoch, its path, its user and
+ user ID, and for a statement what its signer saw (`seen`, changes in this change's
+ history) and, where statements of its kind are numbered, the number that gives it,
+ signed with a key that is that user's there and not retired there. The committer
+ carries for that user, but for a proposal, a vote and their release, which any node
+ commits, and a `node` statement, which the node it names does.
4. In a register (`_continuum/users/<name>`, `_continuum/claims/<kind>/<name>`): only
a new entry under its own digest. Under `_continuum/decisions/<proposal>`: only the
node's own record, once, of a proposal that is there, with votes for it in the
change's history by more than `fractions.decide` of the voters, none released
- there. Nothing replaced, nothing deleted, nor anything that holds a register.
+ there. Under `_continuum/carried`: only the node's own carry record, once an
+ epoch. Nothing replaced, nothing deleted, nor anything that holds a register.
5. A `create`: its name is one the kind `user` takes, has no creation there that
stands, a rule of the kind lets the signer, and the signer isn't past its limit
there; or it is a root's, for a user the root change holds, that has no keys there.
@@ -1214,11 +1253,13 @@ A change is valid if, in the document at its dependencies:
the swarm as a whole: never.
**What is carried over**: an envelope naming the epoch before this one is held to
-less. Any node commits it (a `node` statement only the node it names). What it says
-its signer saw isn't looked at, and its number is taken as it states it. Of 5 to 8
-only what the envelope itself shows is asked: its signature by a key that is its
-user's there, its register, for a value that it replaces what is there, and that
-the root change doesn't list its digest. Whether it counts is resolved.
+less, and comes one way only: in a change that has in its history a carry record
+naming its digest. Any node commits it (a `node` statement only the node it names).
+What it says its signer saw isn't looked at, and its number orders only among what
+is carried over. Of 5 to 8 only what the envelope itself shows is asked: its
+signature by a key that is its user's there, its register, for a value that its
+`prev` is a value the snapshot or another carried over holds there, and that the
+root change doesn't list its digest. Whether it counts is resolved.
Where a rule goes by a user's name (6, 7) and the name has several creations there, a
user that lost it, as far as the change's history shows (another remains, Two claims),
@@ -1280,8 +1321,9 @@ the steps before:
wait while it is out; else the name is contested. A kept name is held by the user
that has the user name.
5. **Values.** A value in a namespace counts if its envelope does and its user has the
- name. Where the document holds several at one place (written at once, or written
- again after a remake by nodes that held different ones), one that another there
+ name. A value carried over is left out where its user signed one in the new epoch
+ at that place. Where the document holds several at one place (written at once,
+ or carried over by nodes that held different ones), one that another there
replaces, directly or along `prev`, is left out; of the rest, those that count,
in Automerge's order. Where the one there doesn't count, the last that does, back
along `prev` (read in the document at the dependencies of the change that
@@ -1535,7 +1577,8 @@ a write is refused only by what its own history holds, and counts from the start
node holds and judged itself. An honest voter's node takes up no base that leaves
out what it held, and 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. And a
+ 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
node records one base for its epoch: two are both decided only where the nodes of
a third of the voters recorded both.
* *Nobody is moved.* A node refuses any decision by its operator's word or bounds,
@@ -1674,6 +1717,20 @@ back, so the point only moves forward as more of them show up.
* **Saying what was held by the order of a node's first changes** after a remake: an
order says one thing, and what a node held of a claim, an unvouch and a value are
three. The node states them.
+* **Every node writing again all it holds** after a remake, before taking anything:
+ each envelope since the base would come once for every node that held it, a
+ month's statements times the nodes after a remake decided late. The nodes witness
+ by digest, and the envelopes come once.
+* **An envelope of the epoch before taken from anyone, all the next epoch**: what a
+ user signed and never sent, whoever got it could hand in, with a number of its
+ choosing, and a value long replaced could come back over what the user wrote
+ since. Only what a carry record names comes (which a node holding it can still
+ see to), its numbers order only what is carried over, and a value of the new
+ epoch has the last word.
+* **The epoch for those who refuse built wherever a proposal says it was signed**:
+ its signer would choose what refusing costs, up to a whole epoch carried over.
+ Nobody takes up a proposal that says it saw less than its node held a window
+ before.
* **A late claim standing in wait** for the name: whoever signed, in time, a claim
that says it saw nothing would have the name the moment its holder lets go.
* **A limit on writers as a rule**: a change starting one writer too many would be
@@ -1739,7 +1796,8 @@ takes tokens and logins by key as its operator says, writes no sessions into the
document, keeps its writer over a clean stop, stamps as often as the policy says,
keeps its seeds and its user's other nodes as neighbours, keeps the document of an
epoch it left on disk and answers for it, keeps a quarantine on disk that holds
-envelopes, writes again after a remake what it holds beyond the base, takes no remake
+envelopes, commits its carry record after a remake and writes again what the epoch
+lacks, takes no remake
but one its voters decided, rejoins no epoch because peers advertise it, and refuses
what its bounds say. For every swarm: the wire's version, with a handshake that says
which epochs its node keeps, and a node that speaks the wire version before its own
@@ -1773,9 +1831,12 @@ author remembered to say. So the design goes by what nodes compute:
* **A node checks itself before it writes.** Started with a version it didn't run
before, a node judges and resolves again what it holds *(docs: a node told that
policies disagree does so today)*, and compares with the stamps it holds of the
- voters' nodes. Where it differs from those of a third of the voters or more, it
+ voters' nodes. Where it differs from the nodes of more than two thirds of the other
+ voters (`fractions.decide`; a voter counted once, however many nodes it has), it
writes nothing, and shows it, until its operator says to go on. Where it differs
- from fewer it shows that and goes on: one party stamping nonsense stops nobody.
+ from fewer it shows that and goes on. So fewer than a third stamping nonsense stop
+ nobody, with three voters too, and a version that computes otherwise than the honest
+ ones stops.
* **A change of the rules is a change of policy.** What a version judges or resolves
differently on purpose, it does under a policy of its own (a part of the policy
that versions before don't know), which the swarm decides. A change is judged by
@@ -1909,70 +1970,75 @@ Decisions and remakes:
| 62 | 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` |
| 63 | Records taking a proposal up without the votes, or with released ones | Refuse: every node judges a record against the votes in its history | 7 | unit: `a_record_needs_the_votes` |
| 64 | 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) |
-| 65 | Keeps votes back until they ran out, or crafts them to look old, then shows them | No honest node takes the proposal up, and fewer than a third decide nothing | 7 | unit: `taken_up_while_the_votes_run`; sim: `a_decision_from_the_past` |
-| 66 | Keeps its node's record back, and shows it weeks later: a proposal decided late | It holds only where none of its matter with a higher number was decided since: a node takes up nothing lower than it took up. What hangs shows, and the voters end it with a later proposal | not promised | unit: `nothing_lower_is_taken_up`; sim: `decided_late` |
-| 67 | Two proposals of one matter both decided: voters changed their minds, or a third voted both ways | Every node acts on the one with the higher number, the same from the same changes; the other shows as replaced | 7 | unit: `the_last_holds`; sim: `two_decided_one_holds` |
-| 68 | Makes a proposal saying it saw little or much, for a number of its choosing; grinds its digest; commits another's a second time | A number brings nothing without the votes of two thirds and their nodes' records; who votes is the epoch's, wherever a proposal is made; a second carrier changes nothing | 7 | unit: `a_proposal_is_where_it_was_signed` |
-| 69 | Stays away to hold decisions up | It counts on. A third staying away do hold them up: the rest go apart, naming who votes | 7 | unit: `two_thirds_of_all` |
-| 70 | Asks the voters for another user's first keys, saying it is that user | It takes two thirds of them, and the days a vote takes, shown to all; the user signs on meanwhile | not promised | argued (Decisions) |
-| 71 | Puts a voter's vote into a change of its own node; keeps one back; offers one again | Taken: the signature is the voter's. It counts while it runs; the register holds it once | 7 | unit: `a_vote_by_any_node` |
-| 72 | Signs a vote that says it runs out in ten years | A node counts no vote for longer than `window` from when it first held it | 7 | unit: `a_vote_runs_a_window` |
-| 73 | A decision lowers a limit; a user signs on saying it saw nothing of the decision. Or a decision sets a number that makes no sense | Valid as written, and resolved by the limit that holds: what is past it doesn't count. The number has the result it has | 6 | unit: `a_lowered_limit_leaves_out_the_last` |
-| 74 | Opens proposals without end | Refuse past `limits.proposals` | 6 | unit: `limits_on_proposals` |
-| 75 | A proposal gives away the name of a user that is out; the user is gone and another claims the name before it is decided | The claim was made in sight of one that didn't stand: it doesn't give way to what the decision gives | 5 | unit: `given_too_late` |
-| 76 | Contests a name, then asks the voters for it | It takes two thirds of them; the claim they name is final | not promised | unit: `whose_a_contested_name_is` |
-| 77 | Claims `wiki.r`, which the rules leave to the voters; holds on to it against a later decision | Refuse the claim. The name is whose the decision that holds says | 4, 7 | unit: `a_name_by_the_voters` |
-| 78 | A user is out and stays out: what of its names? | A decision frees them, or gives them to another, whatever `gone` says | 7 | unit: `a_decision_frees_or_gives` |
-| 79 | The voters decide a policy that covers a user's names no more; another user writes over what is uncovered; a third of the voters stamp to drop it at once | It doesn't count where the policy holds, and shows aside. Only its user takes it away, nobody changes it; it is dropped once seen there for `uncovered` | not promised | unit: `what_a_policy_no_longer_covers`, `uncovered_is_only_taken_away` |
-| 80 | The voters decide a policy that stops keeping names for their users | A kept name its user claimed stays its claim. One it didn't is the first comer's | not promised | unit: `a_kept_name_claimed` |
-| 81 | Names a base for a remake that leaves out what the swarm holds | No honest voter's node takes it up | 7 | sim: `a_stale_base_is_not_taken_up` |
-| 82 | A remake's coordinator names two bases, or none; a voter's nodes record two IDs | A node records one base for its epoch, and such a voter counts for neither: one is decided, or none, and then those left go apart | 7 | sim: `two_bases_no_remake` |
-| 83 | Runs most of the nodes; serves a snapshot of its own | Nothing reads a count of nodes; every node builds the snapshot itself | 7 | sim: `every_node_builds_the_snapshot` |
-| 84 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | Every node wrote again what it held, in its first changes of the new epoch and in order: the pretender's claim is late against what a root's node carried over | 5 | unit: `carried_over_in_order`; sim: `a_pretender_after_a_remake` |
-| 85 | After a remake, writes again a value its user replaced since the base; or a node that held only the older one writes it beside the newer | Of several at one place, one that another there replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
-| 86 | Signs a claim "in the epoch before" of a name the snapshot holds | It gives way to what the snapshot holds | 5 | unit: `the_snapshot_comes_first` |
-| 87 | Hands in again what a remake left out: a stolen laptop's `node` and `key` statements, retired since | Refuse: the root change lists the digests of the statements the base held | 3 | unit: `what_a_remake_dropped_stays_out` |
-| 88 | Keeps the last record of a remake back, and shows it a month later | Every node goes to that base, carries over what it holds, and states what it held of it: statements, values, who saw what first, decisions since. A key rotated since keeps what its retirement lists. What a third of the voters' nodes held as gone, final or dropped stays so; other lengths start anew | not promised | sim: `a_remake_decided_late`; unit: `a_retirement_lists_what_it_keeps` |
-| 89 | Has a second remake of an epoch taken up beside one that hangs, and decides it after the swarm switched to the first | A node records one base for its epoch, and takes a later proposal up only for that base, those voters and roots: a second is decided only where the nodes of a third of the voters recorded both. No node that switched moves again by itself | 7 | sim: `one_base_an_epoch` |
-| 90 | A thief's statements are in the base of a remake | They stand: a remake makes final. The vote's days are the time to cut the key off | not promised | unit: `a_cut_reaches_to_the_snapshot` |
-| 91 | 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` |
-| 92 | 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` |
-| 93 | 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` |
-| 94 | 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` |
-| 95 | 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) |
-| 96 | 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` |
-| 97 | 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` |
-| 98 | 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` |
-| 99 | 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` |
+| 65 | 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` |
+| 66 | Keeps votes back until they ran out, or crafts them to look old, then shows them | No honest node takes the proposal up, and fewer than a third decide nothing | 7 | unit: `taken_up_while_the_votes_run`; sim: `a_decision_from_the_past` |
+| 67 | Keeps its node's record back, and shows it weeks later: a proposal decided late | It holds only where none of its matter with a higher number was decided since: a node takes up nothing lower than it took up. What hangs shows, and the voters end it with a later proposal | not promised | unit: `nothing_lower_is_taken_up`; sim: `decided_late` |
+| 68 | Two proposals of one matter both decided: voters changed their minds, or a third voted both ways | Every node acts on the one with the higher number, the same from the same changes; the other shows as replaced | 7 | unit: `the_last_holds`; sim: `two_decided_one_holds` |
+| 69 | Makes a proposal saying it saw little or much, for a number of its choosing; grinds its digest; commits another's a second time | A number brings nothing without the votes of two thirds and their nodes' records; who votes is the epoch's, wherever a proposal is made; a second carrier changes nothing | 7 | unit: `a_proposal_is_where_it_was_signed` |
+| 70 | Stays away to hold decisions up | It counts on. A third staying away do hold them up: the rest go apart, naming who votes | 7 | unit: `two_thirds_of_all` |
+| 71 | Asks the voters for another user's first keys, saying it is that user | It takes two thirds of them, and the days a vote takes, shown to all; the user signs on meanwhile | not promised | argued (Decisions) |
+| 72 | Puts a voter's vote into a change of its own node; keeps one back; offers one again | Taken: the signature is the voter's. It counts while it runs; the register holds it once | 7 | unit: `a_vote_by_any_node` |
+| 73 | Signs a vote that says it runs out in ten years | A node counts no vote for longer than `window` from when it first held it | 7 | unit: `a_vote_runs_a_window` |
+| 74 | A decision lowers a limit; a user signs on saying it saw nothing of the decision. Or a decision lowers a limit for a day, and raises it again. Or it sets a number that makes no sense | Valid as written, and resolved by the limit that holds: what is past it doesn't count. Names claimed in sight of what fell past it are their claimants' for good. The number has the result it has | 6; not promised | unit: `a_lowered_limit_leaves_out_the_last` |
+| 75 | Opens proposals without end | Refuse past `limits.proposals` | 6 | unit: `limits_on_proposals` |
+| 76 | A proposal gives away the name of a user that is out; the user is gone and another claims the name before it is decided | The claim was made in sight of one that didn't stand: it doesn't give way to what the decision gives | 5 | unit: `given_too_late` |
+| 77 | Contests a name, then asks the voters for it | It takes two thirds of them; the claim they name is final | not promised | unit: `whose_a_contested_name_is` |
+| 78 | Claims `wiki.r`, which the rules leave to the voters; holds on to it against a later decision | Refuse the claim. The name is whose the decision that holds says | 4, 7 | unit: `a_name_by_the_voters` |
+| 79 | A user is out and stays out: what of its names? | A decision frees them, or gives them to another, whatever `gone` says | 7 | unit: `a_decision_frees_or_gives` |
+| 80 | The voters decide a policy that covers a user's names no more; another user writes over what is uncovered; a third of the voters stamp to drop it at once | It doesn't count where the policy holds, and shows aside. Only its user takes it away, nobody changes it; it is dropped once seen there for `uncovered` | not promised | unit: `what_a_policy_no_longer_covers`, `uncovered_is_only_taken_away` |
+| 81 | The voters decide a policy that stops keeping names for their users | A kept name its user claimed stays its claim. One it didn't is the first comer's | not promised | unit: `a_kept_name_claimed` |
+| 82 | Names a base for a remake that leaves out what the swarm holds | No honest voter's node takes it up | 7 | sim: `a_stale_base_is_not_taken_up` |
+| 83 | A remake's coordinator names two bases, or none; a voter's nodes record two IDs | A node records one base for its epoch, and such a voter counts for neither: one is decided, or none, and then those left go apart | 7 | sim: `two_bases_no_remake` |
+| 84 | Runs most of the nodes; serves a snapshot of its own | Nothing reads a count of nodes; every node builds the snapshot itself | 7 | sim: `every_node_builds_the_snapshot` |
+| 85 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | A root's node named the real claim in its carry record, before it took anything in the new epoch: the pretender's claim is late against it | 5 | unit: `a_carry_record_witnesses`; sim: `a_pretender_after_a_remake` |
+| 86 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Refuse what no carry record names. A node that holds such an envelope can still name it in its own record: then a value carried over has no word against one its user signed in the new epoch, and a claim is late against what a root's node's record named | 3 | unit: `only_what_a_carry_record_names`, `the_new_epoch_has_the_last_word` |
+| 87 | Signs after the switch, as of the epoch before, statements and a proposal with numbers of its choosing | Carried over comes after what the snapshot holds and before what the new epoch signs: such a number orders only its signer's statements among what is carried over, and the proposal outranks none of the new epoch | 6, 7 | unit: `carried_over_in_between` |
+| 88 | Writes a carry record naming what it likes, or several, or one of its own after taking from peers | One a node and epoch. What it names is its node's word, as a change of that node would have been: a contest where it is a root's or the claimant's, no more | 5 | unit: `one_carry_record_a_node` |
+| 89 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several carried over to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
+| 90 | Signs a claim "in the epoch before" of a name the snapshot holds | It gives way to what the snapshot holds | 5 | unit: `the_snapshot_comes_first` |
+| 91 | Hands in again what a remake left out: a stolen laptop's `node` and `key` statements, retired since | Refuse: the root change lists the digests of the statements the base held | 3 | unit: `what_a_remake_dropped_stays_out` |
+| 92 | Keeps the last record of a remake back, and shows it a month later | Every node goes to that base. Its carry record names what it holds and what it held of it (who saw what first, decisions since), and each envelope comes once. A key rotated since keeps what its retirement lists. What a third of the voters' nodes held as gone, final or dropped stays so; other lengths start anew | not promised | sim: `a_remake_decided_late`; unit: `a_retirement_lists_what_it_keeps` |
+| 93 | Has a second remake of an epoch taken up beside one that hangs, and decides it after the swarm switched to the first | A node records one base for its epoch, and takes a later proposal up only for that base, those voters and roots: a second is decided only where the nodes of a third of the voters recorded both. No node that switched moves again by itself | 7 | sim: `one_base_an_epoch` |
+| 94 | A thief's statements are in the base of a remake | They stand: a remake makes final. The vote's days are the time to cut the key off | not promised | unit: `a_cut_reaches_to_the_snapshot` |
+| 95 | 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` |
+| 96 | 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` |
+| 97 | 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` |
+| 98 | 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` |
+| 99 | 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) |
+| 100 | 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` |
+| 101 | 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` |
+| 102 | 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` |
+| 103 | 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` |
+| 104 | 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 |
|---|---|---|---|---|
-| 100 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
-| 101 | 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` |
-| 102 | 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` |
-| 103 | 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` |
-| 104 | Hands a joining node another root, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
-| 105 | 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` |
-| 106 | 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` |
-| 107 | 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) |
-| 108 | 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` |
-| 109 | Writes its own member entry 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` |
-| 110 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a party and epoch, every node puts off the changes that start more, taking none from the party's own nodes. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out | 6; not bounded | sim: `writers_past_a_budget_wait` |
-| 111 | 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 | argued |
-| 112 | 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` |
-| 113 | 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 | 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` |
+| 105 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
+| 106 | 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` |
+| 107 | 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` |
+| 108 | 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` |
+| 109 | Hands a joining node another root, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
+| 110 | 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` |
+| 111 | 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` |
+| 112 | 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) |
+| 113 | 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` |
+| 114 | Writes its own member entry 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` |
+| 115 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a party and epoch, every node puts off the changes that start more, taking none from the party's own nodes. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out | 6; not bounded | sim: `writers_past_a_budget_wait` |
+| 116 | 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 | argued |
+| 117 | 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` |
+| 118 | 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 | 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` |
Rules, and the swarm as it is:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 114 | 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 a third of the voters' nodes 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` |
-| 115 | Stamps a wrong digest, to keep the nodes that upgrade from writing | A node stops only where it differs from the nodes of a third of the voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody` |
-| 116 | 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` |
-| 117 | 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. A remake is taken up on one side only by a voter's honest nodes, which record one base | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
-| 118 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
+| 119 | 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` |
+| 120 | 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` |
+| 121 | 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` |
+| 122 | 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. A remake is taken up on one side only by a voter's honest nodes, which record one base | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
+| 123 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
## The registry on it
```
@@ -2029,7 +2095,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 (118).
+their vectors. At every stage the existing tests pass untouched (123).
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
@@ -2037,7 +2103,7 @@ their vectors. At every stage the existing tests pass untouched (118).
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: 104 to 107, 116, 118, and the policy's existing tests under a policy
+ policy. Tests: 109 to 112, 121, 123, and the policy's existing tests under a policy
from the root.
2. **Statements.** The users' registers (`create`, `key`, `node`, `vouch`, `release`);
the user ID, the epoch and what its signer saw in an envelope; nodes carrying for
@@ -2058,7 +2124,7 @@ their vectors. At every stage the existing tests pass untouched (118).
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: 10, 11, 25, 31, 33, 34, 38 to 41, 44, 47, 48, 100, 102, 103.
+ unsettled. Tests: 10, 11, 25, 31, 33, 34, 38 to 41, 44, 47, 48, 105, 107, 108.
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: 15, 42, 43, 46, 49 to
@@ -2069,7 +2135,7 @@ their vectors. At every stage the existing tests pass untouched (118).
Tests: 17, 19 to 24, 26, 27, 54.
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 it
- counts, a node keeping its writer over a clean stop. Tests: 101, 108 to 112.
+ counts, a node keeping its writer over a clean stop. Tests: 106, 113 to 117.
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.
@@ -2081,25 +2147,26 @@ their vectors. At every stage the existing tests pass untouched (118).
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: 18, 56, 60, 63 to 78, 117.
+ voters, as a remake's does. Tests: 18, 56, 60, 63 to 79, 122.
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: 114, 115.
+ handshake that says which epochs its node keeps. Tests: 119, 120.
12. **Remakes.** The proposal with its list of voters, its roots and its coordinator;
the base, one an epoch, 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, by
- every node, with what it held of what it carries; 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: 61, 62, 81 to 94.
+ 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: 61, 62, 82 to
+ 98.
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: 79, 80, 116.
+ a time, moved at a remake. Tests: 80, 81, 121.
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, the
- epoch without the decision, what a node takes along. Tests: 95 to 99. From here it
- can be relied on: the rules change by decisions.
+ epoch without the decision, what a node takes along. Tests: 99 to 104. From here
+ it can be relied on: the rules change by decisions.
## What was checked, and what is assumed
@@ -2202,8 +2269,8 @@ Assumed, to be shown as it is built:
* The snapshot of a federated remake, built from the resolved registry, comes out
byte for byte the same on every node, as today's does from the document.
* A node can keep on disk, and answer sync for, an epoch it left.
-* A node can write again what it holds beyond a base before it takes anything from a
- peer, in changes ordered as the claims' order asks, at a registry's size.
+* A node can commit its carry record (the digests of what it holds beyond a base, and
+ what it held of it) before it takes anything from a peer, at a registry's size.
* What was seen for long is kept as the node goes, per voter's node and per thing
watched (a user out, a claim holding its name, a thing uncovered), costs little,
and is built again from the changes at a start.