aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--docs/federation.md835
1 files changed, 477 insertions, 358 deletions
diff --git a/docs/federation.md b/docs/federation.md
index bce0d0a..9e389af 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -120,7 +120,8 @@ What is not promised:
out, or give them to another, say who has a contested name, and decide a policy
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.
+ once. A third is one where there are up to three voters: a few maintainers at the
+ start are each that third.
* **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
@@ -147,10 +148,11 @@ What is not promised:
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).
* **A bound on what an epoch's document costs.** What is valid as written every node
- holds until a remake: statements past a limit, and writers started out of each
- other's sight, each of which costs memory in proportion to the history. A limit
- bounds how many in sight, and a party's budget how fast; who did it shows, under
- its nodes' signatures.
+ holds until a remake: statements past a limit, and writers started beyond what a
+ party's budget takes, each of which costs memory in proportion to the history. A
+ budget bounds how fast a node takes them from the party itself, not how many
+ reach it as part of others' histories; who did it shows, under its nodes'
+ signatures.
* **A swarm that never splits.** A node that forks its own actor (two changes with one
number) splits the honest nodes that took one from those that took the other, until
one side drops its own (Partitions). It is found, proven and named; it isn't
@@ -212,7 +214,7 @@ value:
| `limits.users` | 16 | users a user created that stand; a root: no limit |
| `limits.vouches`, `limits.bans` | 64 | vouches, and bans, of a user that stand |
| `limits.proposals` | 8 | proposals of a user that are open |
-| `limits.writers` | 1024 | writers a user's nodes start in an epoch |
+| `limits.writers` | 1024 | writers a party's nodes start in an epoch before more are put off |
| `limits.name` | 255 | bytes of a name |
| `limits.entry` | 4096 | bytes of a node's member entry |
| a kind's `limit` | none | names of the kind a user holds by a claim |
@@ -220,8 +222,9 @@ value:
| `fractions.seen` | 1/3 | the share of the voters whose nodes must have seen a thing for long: a user out, a claim holding, a thing uncovered |
What today's genesis change sets for the swarm as a whole (how many neighbours, the
-topology, the dissemination, the relays *(checked: `document::meta`)*) are numbers of
-the policy too.
+topology, the dissemination *(checked: `swarm::bootstrap`)*) are numbers of the
+policy too. The relays aren't: they are addresses an operator lists, which come and
+go, and they stay what they are today.
Nothing constrains them, and a number that makes no sense has the result it has. A
time of nothing is "at once"; a limit of nothing lets nothing more in; a `baseAge` of
@@ -271,7 +274,9 @@ grows. A statement is signed by one user and says one thing:
It may be there without keys (a registry moved in from elsewhere): then it is in,
has its name and what the root change holds in its name, and nobody signs for it,
until a root's `create` for that name gives it its first keys. That is no other
- user, and the only `create` a name that is taken gets.
+ user. It is taken only where the user has no keys, and two of them signed out of
+ each other's sight are two claims of one thing: neither gives keys until one is
+ released.
* **Keys form a tree.** A user's first keys are those its creation names. A `key`
statement adds one, signed with a key the user has, which is **above** the new one,
as are the keys above itself. Any number over time; at once as many as
@@ -294,22 +299,31 @@ grows. A statement is signed by one user and says one thing:
* **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 user's nodes start `limits.writers` in an epoch at
- most, and a federated node keeps its writer over a clean stop. A writer is a run,
- not a write: with a thousand, three nodes each crash or rejoin daily for most of
- a year. A user whose nodes started that many starts no more until a remake, so a
- node of its that crashes then writes nothing. How many a user's nodes started
- shows (`GET /registry/users`), for a remake to come first.
+ *(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.
+* **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
+ it: creating users makes no second budget. A node carrying for several users
+ draws on each.
* **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, not
- counting what was given up or cut off in its sight (a key retired, a node stopped, a
- claim released). It doesn't count. So what is signed out of the sight of the others
- to get past a limit doesn't, and giving up an earlier one later doesn't bring a
- later one in. The limit is the one that holds where the registry is read: lowered,
- it leaves out the last. So for every limit: keys, nodes, creations, vouches, bans,
- 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, bans, proposals, a kind's claims.
* **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).
@@ -374,9 +388,13 @@ node, and what that node had seen at each, from the stamps' histories.
A thing has been **seen for** a length of time, at a set of changes, once a third of
the voters (`fractions.seen`; the voters: Decisions) each have a node with two alive
stamps that far apart or more, the thing so at both and at every stamp of that node
-between. A length of nothing takes one stamp. A node counts for one voter in this,
-though it carry for several. It is read from the changes alone: the stamps are
-changes in the history, each renewal one.
+between. The earlier stamp is in the later one's history, and between them are that
+node's stamps that have the earlier in their history and are in the later's: so a
+stamp that shows up afterwards, built on neither, lies between nothing. A thing is
+so at a stamp as that stamp's own history resolves. A length of nothing takes one
+stamp. A node counts for one voter in this, though it carry for several: as many
+voters have seen a thing as can each be given a node of their own. It is read from
+the changes alone: the stamps are changes in the history, each renewal one.
* A node that is up renews its stamp as often as `stamp` says, whatever else is
written or isn't. (Today the interval follows what members publish in their
@@ -411,8 +429,8 @@ exactly:
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, at whatever node takes its vote. Who votes is a
- remake's word, not its vouchers'.
+ is a voter, it votes on, and its nodes record proposals (Decisions). Who votes is
+ a remake's 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.
@@ -453,8 +471,10 @@ saying who has a contested name; its vouchers unvouching it; and a root unvouchi
the user it created above it, with all below, who then need other vouches. A vouch
from anyone brings it back.
-A user gives itself up by a `release` of its own creation, signed with a first key:
-from that release on it is gone, and its names are free at once.
+A user gives itself up by a `release` of its own creation, signed with a first key.
+That puts it out by its own word: its names wait, and it is gone once seen so for
+`gone`. Until then a cut takes the release back like any other statement, the
+voters' cut too, where the first key was stolen.
### Namespaces
@@ -520,23 +540,31 @@ What must be unique across users (a host's name, an address, a top-level domain)
only growing: `claim` (by the user who wants it) and `release` (by that user, of its
claim: how a name is given up). A claim **stands** while it counts, isn't released,
its user isn't gone, a rule of the policy lets its user, and no decision freed the
-name or gave it to another.
+name or gave it to another. The claims of a user that is out stand as they stood: a
+rule that lets anyone lets anyone who isn't gone.
A claim is taken, as its writer saw the document, if a rule lets the user, the user
is within the kind's limit, and no claim of that name stands there. That is first
come, first served wherever one claim was made in sight of the other: the later one
is refused by every node.
-**What comes back.** A claim made in sight of another that didn't stand there doesn't
-give way to it later. Whatever has the other count or stand again (a vouch that
-brings its user back with what it signed meanwhile, a limit raised, a rule that lets
-its user again), the other gives way to it, for good. One thing brings an earlier
-claim back over a later one: the earlier was released, or left out by a cut, with a
-key that is then cut off from before. It is as if it had never been down: the later
-one gives way, and nobody having seen the earlier one down counts against it;
-unless the later is final (below). That is what a user has against a thief who
-released its names. The registry shows such a later claim as held while that
-release stands.
+**In sight of a claim that didn't stand.** A claim is taken where it was committed.
+The registry asks again, among all the changes a node holds, whether the other stood
+where the claim was signed: in the history of what the claim says its signer saw,
+with the decisions there, and with every witness that has the other count though
+that history lacks it (an unvouch reaches only as far as its signer's nodes and the
+roots' hadn't seen: Unvouching). If it stood, the claim gives way, as if it had been
+refused. If it didn't, the other gives way, for good: whatever has it count or stand
+again later (a vouch that brings its user back with what it signed meanwhile, a
+limit raised, a rule that lets its user again) doesn't bring it back over the claim.
+
+One thing does bring an earlier claim back over a later one: it was down only by a
+release, or a cut, that a cut has taken back since, and a root's node had seen it
+hold the name before it went down. It is then read as never down, and the later one
+gives way, unless it is final (below). That is what a user has against a thief who
+released its names; a claim that was cut off before anyone saw it hold, to wait for
+someone to claim the name, comes back over nothing. The registry shows such a later
+claim as held while a release, or a cut, stands.
A claim says nothing else. What the name is for is in the namespace: a host's entry
names its addresses and names, and they count while its user holds them.
@@ -549,16 +577,23 @@ tell these apart, and both claims are valid as their writers saw the document, s
every node holds both. What decides is who can be shown to have seen what. The
witnesses for a claim are its **side**: the nodes of its user and of the roots.
-* A claim is **late** against another if a change committed by a node of its side
- (one carrying for its user or for a root when it committed it) has the other in
- its history, standing there, while the claim itself wasn't there yet, or didn't
- stand there: the claimant's side had seen the other hold the name while the claim
- didn't. Whether a claim stood there is read from that history, less what a cut
- has taken back since.
-* Of the claims of a name that stand, those remain that are late against no other
- and give way to none. If one remains, its user holds the name, or has it wait
- while it is out. If none or several do, the name is **contested**: nobody holds
- it, until releases leave one, or the voters say whose it is (Decisions).
+* Of two claims neither of which was signed in sight of the other, one is **late**
+ against the other if a change committed by a node of its side (one carrying for
+ its user or for a root when it committed it) has the other in its history,
+ standing there, while the claim itself wasn't there yet, or didn't stand there:
+ the claimant's side had seen the other hold the name while the claim didn't.
+ Whether a claim stood there is read from that history; one that was down there
+ only by a release or a cut that a cut took back since is read as standing. Where
+ one was signed in sight of the other, sight decides alone (Claims).
+* A claim that is late against another, and not the other against it, is late for
+ good: it doesn't stand, and its user claims anew. So nobody waits in line for a
+ name with a claim that says it saw nothing: when the holder releases it, is gone,
+ or the voters free it, whoever comes first then has it. Two claims that are each
+ late against the other both stand.
+* Of the claims of a name that stand, those remain that give way to none. If one
+ remains, its user holds the name, or has it wait while it is out. If none or
+ several do, the name is **contested**: nobody holds it, until releases leave one,
+ or the voters say whose it is (Decisions).
Being late is read from the changes alone, so every node finds the same. It goes
away only with its witness: where the node that committed the change is stopped with
@@ -600,12 +635,19 @@ What this gives:
with a witness of its own. It ends as a claim does (released, its user gone, by
the voters), and it doesn't count where the key that signed it is cut off from
before it. Final takes no root: a claim nobody contested for that long is final
- though no root ever saw it. Two claims that each became final out of the other's
- sight, on two sides of a partition, are contested.
+ though no root ever saw it. A final claim gives way to none and is late against
+ none, but for another final one: two final claims of one name contest each other,
+ however they came to be.
+* **A name a root keeps contested** never becomes final by time: final takes holding
+ the name. The voters say whose it is (Decisions), name by name; or they end all of
+ that root's contests at once, by giving its first keys to someone who stops its
+ nodes with a cut from before them.
-So a name is its claimant's against anyone but the roots within a minute, and
-against the roots too within `final`: that long a root can still contest it, in the
-open, and a root that does is banned and left out at the next remake.
+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 banned, and left out at the next remake.
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
@@ -633,6 +675,10 @@ it is doesn't depend on who asks or when: a change's history is fixed by its has
change's history holds): rotating, not rewriting. No key retires one beside or above
it, so a stolen device key can't cut off the keys above it, nor undo what it signed
before.
+* **What a cut keeps, it names.** Beside the cut, a `retire` lists by digest what
+ the key signed within it since the epoch's root change, and every node checks the
+ list where the statement is taken, as it checks a number. So what a retirement
+ keeps holds also where the changes its cut names aren't there: after a remake.
* **A node that stops carrying** is named with a cut the same way, by the key that
named it or one above: what it committed outside the cut is nobody's, as a witness
or as a carrier.
@@ -672,7 +718,9 @@ A user may state that another doesn't count for it, from a cut on: `ban`, which
committed outside the cut is left out, as a holder and as a witness. Bans are taken
in the order they were made; of two made out of each other's sight, the one by the
user with the shorter line to a root first, then by digest; and none by a user that
-a ban taken before leaves out.
+a ban taken before leaves out. A node that follows several users (the roots, for
+files a whole network reads) takes a ban only where most of those it follows state
+it: else one of them, banning the others first, would decide alone what all read.
A ban changes what a node reads and writes out, never what it takes or refuses: every
node still holds every valid change, so banning splits nothing. It is what a party
@@ -695,42 +743,43 @@ 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 says who, all users
-(recommended) or those of a list. All users are those there when the remake is
-proposed: the users with keys that count where the proposal was signed, and still
-do at the base. So who votes is decided by those who vote, with each remake; a user
-brought in later, while the votes run too, votes once a remake names it; and a
-swarm that one user started is that one's to decide until its first remake. A
-voter votes while it isn't gone, whether it is in or out: who is in is its
-vouchers' word, who votes is the remake's.
+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.
-What to weigh in it:
+What to weigh in a list:
* Every voter named counts toward what a decision takes, whether it takes part or
- not, in or out: 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.
-* So a swarm remakes while two thirds of its voters still take part, and names those
- who do. Past that, those left go apart, naming who votes among them (Going
- apart).
+ 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.
+* 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.
* What is seen for long takes a third of the voters each with a node of their own.
-* All users is whoever brought users in: a user that created sixteen has seventeen
- votes in the next epoch.
+* Whoever brought users in brought voters in, where the list has them: a user that
+ created sixteen is seventeen of it.
-The list is fixed with the proposal, so the voters see it before they vote for it
-(`GET /registry/decisions`), and name 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).
+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).
**How.**
-1. A voter **proposes**: a statement naming its matter (what it is about: one number,
- one user's first keys, one name) and what is to hold. The proposals of a matter are
- numbered: each has, and states, the number after the highest of its matter that it
- was signed in sight of. Any number of proposals are open at a time, on one matter
- too; `limits.proposals` of one voter's at most. A proposal is open until it is
- decided, its proposer releases it, or one of its matter with a higher number is
- decided.
+1. A voter **proposes**: a statement naming its matter and what is to hold. A matter
+ is one thing that can be one way only: one number, the rest of the policy, one
+ user's first keys, one name. The proposals of a matter are numbered: each has, and
+ states, the number after the highest of its matter that it was signed in sight
+ of. Any number of proposals are open at a time, on one matter too;
+ `limits.proposals` of one voter's at most. A proposal is open until it is decided,
+ its proposer releases it, or one of its matter with a higher number is decided.
2. Voters **vote** for it: each a statement signed by the user, saying when the vote
runs out, `window` from signing unless the user says sooner; a node counts no
vote for longer than `window` from when it first held it. A voter has one vote
@@ -740,32 +789,36 @@ before out of reach (below).
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 no proposal with a lower
- number than one 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 for each voter that is out whose vote
- its history holds (its own nodes commit nothing); a voter counts once, however
- many records count for it.
+ `_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.
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, the fraction as it holds there. That is read from the document, the same
- by every node, and never goes away while the epoch lasts.
+ the voters. Who carried for whom and what the fraction was are read where each
+ record was written, from its history. That is read from the document, the same by
+ every node, and never goes away while the epoch lasts.
**At once.** Nothing waits for a vote's days to end. With the votes there, the nodes
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**; of two with the
-same number, made out of each other's sight, the one with the lower digest. A
+decisions of a matter, the one with the highest number **holds**. 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.
**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
chooses the day: a record can be made to look as old as its maker likes, so no rule
-ends its time. Two things bound it. A node takes up nothing lower than it took up,
+ends its time. Two things bound it. A node takes up only what is higher than it took up,
so what is decided late changes what holds only where no proposal with a higher
number was decided since. And it shows: `GET /registry/decisions` has what was taken
up, by whose nodes, and how many it is short of. The voters end it by deciding a
@@ -790,7 +843,7 @@ held while they run by no honest node, so nothing takes their proposal up but it
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 it out of reach.
+voters decide a later one. A remake puts everything before its base out of reach.
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
@@ -809,21 +862,21 @@ clocks. A window of days bears clocks that are minutes apart.
under another name, so that it has a voice and the voters know whom they give the
name back to. Decided, it signs under its name as before, with its names, its
lines and those it brought in, and releases the other name.
-* **The names of a user that is out**, while they wait. The proposal names the user
- and, for each name it deals with, that it is free or who is to have it. A name
+* **A name of a user that is out**, while it waits: each name a matter. The proposal
+ names the user and the name, and that it is free or who is to have it. A name
freed is anyone's to claim from the decision on; the user's own name freed, the
user is gone. A name given is the user's claim made over: the user the decision
names holds it where that claim was, releases it like its own, and it doesn't
count toward its limit. A user that is vouched for again has back what no decision
- dealt with. What another claimed in sight of a claim that didn't stand (the user
- was gone meanwhile) stays the other's, as with anything that comes back.
+ dealt with. What another claimed in sight of the claim while it didn't stand (the
+ user was gone meanwhile) stays the other's, as with anything that comes back.
* **Whose a contested name is.** The proposal names one of its claims: decided, that
claim is final.
* **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's remakes are one matter.
+ (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
@@ -836,19 +889,29 @@ away and names who votes and who the roots are in the next epoch, and does nothi
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** names the voters of the next epoch (all users, or those of a
- list) and its roots (those there are, unless it names others). It is voted on
- like anything else.
-* **The base.** The remake's **coordinator** is the node of the proposer that takes
- it up first. It names the base in its record: the base is that record's history.
-* **Taking it up.** A voter's node takes a remake up with its base: once the votes
- are there, and the base holds all that the node held `baseAge` before the base
- reached it, so that a remake can't leave out what the swarm has. It builds the
- snapshot first, and records the ID of the epoch it got. The remake is decided
- for an ID: by records that name that one (Continuum changing under a swarm). One
- base a proposal, the first to reach the node; a voter whose nodes recorded two
- IDs counts for neither. A coordinator that names two bases, or none, may get no
- remake: it is proposed again, under the next number.
+* **The proposal** lists the voters of the next epoch by their IDs, names its roots
+ (those there are, unless it names others), and names the node of its proposer
+ that is to be its **coordinator**. It is voted on like anything else.
+* **The base.** Once the coordinator holds the votes it names the base in its
+ record: the base is that record's history.
+* **One base an epoch.** A voter's node takes a remake up with its base: once the
+ votes are there, and the base holds all that the node held `baseAge` before the base
+ reached it (the remake's own records aside), so that a remake can't leave out what
+ the swarm has. It builds the snapshot first, and records the ID of the epoch it got
+ (Continuum changing under a swarm). Having recorded one, it records no other for its
+ epoch, ever: not another base, nor other voters or roots. A later proposal for the
+ epoch's remake is taken up only where it names that base, those voters and those
+ roots, however old the base is by then. So an epoch's remakes aren't numbered
+ against each other, and of two with two bases both are decided only where the nodes
+ of a third of the voters recorded both, which no honest node does.
+* **A remake that hangs**, short of records, is tried again by voting for the same
+ base again; once the nodes of a third of the voters took a remake up, the epoch's
+ remake is that one or none. A record that comes late decides what the swarm was
+ waiting for, or what nothing else could be decided against. No node, having
+ switched, moves again by itself: where it finds another remake of the epoch it
+ left decided, it shows it, and its operator says.
+* **A coordinator that names two bases, or none**, may get no remake for the epoch
+ where the nodes split over the two. Those left go apart (Going apart).
* **Every node builds the snapshot** itself once the remake is decided, from the base
as it holds it, and switches after the switch delay, as today. The snapshot holds
the registry as it resolves at the base:
@@ -862,61 +925,63 @@ which every node works out itself.
which, which is settled, which final;
* the values in the namespaces that count, as the envelopes they are;
* the bans that stand, and what is uncovered and not dropped;
+ * the proposals that are open, with their votes;
* the member entries of the nodes that carry for a user it holds, and the
epochs' metadata, as today;
* the digest of every statement the base holds, for this one epoch.
* **What it leaves out**: all history, and with it everything that is over or didn't
- count. A claim released, and its release. A key retired, a node stopped, an
- unvouch, each with its cut: what they left out is out for good. A user gone. A
- proposal, its votes and the nodes' records: what holds is in the policy and the
- registry. So after a remake the document's size goes by what stands (users, their
- keys and nodes, names held, values, members), and for one epoch by 32 bytes for
- each statement there was; not by what ever happened. Within an epoch nothing is
- removed: a release is a statement like any other, signed, and a document keeps
- its history. The remake is what deletes.
+ count. A claim released, and its release. A key retired, a node stopped, an unvouch,
+ each with its cut: what they left out is out for good. A user gone. A proposal that
+ is decided or closed, its votes and the nodes' records: what holds is in the policy
+ and the registry. So after a remake the document's size goes by what stands (users,
+ their keys and nodes, names held, values, members), and for one epoch by 32 bytes
+ for each statement there was; not by what ever happened. Within an epoch nothing is
+ 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 a statement among them is refused. The epoch after drops the list.
+ 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. It does so in its first changes of the new epoch, before it takes anything
- from a peer, and in the order it holds them: what is late against another, or
- gives way to it, in a later change than that other. 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. So what a node's changes witnessed in the old epoch its first
- changes witness again, and a claim that turns up later as signed in the epoch
- before is late against what a root's node carried over. Against a claim the
+ 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.
-* **A cut carried over** (with a `retire`, a stop, an `unvouch`, a ban) names changes
- of the epoch before, which the new one doesn't hold. It reaches as far as the
- snapshot: everything of its key, its node or its user that the snapshot doesn't
- hold is outside it. What was meant to stay is signed again.
+* **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.
* **Decisions after the base** aren't in the snapshot. Their proposals and votes are
carried over, and a node that held one decided takes it up again in the new
epoch, whether its votes still run or not: it is decided there once the nodes of
- two thirds of the voters switched. Where the remake changed the voters so that
- its votes are too few, it is proposed again.
+ two thirds of the voters switched. Until then the registry resolves without it,
+ and what is signed meanwhile with a key the decision cut off is outside that cut
+ 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.
-* **Two remakes of one epoch.** They are one matter: the one with the highest number
- holds. A node that holds a remake decided takes up no other; one that switched
- goes on syncing the epoch it left while it keeps it, and where it finds a remake
- decided there with a higher number, it moves to that one by itself: it builds the
- snapshot from that base and carries over what it holds of the epoch both came
- from. What was signed only in the epoch it leaves goes to the quarantine, for its
- user to sign again.
-* **A remake that hangs**, short of records, and is decided weeks later sends every
- node to a base that old. What was signed since comes along: every node carries
- over what it holds, in order, decisions among it. What it costs is the lengths that
- had begun, and whatever only a node witnessed that didn't come along. A swarm
- ends it as any proposal that hangs: by deciding another remake.
+* **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,
+ 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
off later from before; so for an unvouch. The days a vote takes are the time to cut
@@ -1098,10 +1163,13 @@ statement on its side.
A change is first of all one that Automerge itself writes, or it is refused before
Automerge sees it, in every swarm *(checked: `document::changes::Written`)*: its
bytes are the ones Automerge encodes for it; its first operation is numbered one
-after the highest of its dependencies; and every operation it names was made before
-it. Automerge 0.12 applies changes that are none of these, and then panics, or saves
-a document that doesn't load *(measured upstream)*. All three are read from the
-change and its history, as the rules are.
+after the highest of its dependencies; it is its actor's first, or builds on the
+one before; and every operation it names was made in its history and is what it is
+named as (the object written into, the element of that list, an operation at that
+place). Automerge 0.12 applies changes that are none of these, and then panics,
+saves a document that doesn't load, or holds another change than it was given
+*(measured upstream)*. All of it is asked of the change and its history, as the
+rules are.
A change is valid if, in the document at its dependencies:
@@ -1110,9 +1178,9 @@ A change is valid if, in the document at its dependencies:
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. A
- change that starts a writer is refused where its user's nodes have started
- `limits.writers` in its history.
+ 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.
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
@@ -1128,12 +1196,13 @@ A change is valid if, in the document at its dependencies:
there. 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 without keys. `key`,
- `node`, `vouch`, `ban`: not past their limits there; a `vouch` for a user that
- isn't gone there. `unvouch`: by the signer of what it takes back, or by a root for
- what is the seats'. `retire`, a node stopping: by a key above, or by the key itself
- as said under Cuts, the cut in the change's history. `release`: by the user of what
- it releases; of the user itself, with a first key.
+ there; or it is a root's, for a user the root change holds, that has no keys there.
+ `key`, `node`, `vouch`, `ban`: not past their limits there; a `vouch` for a user
+ that isn't gone there. `unvouch`: by the signer of what it takes back, or by a root
+ for what is the seats'. `retire`, a node stopping: by a key above, or by the key
+ itself as said under Cuts, the cut in the change's history, and its list what the
+ key signed within it. `release`: by the user of what it releases; of the user
+ itself, with a first key.
6. A `claim`: the kind is declared, the name is one of it, a rule lets the signer,
the signer isn't past the kind's limit there, and no claim of that name stands
there. One that doesn't count there doesn't stand there.
@@ -1141,10 +1210,10 @@ A change is valid if, in the document at its dependencies:
what is there (`prev`); nothing within one, nothing replacing what holds one. At
a place the policy no longer covers: only its user's envelope that puts nothing
there.
-8. `propose`, `vote`: by a voter that isn't gone there (a fork: proposed by any user
- that isn't); a proposal not past its user's limit there (a fork: the only one of
- its user that is open); a vote where the user has none on that matter that isn't
- released.
+8. `propose`, `vote`: by a voter, with a key the document has for it (a fork: proposed
+ by any user that isn't gone there); a proposal not past its user's limit there (a
+ fork: the only one of its user that is open); a vote where the user has none on
+ that matter that isn't released.
9. `_continuum/access`, the swarm ID, the epochs, and what the root change sets for
the swarm as a whole: never.
@@ -1175,49 +1244,53 @@ the steps before:
1. **Decisions.** Which proposals are decided, and which decision of each matter
holds (Decisions): the policy with its numbers, the first keys given, the names
- freed, given or said to be someone's. They are read from the records, which were
- judged against the votes where they were written, so nothing below changes them.
+ freed, given or said to be someone's. A record is read where it was written: who
+ carried for whom, and the fraction, are as its own history has them, so this goes
+ back along the history and ends, and nothing below changes it.
2. **Who counts, and where.** The roots count, by their seats; a user the root change
holds without a creator is in by the seats. A user counts at a statement if a
`create` or `vouch` for it counts whose signer counts there by a line that
doesn't pass through the user (so this ends), and the statement is within what
every `unvouch` of that one leaves; what is the seats' is taken back once every
root unvouched it. A statement counts if its user counts at it (a proposal and a
- vote: while their voter isn't gone); its key was the
- user's (added by statements that count, up to its creation, or given by a
- decision); it is within every cut set for that key (by a `retire` that counts, or
- a decision); a node carrying for the user committed it (any node, for what any
- node commits), within that node's cut if it has one; and it isn't past its limit
- (Users), by the limit that holds. A `retire`, a stop and an `unvouch` are never
- outside a cut they set themselves, nor left out with their carrier. Bans of
- followed users cut the same way. A user is **out** where no `create` or `vouch`
- for it counts any more. It is **gone** once seen out for `gone`, or where it
- released itself or a decision freed its name; and gone it stays, whatever is
- vouched or cut off after.
+ vote: always, for a voter); its key was the user's (added by statements that
+ count, up to its creation, or given by a decision); it is within every cut set
+ for that key (by a `retire` that counts, or a decision); a node carrying for the
+ user committed it (any node, for what any node commits), within that node's cut
+ if it has one; and it isn't past its limit (Users), by the limit that holds. A
+ `retire`, a stop and an `unvouch` are never outside a cut they set themselves,
+ nor left out with their carrier. Bans cut the same way, for those who follow
+ their signers. A user is **out** where no `create` or `vouch` for it counts any
+ more, or where it gave itself up. It is **gone** once seen out for `gone`, or
+ where a decision freed its name; and gone it stays, whatever is vouched or cut
+ off after.
3. **Users' names.** A creation stands while it counts, isn't released, its user isn't
gone, and a rule of the kind `user` lets its signer. Of the creations of a name
that stand: the one that remains (Two claims) has the name, or has it wait while
it is out.
4. **Names.** A claim stands the same way, where a rule of the policy that holds lets
- its user: anyone vouched for where the rule says `"*"`, a root where it says
+ its user: anyone who isn't gone where the rule says `"*"`, a root where it says
`"{root}"`, else the user that has the name the rule gives; and a name the
- voters gave stands as its decision says while the rule says `"{voters}"`. Among
- the claims of a name that stand:
- * every other gives way to a final one, unless it is final too;
- * of two, one signed in sight of the other: the other gives way (it didn't stand
- there, or the one in sight would have been refused). But where the other was
- down only by a release or a cut that a cut has taken back, the one signed in
- sight gives way, unless it is final;
- * what was carried over gives way to what the snapshot held;
- * and one is late against another as said under Two claims.
+ voters gave stands as its decision says while the rule says `"{voters}"`. A claim
+ that is late against another, and not the other against it, doesn't stand. For
+ each two claims of a name that stand, one question is asked, the first that fits:
+ * both final: neither gives way, and they contest each other;
+ * one final: the other gives way;
+ * one carried over, the other held by the snapshot: the one carried over gives
+ way;
+ * one signed in sight of the other: it gives way if the other stood where it was
+ signed, or is read as never down (Claims); else the other gives way;
+ * neither in sight of the other: each stands, late against the other or not.
- Those that give way to none and are late against none remain: one, and its user
- holds the name, or has it wait while it is out; else the name is contested. A
- kept name is held by the user that has the user name.
+ Those that give way to none remain: one, and its user holds the name, or has it
+ 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), 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
+ 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
+ replaces, directly or along `prev`, is left out; of the rest, those that count,
+ in Automerge's order. Where the one there doesn't count, the last that does, back
+ along `prev` (read in the document at the dependencies of the change that
replaced it).
A node keeps the resolved registry as it goes (a statement changes it around its own
@@ -1227,10 +1300,11 @@ name), and answers from it:
created it and who vouches for it; or that it is contested, between whom; or out,
since where, and how long its names still wait; or gone.
* `GET /registry/claims/<kind>/<name>`: the holder, and whether the claim is settled,
- and final; held "while a release stands" where it was made after one and isn't
- final; or contested, between whom, with the changes that make each claim late and
- whose nodes committed them. A user whose nodes showed both orders of two claims
- is marked, a root too: it lied, or its nodes were apart.
+ and final; held "while a release, or a cut, stands" where it was made in sight of a
+ claim that one could bring back, and isn't final; or contested, between whom, with
+ the changes that make each claim late and whose nodes committed them. A user whose
+ nodes showed both orders of two claims is marked, a root too: it lied, or its nodes
+ were apart.
* `GET /registry/decisions`: the roots, the voters, the policy and its numbers; what
is proposed, with its number, who voted, until when, whose nodes took it up, how
many it is short of, and which nodes would refuse it; what is decided, which
@@ -1250,8 +1324,8 @@ same holder, or contested. The users see it and one releases; nobody drops anyth
**Two epochs**, after a fork or a decision some refuse, are apart for good: each node
is where its operator put it (by word or by bounds), and moves to the other side by
being told to (it builds that side's snapshot from the base it holds, and carries
-over what it holds). After two remakes of one epoch, the nodes end up in the one
-that holds by themselves (Remakes).
+over what it holds). The same where two remakes of one epoch were both decided,
+which takes a third of the voters' nodes recording both (Remakes).
**Changes one side refuses** are a partition nobody chose. A node is cut off from the
others when it holds a change they refuse, as everything it writes after builds on
@@ -1367,6 +1441,10 @@ the document. What must hold for this, and doesn't everywhere today:
aren't, and then holds another change than the one it was given: under the hash
received it gives back a change with another hash, and its save doesn't load
*(measured upstream)*. Screening refuses those before Automerge sees them;
+* a register made by two changes at once holding what both put there. Two claims of
+ a name nobody claimed yet each make its register, and after a remake every node
+ makes the same registers; reads show maps made at one key as one *(docs)*, and
+ judging and resolving must read them so;
* one change per actor and number. A forked actor breaks "hold the same changes"
until one side drops. Automerge names a change by actor and number where
Kleppmann's construction needs the hash.
@@ -1462,7 +1540,9 @@ 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.
+ they vote for it. What a node holds beyond the base it carries over itself. 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,
and follows a fork by its operator's word alone.
* *With other fractions.* Write d for `fractions.decide` and s for `fractions.seen`.
@@ -1591,6 +1671,23 @@ back, so the point only moves forward as more of them show up.
upstream)*. A hundred nodes stamping daily write 10^4 changes in a hundred days.
So a fork of an actor is proven and named, and not prevented, for as long as
Automerge's clocks grow with its actors.
+* **An epoch's remakes numbered like any matter**, the highest number holding: a
+ remake that hangs would be ended by deciding another. But the one that hangs can
+ be the higher, and be decided after the swarm switched to the other: then it
+ undoes the epoch the swarm is in, on a day one voter chooses. One base an epoch,
+ recorded once by each node, leaves nothing to undo.
+* **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.
+* **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
+ refused, and an honest user whose nodes crash too often would write nothing until
+ a remake. Put off by each node, nothing valid is refused, and what is bounded is
+ how fast.
+* **Any node's record counting for a voter that is out**: one node, holding old
+ votes, would decide for all of them. Its own nodes record, and commit nothing
+ else.
* **A document per user**, each written by one party, a claim counted across them (as
in Secure Scuttlebutt's feeds). A fork of an actor then spoils only the forker's
own document, not the swarm, which is the one thing this design can't give. It
@@ -1646,14 +1743,17 @@ what its signer saw; a node is given its root, syncs under no policy it doesn't
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, 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 too.
-[`trust.md`](trust.md), [`access.md`](access.md), [`remakes.md`](remakes.md) and the
-glossary get the federated case: party, statement, line, root, voter, claim, cut,
-late, contested, settled, final, out, gone, uncovered, seen for, taking a proposal up,
-a decision that holds, bounds, and a ban of a user beside a ban of a node.
+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
+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
+too. [`trust.md`](trust.md), [`access.md`](access.md), [`remakes.md`](remakes.md) and
+the glossary get the federated case: party, statement, in sight of, line, root, the
+seats', voter, claim, cut, late, giving way, contested, settled, final, out, gone,
+uncovered, seen for, taking a proposal up, a decision that holds, what hangs, carried
+over, refusing a decision, bounds, the numbers, and a ban of a user beside a ban of a
+node.
## Continuum changing under a swarm
@@ -1727,152 +1827,161 @@ Statements and users:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
| 1 | Signs a statement with a key that isn't the user's | Refuse | 3 | unit, statements: `a_statement_needs_its_users_key` |
-| 2 | Puts another user's statement into a change of its own node | Refuse, its node not carrying for the signer; but for what a decision is made of, and what is carried over a remake | 3 | unit: `only_a_users_node_carries_it` |
+| 2 | Puts another user's statement into a change of its own node | Refuse, its node not carrying for the signer; but for what a decision is made of, what is carried over a remake, and a `node` statement, which the node it names commits | 3 | unit: `only_a_users_node_carries_it` |
| 3 | Replaces or deletes a statement, or what holds the register | Refuse | 2, 3 | unit: `a_register_only_grows` |
| 4 | Offers a statement again; or an envelope signed for another swarm, epoch, path or user ID | Nothing where it is there under its digest; refuse elsewhere | 3 | unit, exists for swarm and path: `what_an_envelope_must_be`; `signed_for_its_user_id_and_epoch` |
| 5 | Commits a statement a second time, in a change with other dependencies, to move it | A statement is where it says its signer was (`seen`), whoever carries it and how often: nothing moves | 2 | unit: `a_statement_carried_twice` |
| 6 | Creates a user listing a victim's public key beside its own | The victim's envelopes name the victim's ID: they count for no other | 3 | unit: `a_key_in_two_creations` |
-| 7 | Users vouch for each other in a ring away from the roots; a user vouches for its creator | None is vouched for by it | 3 | unit, resolve: `no_line_no_user` |
-| 8 | Creates a name in sight of its creation | Refuse | 4 | unit: `a_name_created_once` |
-| 9 | Creates a name another has, saying it saw nothing of it | Hold both; late once a root saw the first. Before: contested, or the first is late where a root's node got the other first | 4, 5 | unit: `a_backdated_creation_is_late` |
-| 10 | Gets a user's name contested to free its names | Its claims stand without the name | 5 | unit: `claims_stand_without_the_name` |
-| 11 | Creates many users, each claiming many names (sybils); creates them out of each other's sight to pass the limit | Refuse past the limits in sight; out of sight, those past them don't count. A limit bounds how many each user brings in itself, not how many come in below it: each shows below its creator, for all to see, to ban, and to go with it when it is unvouched | 6 | unit: `limits_on_creating`, `past_a_limit_out_of_sight` |
-| 12 | Adds keys, nodes or statements without end; signs and gives up without end (vouch and unvouch, claim and release, key and retire) | Refuse past the limits. What is given up counts toward none: it is taken no faster than a budget per party, and a remake leaves it out | 6 | unit: `limits_on_a_register`; sim: `a_party_past_its_budget_waits` |
-| 13 | Signs more than its limit out of each other's sight; another claims a name that so doesn't count; then gives the earlier ones up | What is past a limit stays past it, whatever is given up later; and the claim made in sight of it doesn't give way | 5 | unit: `past_a_limit_for_good` |
-| 14 | Names another party's node as one that carries for it; offers that node a token of its own | A node carries only once it committed the statement naming it; a token is taken from nodes the operator named | 3 | unit: `a_node_carries_by_its_own_word`, `a_token_of_ones_party` |
+| 7 | A second root signs a `create`, with keys of its own, for a user the root change holds | Refuse where the user has keys. Of two signed out of each other's sight neither gives keys, until one is released | 3 | unit: `first_keys_once` |
+| 8 | Users vouch for each other in a ring away from the roots; a user vouches for its creator | None is vouched for by it | 3 | unit, resolve: `no_line_no_user` |
+| 9 | Creates a name in sight of its creation | Refuse | 4 | unit: `a_name_created_once` |
+| 10 | Creates a name another has, saying it saw nothing of it | Hold both; late once a root saw the first. Before: contested, or the first is late where a root's node got the other first | 4, 5 | unit: `a_backdated_creation_is_late` |
+| 11 | Gets a user's name contested to free its names | Its claims stand without the name | 5 | unit: `claims_stand_without_the_name` |
+| 12 | Creates many users, each claiming many names (sybils); creates them out of each other's sight to pass the limit | Refuse past the limits in sight; out of sight, those past them don't count. A limit bounds how many each user brings in itself, not how many come in below it: each shows below its creator, for all to see, to ban, and to go with it when it is unvouched | 6 | unit: `limits_on_creating`, `past_a_limit_out_of_sight` |
+| 13 | Adds keys, nodes or statements without end; signs and gives up without end (vouch and unvouch, claim and release, key and retire) | Refuse past the limits. What is given up counts toward none: it is taken no faster than a budget per party, and a remake leaves it out | 6 | unit: `limits_on_a_register`; sim: `a_party_past_its_budget_waits` |
+| 14 | Signs more than its limit out of each other's sight; another claims a name that so doesn't count; then gives the earlier ones up | What comes to count later than it was signed gives way to what was claimed in sight of it meanwhile | 5 | unit: `counting_late_gives_way` |
+| 15 | With a stolen key, signs statements that come before its user's own (keys, creations, claims), to push those past their limits | Until the key is cut off they do. What a cut leaves out comes before nothing: the user's own count again, and what was claimed in sight of them meanwhile gives way where a root's node had seen them hold | 3 | unit: `cut_off_comes_before_nothing` |
+| 16 | Names another party's node as one that carries for it; offers that node a token of its own | A node carries only once it committed the statement naming it; a token is taken from nodes the operator named | 3 | unit: `a_node_carries_by_its_own_word`, `a_token_of_ones_party` |
Unvouching:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 15 | 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` |
-| 16 | The roots unvouch the voters, to keep them from deciding | A voter votes while it isn't gone, in or out, and a record of any node that holds its vote counts for it: who votes is the remake's word, not its vouchers' | 7 | unit: `a_voter_that_is_out_votes` |
-| 17 | 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` |
-| 18 | 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` |
-| 19 | 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` |
-| 20 | An unvouched user's nodes keep sending | Refused as peers; nothing taken from them | 6 | sim: `nothing_from_an_unvouched_node` |
-| 21 | Claims a name of a user that is out, or creates its user name | Refuse: the names wait until the user is gone, or a decision frees them or gives them away | 5 | unit: `names_wait_while_out` |
-| 22 | Has a user unvouched, then stamps its nodes `gone` apart at once, to free the names; carries for many voters to be many | Gone takes a third of the voters, each with a node, and a node counts for one | 5 | unit: `gone_by_a_third_of_the_voters`, `a_node_is_seen_for_one_voter` |
-| 23 | Vouches for a gone user saying it saw nothing of that, over a name claimed since | Gone stays: no vouch brings it back | 4 | unit: `gone_stays_gone` |
-| 24 | Out, signs a claim that doesn't count; another claims the name in sight of it; a vouch brings the user back | It is back with what it signed, but the claim made in sight of one that didn't count doesn't give way to it; nor does a settled one that never saw it | 5 | unit: `back_but_not_over_a_later_claim` |
+| 17 | 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` |
+| 18 | 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` |
+| 19 | 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` |
+| 20 | 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` |
+| 21 | 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` |
+| 22 | An unvouched user's nodes keep sending | Refused as peers; nothing taken from them | 6 | sim: `nothing_from_an_unvouched_node` |
+| 23 | Claims a name of a user that is out, or creates its user name | Refuse: the names wait until the user is gone, or a decision frees them or gives them away | 5 | unit: `names_wait_while_out` |
+| 24 | Has a user unvouched, then stamps its nodes `gone` apart at once, to free the names; carries for many voters to be many | Gone takes a third of the voters, each with a node, and a node counts for one | 5 | unit: `gone_by_a_third_of_the_voters`, `a_node_is_seen_for_one_voter` |
+| 25 | Shows a stamp later that lies, by its time, between two that counted, with the thing not so there | Between goes by the stamps' histories, not their times: it lies between nothing, and gone, final and dropped stay | 5 | unit: `between_two_stamps` |
+| 26 | Vouches for a gone user saying it saw nothing of that, over a name claimed since | Gone stays: no vouch brings it back | 4 | unit: `gone_stays_gone` |
+| 27 | Out, signs a claim that doesn't count; another claims the name in sight of it; a vouch brings the user back | It is back with what it signed, but the claim made in sight of one that didn't count doesn't give way to it; nor does a settled one that never saw it | 5 | unit: `back_but_not_over_a_later_claim` |
Namespaces:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 25 | Writes into another's namespace, signed by itself | Refuse, and the node as a whole | 3 | unit: `a_namespace_is_its_users`; sim, as `a_member_writing_against_the_rules` today |
-| 26 | Writes plain values, or protocol data but its own member entry | Refuse | 3 | unit: `nothing_plain` |
-| 27 | Puts an old envelope back | Refuse: it doesn't replace what is there | 3 | unit, exists: `what_an_envelope_must_be` |
-| 28 | A user with a late creation of a name writes in the namespace | Refuse where its change's history shows it lost the name; else hold it and leave it out | 3 | unit: `a_user_that_lost_its_name` |
+| 28 | Writes into another's namespace, signed by itself | Refuse, and the node as a whole | 3 | unit: `a_namespace_is_its_users`; sim, as `a_member_writing_against_the_rules` today |
+| 29 | Writes plain values, or protocol data but its own member entry | Refuse | 3 | unit: `nothing_plain` |
+| 30 | Puts an old envelope back | Refuse: it doesn't replace what is there | 3 | unit, exists: `what_an_envelope_must_be` |
+| 31 | A user with a late creation of a name writes in the namespace | Refuse where its change's history shows it lost the name; else hold it and leave it out | 3 | unit: `a_user_that_lost_its_name` |
Claims:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 29 | Claims a held name in sight of the claim | Refuse | 4 | unit, claims: `first_come_first_served` |
-| 30 | Claims a settled name saying it saw nothing of the claim, long after | Hold both; it is late, the holder holds | 5 | unit: `a_backdated_claim_is_late`; sim: `a_backdated_claim_loses` |
-| 31 | Two honest users claim on two sides of a partition | Hold both; every node finds the same: one holder, or contested; a release leaves one | 2, 4 | sim: `a_partition_heals_to_one_answer`; unit: `a_release_ends_a_contest` |
-| 32 | Claims `x.tv.r` as another; claims a top-level domain as another than a root; claims `wiki.r`, which the rules leave to the voters | Refuse: the kind's rule. A kept name needs no claim; a claim by a user that doesn't have the name its rule gives doesn't count | 4 | unit: `a_kinds_rules`, `a_kept_name`, `a_rule_goes_by_who_has_the_name` |
-| 33 | Claims past its limit, in sight or out of sight of its other claims | Refuse in sight; out of sight, those past the limit don't count | 4, 6 | unit: `a_limit_in_sight`, `past_a_limit_out_of_sight` |
-| 34 | Claims `TV.r` beside `tv.r`, or `10.243.foo.bar`; claims one address in two spellings | Refuse what has characters the kind doesn't name. Else a name is compared as written: the application claims one spelling and reads no other | 4 | unit: `a_kinds_characters`; argued (Claims) |
-| 35 | A root says it saw a rival first, after the claim is settled | The name is contested; the registry names the changes and the root, and marks it if it showed both orders. Once the claim is final: nothing | not promised; 5 once final | unit: `a_root_contests`; sim: `both_orders_show` |
-| 36 | Hands an honest node of a root or of the claimant, back from a day off, a rival before the claim | A node that comes back catches up with the peers it keeps before it writes. Where it wrote all the same: contested, until one releases or the voters say. Once the claim is final: nothing | not promised; 5 once final | sim: `a_node_handed_the_rival_first` |
-| 37 | Two claims made at once reach two roots' nodes in two orders | Each is late against the other: contested, and one releases | 4 | unit: `roots_that_saw_two_orders` |
-| 38 | Keeps silent while no root's node is up, then claims saying it saw nothing | Before the claim is settled: contested, or whichever reaches a root's node first holds. After: late. Final: it gives way | 5 | unit: `silence_before_settling` |
-| 39 | Releases a claim with a stolen key, an accomplice claims | Once the key is cut off the release doesn't count: the accomplice's claim, made in sight of the first, gives way, unless it is final by then | 3, 4 | unit: `a_release_cut_off` |
-| 40 | Every root that saw a claim stops its node with a cut from before, and a rival is handed in | A final claim holds. One that isn't is as before the roots saw it: contested, or late | 5 once final; not promised before | unit: `final_against_the_roots` |
-| 41 | Stamps its nodes `final` apart at once, to make a claim final that doesn't hold, or holds only as it sees it | Final takes a third of the voters, each having held the claim as the holder at both stamps and between | 5 | unit: `final_by_a_third_of_the_voters` |
-| 42 | Keeps honest voters' nodes apart for longer than `final`, a claim of one name on each side | Both are final: contested, until one releases or the voters say | not promised | sim: `two_finals` |
+| 32 | Claims a held name in sight of the claim | Refuse | 4 | unit, claims: `first_come_first_served` |
+| 33 | Claims a settled name saying it saw nothing of the claim, long after | Hold both; it is late, the holder holds | 5 | unit: `a_backdated_claim_is_late`; sim: `a_backdated_claim_loses` |
+| 34 | Two honest users claim on two sides of a partition | Hold both; every node finds the same: one holder, or contested; a release leaves one | 2, 4 | sim: `a_partition_heals_to_one_answer`; unit: `a_release_ends_a_contest` |
+| 35 | Claims `x.tv.r` as another; claims a top-level domain as another than a root; claims `wiki.r`, which the rules leave to the voters | Refuse: the kind's rule. A kept name needs no claim; a claim by a user that doesn't have the name its rule gives doesn't count | 4 | unit: `a_kinds_rules`, `a_kept_name`, `a_rule_goes_by_who_has_the_name` |
+| 36 | Claims past its limit, in sight or out of sight of its other claims | Refuse in sight; out of sight, those past the limit don't count | 4, 6 | unit: `a_limit_in_sight`, `past_a_limit_out_of_sight` |
+| 37 | Claims `TV.r` beside `tv.r`, or `10.243.foo.bar`; claims one address in two spellings | Refuse what has characters the kind doesn't name. Else a name is compared as written: the application claims one spelling and reads no other | 4 | unit: `a_kinds_characters`; argued (Claims) |
+| 38 | A root says it saw a rival first, after the claim is settled | The name is contested; the registry names the changes and the root, and marks it if it showed both orders. Once the claim is final: nothing | not promised; 5 once final | unit: `a_root_contests`; sim: `both_orders_show` |
+| 39 | Hands an honest node of a root or of the claimant, back from a day off, a rival before the claim | A node that comes back catches up with the peers it keeps before it writes. Where it wrote all the same: contested, until one releases or the voters say. Once the claim is final: nothing | not promised; 5 once final | sim: `a_node_handed_the_rival_first` |
+| 40 | Two claims made at once reach two roots' nodes in two orders | Each is late against the other: contested, and one releases | 4 | unit: `roots_that_saw_two_orders` |
+| 41 | Keeps silent while no root's node is up, then claims saying it saw nothing | Before the claim is settled: contested, or whichever reaches a root's node first holds. After: late. Final: it gives way | 5 | unit: `silence_before_settling` |
+| 42 | Releases a claim with a stolen key, an accomplice claims | Once the key is cut off the release doesn't count: the accomplice's claim, made in sight of the first, gives way, unless it is final by then | 3, 4 | unit: `a_release_cut_off` |
+| 43 | Signs a claim and cuts its key off at once, so that the name shows free; another claims it; then cuts off the key that cut | It comes back over nothing: no root's node saw it hold the name before it was down | 5 | unit: `a_planted_claim_comes_back_over_nothing` |
+| 44 | Signs claims of held names that say they saw nothing, to have each the moment its holder releases it, is gone, or the voters free it | A claim late against another that isn't late against it is late for good: it doesn't stand, and whoever comes first then has the name | 5 | unit: `late_for_good` |
+| 45 | A limit is lowered and raised again, or a policy uncovers and covers again; someone claims in between a name that so showed free | The claim made in sight of one that didn't stand keeps the name: the other gives way, though a root's node had seen it first | 5 | unit: `sight_decides_alone` |
+| 46 | Every root that saw a claim stops its node with a cut from before, and a rival is handed in | A final claim holds. One that isn't is as before the roots saw it: contested, or late | 5 once final; not promised before | unit: `final_against_the_roots` |
+| 47 | Stamps its nodes `final` apart at once, to make a claim final that doesn't hold, or holds only as it sees it | Final takes a third of the voters, each having held the claim as the holder at both stamps and between | 5 | unit: `final_by_a_third_of_the_voters` |
+| 48 | Keeps honest voters' nodes apart for longer than `final`, a claim of one name on each side | Both are final: contested, until one releases or the voters say | not promised | sim: `two_finals` |
Keys:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 43 | Steals a device key and signs with it | Take it until a key above cuts it off, then leave out what is outside the cut; a value it replaced is read again | 3 | unit: `a_retired_key_counts_within_its_cut`, `the_value_before_counts_again`; sim: `a_stolen_key_cut_off` |
-| 44 | Signs with a retired key, saying it saw nothing of the retiring | Hold it (valid as written), leave it out | 3 | unit: `backdated_past_a_cut` |
-| 45 | With a stolen device key, retires the keys above or beside it | Refuse | 3 | unit: `no_key_retires_one_above` |
-| 46 | With a stolen device key, retires that key from long ago, to undo what its user signed | Refuse: a key retires itself from where it stands | 3 | unit: `a_key_retires_itself_forward` |
-| 47 | A key retires itself; a retirement is carried by a node that only the retired key named; a node commits its own stop | Each counts: a cut never leaves out its own statement, nor the node that carried it | 2 | unit: `a_cut_never_reaches_itself` |
-| 48 | With a stolen key, retires the keys below it, stops nodes, unvouches, releases names | A key above cuts it off from before: all of it is taken back, but what became final on it | 3 | unit: `a_cut_takes_back_what_the_key_cut` |
-| 49 | With a device key, releases the user itself | Refuse: it takes a first key | 3 | unit: `giving_up_takes_a_first_key` |
-| 50 | Steals a user's first key | The name is the thief's too, until a decision gives the user first keys anew, with a cut for the stolen one | 7 | unit: `first_keys_by_a_decision` |
-| 51 | Cuts its own key off early to take back a vouch or a release | It is taken back, but for what is final; a user with a second vouch stays | not promised | unit: `a_second_vouch_stands` |
-| 52 | A key is retired on one side of a partition while it signs on the other | After healing, every node leaves out the same | 2 | sim: `a_cut_across_a_partition` |
-| 53 | Steals a node's key: commits changes as a witness | They count until the node is stopped with a cut, then not | 5 | unit: `a_stopped_node_witnesses_nothing` |
+| 49 | Steals a device key and signs with it | Take it until a key above cuts it off, then leave out what is outside the cut; a value it replaced is read again | 3 | unit: `a_retired_key_counts_within_its_cut`, `the_value_before_counts_again`; sim: `a_stolen_key_cut_off` |
+| 50 | Signs with a retired key, saying it saw nothing of the retiring | Hold it (valid as written), leave it out | 3 | unit: `backdated_past_a_cut` |
+| 51 | With a stolen device key, retires the keys above or beside it | Refuse | 3 | unit: `no_key_retires_one_above` |
+| 52 | With a stolen device key, retires that key from long ago, to undo what its user signed | Refuse: a key retires itself from where it stands | 3 | unit: `a_key_retires_itself_forward` |
+| 53 | A key retires itself; a retirement is carried by a node that only the retired key named; a node commits its own stop | Each counts: a cut never leaves out its own statement, nor the node that carried it | 2 | unit: `a_cut_never_reaches_itself` |
+| 54 | With a stolen key, retires the keys below it, stops nodes, unvouches, releases names | A key above cuts it off from before: all of it is taken back, but what became final on it | 3 | unit: `a_cut_takes_back_what_the_key_cut` |
+| 55 | With a device key, releases the user itself; with a stolen first key, does so before the voters can cut that key off | Refuse the first: it takes a first key. The second puts the user out, its names waiting, and a cut takes it back within `gone` | 3 | unit: `giving_up_takes_a_first_key`, `given_up_is_out_first` |
+| 56 | Steals a user's first key | The name is the thief's too, until a decision gives the user first keys anew, with a cut for the stolen one | 7 | unit: `first_keys_by_a_decision` |
+| 57 | Cuts its own key off early to take back a vouch or a release | It is taken back, but for what is final; a user with a second vouch stays | not promised | unit: `a_second_vouch_stands` |
+| 58 | A key is retired on one side of a partition while it signs on the other | After healing, every node leaves out the same | 2 | sim: `a_cut_across_a_partition` |
+| 59 | Steals a node's key: commits changes as a witness | They count until the node is stopped with a cut, then not | 5 | unit: `a_stopped_node_witnesses_nothing` |
Decisions and remakes:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 54 | 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` |
-| 55 | Brings in many users to vote, also while a remake's votes run | They vote only if a remake names them: by a list, or as all there were when it was proposed, which those who vote saw | 7 | unit: `who_votes`, `all_users_as_proposed` |
-| 56 | A remake that says all users, after one user brought in many | They vote in the next epoch: all users is whoever brought users in. The voters see the list before they vote, and name one of their own instead | not promised | unit: `voters_are_the_remakes` |
-| 57 | 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` |
-| 58 | 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) |
-| 59 | 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` |
-| 60 | 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` |
-| 61 | 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` |
-| 62 | 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` |
-| 63 | 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` |
-| 64 | 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) |
-| 65 | 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` |
-| 66 | 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` |
-| 67 | 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` |
-| 68 | Opens proposals without end | Refuse past `limits.proposals` | 6 | unit: `limits_on_proposals` |
-| 69 | 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` |
-| 70 | 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` |
-| 71 | 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` |
-| 72 | 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` |
-| 73 | 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` |
-| 74 | 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` |
-| 75 | 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` |
-| 76 | A remake's coordinator names two bases, or none; a voter's nodes record two IDs | A node takes the remake up with one base, and such a voter counts for neither: one ID is decided, or none. Then the remake is proposed again | 7 | sim: `two_bases_no_remake` |
-| 77 | 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` |
-| 78 | 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` |
-| 79 | 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` |
-| 80 | 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` |
-| 81 | Keeps the last record of a remake back, and shows it a month later | Every node goes to that base and carries over what it holds: statements, values, the order it saw, decisions since. What a third of the voters' nodes held as gone, final or dropped stays so; other lengths start anew. Not at all where another remake was decided since | not promised | sim: `a_remake_decided_late` |
-| 82 | Two remakes of one epoch are both decided | The one with the higher number holds; a node that got to the other moves by itself, and what was signed only there is signed again | 7 | sim: `two_remakes_one_epoch` |
-| 83 | 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` |
-| 84 | 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` |
-| 85 | 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` |
-| 86 | 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` |
-| 87 | 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` |
-| 88 | 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 ban, refuse, or fork | not promised | argued (Going apart, Refusing a decision) |
-| 89 | 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` |
-| 90 | 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` |
-| 91 | 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` |
-| 92 | 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` |
+| 60 | 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` |
+| 61 | 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` |
+| 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 ban, 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` |
Nodes and syncing:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 93 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
-| 94 | 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` |
-| 95 | 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` |
-| 96 | 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` |
-| 97 | 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` |
-| 98 | 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` |
-| 99 | 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 | A node lets in by key the users it carries for and those its operator names; its own names are its own | 3 | unit: `login_by_key_is_the_operators` |
-| 100 | 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) |
-| 101 | 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` |
-| 102 | 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` |
-| 103 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Refuse past `limits.writers` a user, as the change's history shows. Out of each other's sight they are valid, and held: the user's nodes have then shown more than the limit, under their signatures, and are refused as peers; the party's budget, which counts a new writer for more than a change, bounds how many came first. A remake leaves them out | 6; not bounded out of sight | unit: `limits_on_writers`; sim: `writers_out_of_sight` |
-| 104 | 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` |
-| 105 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, an actor named that nobody wrote as, operations numbered far ahead of its dependencies' or below them | Refuse before Automerge sees it: applied, such a change makes a node panic, or its document save to bytes that don't load | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `operations_naming_what_nobody_made_are_refused` |
+| 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 | A node lets in by key the users it carries for and those its operator names; its own names are its own | 3 | unit: `login_by_key_is_the_operators` |
+| 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` |
Rules, and the swarm as it is:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 106 | 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` |
-| 107 | 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` |
-| 108 | 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` |
-| 109 | A root that lies and isn't left out; a user nobody unvouches | The parties ban it from a cut on and read on without it | not promised | unit: `a_ban_for_those_who_follow` |
-| 110 | A banned user's name claimed by one who bans it | The node refuses its own user's write: the others would | 1 | unit: `no_write_by_ones_bans_alone` |
-| 111 | 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, and of two remakes ends up in the one that holds | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
-| 112 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
+| 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 root that lies and isn't left out; a user nobody unvouches | The parties ban it from a cut on and read on without it | not promised | unit: `a_ban_for_those_who_follow` |
+| 118 | A root bans the other roots, to decide alone what readers that follow the roots see | A node that follows several takes a ban only where most of them state it | not promised | unit: `a_ban_by_most_of_those_followed` |
+| 119 | A banned user's name claimed by one who bans it | The node refuses its own user's write: the others would | 1 | unit: `no_write_by_ones_bans_alone` |
+| 120 | 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` |
+| 121 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
## The registry on it
```
@@ -1895,15 +2004,16 @@ separator `:`, first come, first served like `ip4`, holds whether or not anyone
generates honestly, for addresses written out in full. The export reads an address
or a name only in the one spelling it writes.
-**Moving in.** The root is made from the repository by a script
+**Moving in.** The genesis change is made from the repository by a script
(`scripts/kartei-import`): the kinds and their rules; the maintainers as the roots and
the first voters, with their keys and nodes; and for each namespace of the repository
a user without keys, its hosts as they are, plain, and their addresses as claims in
-its name. The root is trusted as it is (every party is given its hash), so what it
-holds counts without signatures: a host from the root counts until its user signs
-over it, and a claim from the root is its user's. A root gives each user its first
-keys as it comes; from then on the user signs its own, and votes from the next remake
-that names it. A namespace whose user never comes stays as the root has it.
+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.
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,
@@ -1929,7 +2039,7 @@ the network at large reads.
## 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 (112).
+their vectors. At every stage the existing tests pass untouched (121).
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
@@ -1937,67 +2047,70 @@ their vectors. At every stage the existing tests pass untouched (112).
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: 97 to 100, 108, 112, and the policy's existing tests under a policy
+ policy. Tests: 104 to 107, 116, 121, 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
users by their own word, and the rule for committers by it; nothing plain; the
- limits, and the order past them. Resolving, step 2 without cuts, and
- `GET /registry/users`. The client signs statements. Tests: 1 to 8, 11, 12, 14, 26.
-3. **Namespaces.** The rule, with `userSigned` below a name. Tests: 25, 27. From here
+ limits, and the order past them. First, the payloads: each statement's fields and
+ the member entry's shape, settled, so that tests leave vectors. Resolving, step 2
+ without cuts, and `GET /registry/users`. The client signs statements. Tests: 1 to
+ 9, 12, 13, 16, 29.
+3. **Namespaces.** The rule, with `userSigned` below a name. Tests: 28, 30. From here
the registry runs with users and hosts, names not yet unique.
4. **Claims in sight.** Kinds, names as they are written, their characters, rules by
their structure, kept names and claims of them, limits, `claim` and `release`,
judged as written; resolving step 4 for claims in sight, and what comes back.
- Tests: 13, 29, 32 to 34.
+ Tests: 14, 32, 35 to 37, 45.
5. **Out of sight.** Late, contested and settled, for names and for users' names; a
claim's side; a root's node writing when a claim reaches it, and a node that comes
back catching up first. The voters as the root change names them; lengths of time
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, and shows a claim long unsettled. Tests: 9, 10, 28, 30, 31, 35 to 38,
- 41, 42, 93, 95, 96.
+ 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.
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: 39, 40, 43 to 49, 51
- to 53.
+ read again, the client listing what stopped counting. Tests: 15, 42, 43, 46, 49 to
+ 53, 55, 57 to 59.
7. **Unvouching.** `unvouch`, a user giving itself up, one that another vouched for
staying, those brought in going with it, the names of a user that is out waiting,
gone, nothing taken from an unvouched user's nodes, what comes back with a vouch.
- Tests: 15, 17 to 24.
+ 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 limit on
- writers, a node keeping its writer over a clean stop. Tests: 94, 101 to 104.
-9. **Bans** for those who follow. Tests: 109, 110.
+ 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.
+9. **Bans** for those who follow. Tests: 117 to 119.
10. **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. The stages after change the rules, and until a policy changes by a
decision a rule changes only by every party upgrading at once: a swarm started
here is started anew after the last stage, by an import of what it holds.
-11. **Decisions.** `propose` and `vote` 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: 16, 50, 54, 57 to 63, 65 to 72, 111.
+11. **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: 18, 56, 60, 63 to 78, 120.
12. **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: 106, 107.
-13. **Remakes.** The proposal with who votes and who the roots are; the coordinator
- and the base, 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
- and in order; decisions and what was seen for long, over a remake; two remakes of
- one epoch; 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: 55, 56, 75 to 87.
+ handshake that says which epochs its node keeps. Tests: 114, 115.
+13. **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.
14. **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: 73, 74, 108.
+ a time, moved at a remake. Tests: 79, 80, 116.
15. **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: 64, 88 to 92. From
- here it can be relied on: the rules change by decisions.
+ 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.
## What was checked, and what is assumed
@@ -2034,6 +2147,12 @@ Checked in the code:
* A message of another wire version is ignored whole (`transport::wire`).
* A node keeps the documents of the epochs it left in memory (`remake::local`).
Keeping them on disk is new.
+* The quarantine is in memory, and holds paths and values of the node's own writes
+ (`docs/remakes.md`); a replay writes state by path, the last writer winning
+ (`remake::delta`). A quarantine on disk that holds envelopes, anyone's, and every
+ node writing again the envelopes it holds after a remake, are new.
+* The relays are read from `_continuum/relays`, which an operator lists
+ (`document::meta`, `swarm::members`); the genesis change doesn't set them.
* A snapshot records the highest number per actor in its base, by which a node tells
what it holds beyond it (`remake::snapshot`, `remake::delta`). The digests of the
base's statements do that for a federated one.
@@ -2104,6 +2223,6 @@ Assumed, to be shown as it is built:
* A version can speak the wire version before its own.
* The writers a user's nodes started in a change's history are counted cheaply
enough: a count kept per user.
-* The three things asked of a change before Automerge sees it keep out every change
- it applies and shouldn't. Six such changes were tried; operations on objects that
- don't exist, and others crafted, weren't.
+* What is asked of a change before Automerge sees it keeps out every change
+ it applies and shouldn't. Crafted changes were tried by hand against Automerge
+ alone; no fuzzer was run over them.