aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-14 05:52:41 +0000
committertv <tv@krebsco.de>2026-11-14 05:52:41 +0000
commit32236bdad06ab6992dbc1f5dbe7aa44e3520e61e (patch)
tree6fdca034b180d8f4d790797bc4a6838c2cb883ab
parent85f4d50fbf8866701b45142374dc94246dc13e07 (diff)
federation: remakes are continuum's
A federated swarm remakes as every swarm does: a node proposes and coordinates, the alive peers ack, every node builds the next epoch itself. The voters no longer decide remakes, so the base check, the votes naming a base, `baseAge`, `remakeAge`, the heal, and the admin actions `choose`, `follow` and `back` go. What the federated policy adds: * compaction only, and no sooner than the epoch's history holds `remakeChanges` changes (recommended 10 000) or its changes started `remakeWriters` writers (1 000): every node proposes and acks by these numbers, and follows only such a remake; * any base serves: the snapshot holds the registry at the base with whatever something signed later could still change (envelopes with their signatures, what was given up and hasn't stopped counting for good, what the order among claims rests on, how far each length of time has run), and every node carries over what it holds beyond the base with what it held of it; * envelopes of the epoch before come from any node, as within an epoch; a claim carried over and one the snapshot holds are ordered as two claims out of each other's sight, not by the base; * lengths of time go on across a remake, each node's carry record saying what it saw broken after the base; * of two remakes of one epoch, every node goes to the one with the lower ID. A remake made a cut reach no further back than its snapshot. With remakes as frequent as the document grows, that would leave a stolen key's work standing after an hour. So what was given up, replaced, left out by a cut or past its limit, and was seen so for `final`, has stopped counting for good, remake or not; that is what a remake leaves out.
-rw-r--r--docs/federation.md840
1 files changed, 375 insertions, 465 deletions
diff --git a/docs/federation.md b/docs/federation.md
index 7a9b6f6..01f6358 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -15,9 +15,9 @@ section lists them. How sure each part of the design is, is said with the promis
A swarm is federated if its genesis change carries the federated policy (below).
Everything here holds under that policy, and nothing else changes:
-* A swarm started as today has no such policy and stays as it is: its rules, its
- users with their capabilities, its remakes by the members' votes, its tokens, and
- what its nodes send and do.
+* A swarm started as today has no such policy and stays as it is: its rules, its users
+ with their capabilities, its remakes of every kind, its tokens, and what its nodes
+ send and do.
* The code is apart where it would cost. Judging reads the policy as it does today and
takes the federated rules under the federated one only; the resolved registry is
kept there only; envelopes carry their new fields there only. The wire's version
@@ -64,7 +64,9 @@ but for what the voters can do to a user, said with each and below):
1. **Only valid changes.** Every change it holds passed the rules, judged as its
writer saw the document (at its dependencies).
2. **The same document.** Two honest nodes holding the same changes hold the same
- document, and resolve it (Resolving, below) to the same registry.
+ document, and resolve it (Resolving, below) to the same registry. A remake changes
+ nothing that counts, whoever makes it and from whatever base: every node builds the
+ next epoch itself, and carries over what it holds beyond the base.
3. **Signed by its user.** Whatever the resolved registry shows in a user's namespace
was signed with a key that was that user's when it signed, or is as the root
change has it. What it shows as held by a user, the user claimed with such a key,
@@ -90,14 +92,13 @@ fewer than a third of the voters malicious (the voters are the users the genesis
change names, or the decision that holds on who votes; a voter is honest here if its
user is and the nodes that carry for it are):
-7. **Decisions by two thirds.** A proposal (who votes, who the roots are, a remake, a
- number, the policy, first keys for a user that lost its own, a name) is decided
- only once more than two thirds of all the voters voted for it, and nodes of that
- many held those votes together. So none is decided that no honest voter voted for,
- and a side of a partition decides only with nodes of that many voters on it. Of the
- decisions of one matter every node acts on the same one, the last. A remake changes
- nothing in what counts: every node builds the next epoch itself, from the changes
- it holds. Nobody is moved against its will: a decision is refused by choice.
+7. **Decisions by two thirds.** A proposal (who votes, who the roots are, a number,
+ the policy, first keys for a user that lost its own, a name) is decided only once
+ more than two thirds of all the voters voted for it, and nodes of that many held
+ those votes together. So none is decided that no honest voter voted for, and a side
+ of a partition decides only with nodes of that many voters on it. Of the decisions
+ of one matter every node acts on the same one, the last. Nobody is moved against
+ its will: a decision is refused by choice.
What is not promised:
@@ -119,8 +120,8 @@ What is not promised:
user it created or vouched for goes out as by an unvouch, its names waiting until it
is gone; but a user another vouches for stays in, with what it claimed: a thief's
accomplice keeps the thief's sock in, and so does a root's node that witnesses for
- it after the cut, in the open. Past what became final meanwhile, and past a remake,
- it stays.
+ it after the cut, in the open. Past what became final meanwhile, and what stopped
+ counting for good, it stays.
* **Agreement in the classic sense, for what users write.** There is no quorum there,
so no n ≥ 3f+1: promises 1 to 4 and 6 hold against any number of malicious parties,
and 5 from when a root saw the claim. Only decisions take two thirds, and only the
@@ -149,39 +150,27 @@ What is not promised:
decided and choose which is the later. So does a node that carries for a third of
them, until they name another (Decisions).
* **When a proposal is decided.** One that had the votes and lacks records of nodes
- hangs over its matter: whoever holds the last record chooses the day. The voters
- end that by deciding a later proposal of the matter (Decisions); not for a remake.
-* **A remake the voters changed their minds on.** A vote for a remake isn't released,
- and a voter has one an epoch. So a remake that hangs comes on the day its last
- record does, for the rest of the epoch, and those who voted for it vote for no
- other. A node follows a remake at once only within `remakeAge` of taking its base
- up; past that, it waits in the epoch until the new epoch's carry records count for
- more than a third of the voters (Partitions). Every node holds that number, but each
- took the base up when it reached it, and gets the decision when it does: whoever
- holds the last record can show it when some honest nodes are past that and some
- aren't, and splits them. The split shows, and heals once those carry records count
- for more than a third; until then those that followed stay, or go back by their
- operators' word, their users signing again what they wrote there. And voters who
- split their votes between two remakes, neither getting more than two thirds, end the
- epoch's remakes: those left go apart (Going apart). One voter can split them:
- clients keep honest votes on one remake, but a twin proposal made while honest
- voters vote, within the same minutes, splits those.
+ hangs over its matter: whoever holds the last record chooses the day. The voters end
+ that by deciding a later proposal of the matter (Decisions).
* **Decisions without the voters.** With a third of an epoch's voters not taking
part (gone, silent, without a node that carries for them), nothing more is decided
there; what users write goes on. Those left go apart (Going apart).
* **Anything of 7 with one voter.** A swarm that one user starts has that user as its
only root and voter until it decides on others: it decides alone, and what a third
of the voters see, it sees alone.
-* **Time across a remake.** A length of time that had begun when a remake came
- starts anew after it. What became gone, final or dropped after a remake's base
- stays so where the nodes of a third of the voters carried it over (Remakes).
* **A bound on what an epoch's document costs.** What is valid as written every node
holds until a remake: statements past a limit, writers started past
`limits.writers`, a change of a few bytes that holds a million operations, a
- snapshot built for every remake's base. Each costs memory and time, and nothing
- bounds how many reach a node as part of others' histories: a limit and a party's
- budget bound how fast a node takes them from the party itself. Who did it shows,
- under its nodes' signatures.
+ snapshot built for every remake a node is offered. Each costs memory and time, and
+ nothing bounds how many reach a node as part of others' histories: a limit and a
+ party's budget bound how fast a node takes them from the party itself. Who did it
+ shows, under its nodes' signatures.
+* **How often the swarm remakes, and from what.** The alive peers commit a remake as
+ in every swarm, and a party that runs most of the alive nodes has them. It changes
+ nothing that counts, and comes no sooner than `remakeChanges` and `remakeWriters`
+ allow; but each
+ remake of an epoch a node is offered costs it a snapshot, the lowest ID first,
+ until one comes out to the ID it was committed for.
* **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
@@ -237,8 +226,8 @@ value:
| `uncovered` | 90 days | how long what a policy no longer covers stays aside before it is dropped; none: until its user takes it away |
| `archiveRetention` | 90 days | how long a node answers for an epoch it left, at least |
| `stamp` | 1 day | how often a node that is up renews its alive stamp |
-| `baseAge` | 10 minutes | how much of what a node holds a remake's base may lack |
-| `remakeAge` | 30 days | how long after taking its base up a node still follows a remake |
+| `remakeChanges` | 10000 | changes an epoch's history holds beyond its root change before a remake |
+| `remakeWriters` | 1000 | writers an epoch's changes start before a remake |
| `witness` | 1 minute | how long a root's node lets a claim wait before it writes |
| `limits.keys` | 64 | keys a user has at once |
| `limits.nodes` | 64 | nodes carrying for a user at once |
@@ -259,14 +248,12 @@ too. The relays aren't: in a federated swarm they are each node's configuration
document, which nobody may write plain.
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
-nothing takes a base that lacks nothing. Three end deciding itself: a
-`fractions.decide` of 1, `limits.proposals` at 0, a `window` of nothing; a `remakeAge`
-of nothing ends remaking, as nobody follows a remake at once. What is left then is
-refusing that decision, or going apart. A proposal that leaves a number without a
-value where it needs one is no proposal. More than a share is strictly more; a share
-of the voters, for what was seen for long, is the fewest voters that are that share at
-least, and one at least.
+time of nothing is "at once"; a limit of nothing lets nothing more in. Three end
+deciding itself: a `fractions.decide` of 1, `limits.proposals` at 0, a `window` of
+nothing. What is left then is refusing that decision, or going apart. A proposal that
+leaves a number without a value where it needs one is no proposal. More than a share
+is strictly more; a share of the voters, for what was seen for long, is the fewest
+voters that are that share at least, and one at least.
Where this text says two thirds and a third, it means the two fractions as
recommended. What is promised of decisions is argued for those; a swarm that sets
@@ -474,8 +461,8 @@ the changes alone: the stamps are changes in the history, each renewal one.
While no node writes at all, no time passes: nothing is seen for longer by it.
* The length that counts is the number's as it holds in the later stamp's history.
What was seen for long stays so: gone, final and dropped never go away.
-* A remake starts every length anew: what was being seen is seen from the new
- epoch's first stamps on. What had been seen for long stays so (Remakes).
+* A remake starts no length anew: the snapshot holds how far each had run, and the
+ nodes' stamps go on from there (Remakes).
No clock is compared with another. A third, because decisions are argued against
fewer than a third of the voters being malicious: so few show nothing by themselves,
@@ -752,8 +739,9 @@ to a name (a kept name, a name only `tv` claims) is nobody's while the name is.
### Cuts: what stops counting
A **cut** is a set of changes, named by their hashes: "as far as I saw". A statement
-is within the cut if a change that carries it is in the history of the cut. Whether
-it is doesn't depend on who asks or when: a change's history is fixed by its hash.
+is within the cut if a change that carries it is in the history of the cut, or, for
+one the epoch's snapshot holds, if the cut's list names it (below). Whether it is
+doesn't depend on who asks or when: a change's history is fixed by its hash.
* **Retiring a key** names the key and a cut. What the key signed within the cut
counts as before; what it signed outside doesn't count, for anyone, whenever it
@@ -766,13 +754,14 @@ 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's
- stop lists what its cut keeps the same way, and so does a decision's cut of a user's
- first keys. A list is 32 bytes for each statement and value kept, since the root
- change: what a remake resets.
+* **What a cut keeps, it names.** Beside the cut, a `retire` lists by digest what it
+ keeps of what the key signed: what is within the cut of the epoch's own, which every
+ node checks where the statement is taken, as it checks a number; and what it keeps
+ of what the snapshot holds, which is in the history of every change after it, so the
+ list alone says. So what a retirement keeps holds also where the changes its cut
+ names aren't there: after a remake. A node's stop lists what its cut keeps the same
+ way, and so does a decision's cut of a user's first keys. A list is 32 bytes for
+ each statement and value kept that hasn't stopped counting for good.
* **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.
@@ -815,6 +804,13 @@ What stops counting stays in the document, and every node holds the same. It is
out when resolving. In a namespace, where a value that doesn't count replaced one
that does, the one that does is read again (Resolving).
+**For good.** What doesn't count because it was given up, replaced, left out by a cut
+or past its limit, and has been seen so for `final` (Lengths of time), has stopped
+counting for good: no cut, no limit raised, nothing brings it back. Not so what
+doesn't count only because its user is out, which waits until the user is gone, nor
+what a policy no longer covers, which stays aside until it is dropped. A remake leaves
+out what stopped counting for good (Remakes).
+
The price: a key above retiring one below with an early cut takes back what that key
signed since, a release among them, further back than an unvouch reaches; a vouch or a
creation no further than its signer's unvouch would, signed where the retirement was,
@@ -829,7 +825,8 @@ the user brought in and releases its names. A key above takes all of that back w
a cut, as far as nothing final was built on it. Only giving the user itself up takes
a first key.
-A cut reaches no further back than the epoch (Remakes).
+A cut reaches back as far as anything still counts or could: what stopped counting
+for good, it doesn't bring back.
### Leaving a user out when reading
@@ -846,8 +843,8 @@ and refuses as peers whom its operator says.
Some things are the swarm's to decide: its numbers and the rest of its policy, a
user's first keys where it lost its own, the names of a user that is out, whose a
-contested name is, names the rules leave to the voters, when to compact, who votes and
-who the roots are. They are decided by votes of users, signed by them, over days.
+contested name is, names the rules leave to the voters, who votes and who the roots
+are. They are decided by votes of users, signed by them, over days.
**Who votes.** The **voters** are the users the genesis change names (the user who
starts the swarm, or those the file it starts from says), and from a decision on who
@@ -899,9 +896,7 @@ voted on, they propose again to those who vote now.
for longer than `window` from when it first held it. A voter has one vote on a
matter at a time; `release` takes one back, as far as it gets there first: a node
that holds the vote without its release counts it, and a proposal may be decided
- with a vote whose release was on its way. A vote is meant when signed. A vote for a
- remake is otherwise: it names its base, runs while the epoch lasts, and isn't
- released (Remakes).
+ with a vote whose release was on its way. A vote is meant when signed.
3. A node that carries for a voter **takes the proposal up** once it holds votes for
it by more than two thirds of all the voters (`fractions.decide`), none released,
each still running by the node's clock, and the proposal says its signer saw all
@@ -909,18 +904,16 @@ voted on, they propose again to those who vote now.
under `_continuum/decisions/<proposal>/<node ID>`. It takes up only a proposal with
a higher number than any of the matter that it took up, or that it holds as taken
up by another node of its voters. Every node judges the record: its history must
- hold votes for the proposal by that many voters, none released there. (A remake is
- taken up by its base instead, and its record judged without votes: Remakes.) 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.
+ 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 (a remake is decided by its records and the votes naming its base: Remakes).
- 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.
+ 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.
@@ -947,13 +940,12 @@ names after. `GET /registry/decisions` shows how many voters each node carries f
**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 only what is higher than it took up,
-so what is decided late changes what holds only where no proposal with a higher
+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
-later proposal of the matter, saying the same or something else: that one holds,
-whatever comes after. Not so a remake: its votes aren't released, and nothing but
-its last record ends it (Remakes).
+up, by whose nodes, and how many it is short of. The voters end it by deciding a later
+proposal of the matter, saying the same or something else: that one holds, whatever
+comes after.
**Where a decision counts.** A change is judged by the decisions decided in its
history, so one made out of sight of a decision is valid as it was written, and
@@ -971,12 +963,10 @@ page, paper) is the application's.
**From the past.** Votes kept back until they ran out, or crafted to look old, are
held while they run by no honest node, so nothing takes their proposal up but its
makers' nodes, and their records are judged like any: they need the votes of two
-thirds of the voters. With that many keys stolen later, a decision of then is made up
-within the epoch, and holds if it gets the highest number of its matter, until the
-decision of that matter that holds is final; the voters decide a later one. Of voters
-that others replaced, it decides nothing (The voters before). A remake puts everything
-before its base out of reach. A remake's vote doesn't run out: kept back, it counts
-when it comes, as its signer wrote.
+thirds of the voters. With that many keys stolen later, a decision of then is made up,
+and holds if it gets the highest number of its matter, until the decision of that
+matter that holds is final; the voters decide a later one. Of voters that others
+replaced, it decides nothing (The voters before).
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
@@ -1014,7 +1004,6 @@ clocks. A window of days bears clocks that are minutes apart.
* **Who the roots are**: their IDs, one matter, and for each root it leaves out which
root has each name a rule gives a root. One that names no root is no proposal:
nobody would be in.
-* **A remake** (below). An epoch has one.
A decision stays, whatever is cut off after: a vote signed with a key that is retired
later, from before, stays in it. The days a vote takes are the time to cut a stolen
@@ -1022,117 +1011,105 @@ key off.
### Remakes
-A federated swarm compacts by a remake its voters decide. A remake throws history away
-and does nothing else: what the next epoch holds isn't voted on. It is the registry as
-it resolves, which every node works out itself.
+A federated swarm remakes as every swarm does ([`remakes.md`](remakes.md)): a node
+proposes and coordinates, the alive peers ack, and every node builds the next epoch
+itself and switches. Nothing the swarm decides goes through it, and nothing that counts
+changes by it: it keeps the document small, and the nodes do it by themselves. What
+the federated policy adds is when, what the snapshot holds, what comes along, and which
+of two remakes the nodes go to.
-* **The proposal** names the node of its proposer that is to be its **coordinator**,
- and the switch delay.
-* **The base.** The coordinator names the base in its record of the proposal, by its
- heads, at once.
-* **Taking the base up.** Every node takes the base up where the base holds all that
- the node held `baseAge` before the base reached it, so that a remake can't leave out
- what the swarm has; or, however old, where records of that base count for a third of
- the voters, of whom one at least is honest, votes or none. A voter's node records
- it, with the ID of the epoch it built from it (Continuum changing under a swarm);
- any other node notes when it took it up, which `remakeAge` counts from, and builds
- the snapshot only once the remake is decided. Taking a base up chooses nothing: a
- node takes up every base that passes, one record a proposal (two proposals that name
- one base have a record each), and switches only to the one decided. Each costs a
- voter's node a snapshot of the document; a voter has `limits.proposals` open at
- once, and its budget paces them.
-* **The votes name the base.** A voter votes for a remake once a node of its took the
- base up, and its vote names the base. It has one such vote an epoch, never released.
- A record counts for a voter only where that voter's vote names the record's base. So
- two bases are both decided only where more than a third of the voters signed votes
- for both, which no honest voter does: a coordinator that names two bases, to two
- nodes of each voter, gets one decided or none, and shows: clients offer no vote for
- its proposal. A client offers a vote only for a base whose records count for more
- than two thirds of the voters, which every node then takes up, and shows the other
- remakes under way beside it: a vote is spent only on a base every voter's node can
- take up. Of the remakes under way that name the same voters and roots it offers one,
- by a rule every client applies alike (the one with the most votes, then the lowest
- digest).
-* **Decided** for a base and an ID, once a change has in its history records of the
- proposal naming them, and votes for it naming the base, that together count for more
- than two thirds of the voters. A record is judged without votes: it is written when
- its node takes the base up, before them, and they are read beside it, not in its
- history.
-* **A remake that hangs**, short of votes or records, is decided once they come: every
- node takes up a base a third took up. Nothing else ends it: its votes aren't
- released, so whoever holds its last record chooses its day for the rest of the
- epoch, and those who voted for it vote for no other. A node follows it at once only
- within `remakeAge` of taking its base up; past that, once the new epoch's carry
- records count for more than a third of the voters (Partitions). Voters who split
- between two remakes, neither getting more than two thirds, end the epoch's remakes:
- those left go apart (Going apart). 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 which (`POST /admin/epochs/choose`).
-* **Every node builds the snapshot** itself once the remake is decided, from the base
- as it holds it, and switches after the switch delay its proposal names. The snapshot
- holds the registry as it resolves at the base:
- * the policy that holds, with its numbers;
- * the voters and the roots, as the decisions that hold say;
- * the users that count, and those out and not gone, each with its name (or that
- it is contested, and with which), ID, keys, nodes, and who created and who
- vouches for it, or that it is in by the seats;
- * the claims that stand, the names decisions gave, and what the order among the
- claims of a name rests on: which gives way to which, which is late against which,
- which is settled, which final; and of a user the root change holds, roots'
- creations that contest each other, with what their order rests on, until the
- voters give it first keys;
- * the values in the namespaces that count, as the envelopes they are;
+* **Compaction only.** A node follows a remake of the kind `compact` alone: `replace`,
+ `import` and `strict` put content nobody signed, and start a new swarm.
+* **When.** A node proposes a remake by itself once the epoch's history holds
+ `remakeChanges` changes beyond its root change, or its changes started
+ `remakeWriters` writers, after a random wait, unless one is under way; and acks one
+ whose proposal has that in its history. It follows only a remake whose base holds
+ that. So remakes come as the document grows, nobody asking, and no faster, whoever
+ proposes them.
+* **Any base.** The base is the coordinator's heads when it commits, as in every swarm,
+ and the coordinator may be anyone's node. One that leaves out what others hold, or
+ is old, loses nothing: every node carries over what it holds beyond the base, with
+ what it held of it (below). A node that lacks the base syncs it from a peer that
+ keeps the epoch.
+* **By its result.** Every node builds the snapshot itself from the base, and follows
+ only where it gets the epoch ID the remake was committed for (Continuum changing
+ under a swarm).
+* **Two remakes of one epoch**, both committed: every node goes to the one with the
+ lower ID, a node in the other moving to it as one that comes back does (Coming back
+ after remakes), with what it holds there. No count of nodes decides, which a party
+ running many nodes would have.
+* **The snapshot holds** the registry as it resolves at the base, and with it whatever
+ something signed later could still change:
+ * the policy that holds, with its numbers, and the decision that holds of each
+ matter, with its number and digest, and whether it is final;
+ * the users that count, and those out and not gone, each with its name (or that it
+ is contested, and with which), ID, keys, nodes, and who created and who vouches
+ for it, or that it is in by the seats;
+ * every statement and value that counts, as the envelope it is, with its signature;
+ * what doesn't count and could still come to: what was given up, replaced, left out
+ by a cut or past a limit, and hasn't stopped counting for good (Cuts), each as its
+ envelope, with what stopped it;
+ * what the order among claims rests on: which claim gives way to which, which is
+ late against which, which is settled and which final, which statements count
+ through an unvouch or a cut; and for each claim not yet settled, the users whose
+ nodes had it standing in a change they committed;
+ * how far each length of time has run: for each thing being seen (a user out, a
+ claim holding its name, a decision holding, a thing uncovered), each node of a
+ voter with its first stamp, and that stamp's time, from which it has held the
+ thing so without a break;
* 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 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, carried over, in the next. So that what a remake left out (a stolen laptop's
- key and node, retired since) can't be handed in again in the next epoch as signed in
- the one before, the root change lists the digests of all the statements the base
- held, and of the values deleted there, and an envelope among them is refused. The
- epoch after drops the list.
+ * the member entries of the nodes that carry for a user it holds, and the epochs'
+ metadata, as today;
+ * the digests of the envelopes the base holds that were signed in the epoch it
+ leaves.
+* **What it leaves out**: the history, and what can never count again: a user gone;
+ what stopped counting for good, and the release, stop or unvouch that gave it up; a
+ proposal decided or closed, with its votes and the nodes' records. So after a remake
+ the document's size goes by what stands (users, their keys and nodes, names held,
+ values, members) and by what stopped counting within the last `final`, and for one
+ epoch by 32 bytes for each envelope signed in the one before; 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 left out comes back.** An envelope is taken in the epoch it names and,
+ carried over, in the next. So that what the base held and the remake left out (a
+ stolen laptop's key and node, retired long since) can't be handed in again as signed
+ in the epoch before, the root change lists the digests of the envelopes the base
+ held that were signed there, and an envelope among them is refused. The epoch after
+ drops the list.
* **Carried over.** A node that switches first catches up with the peers it keeps in
the epoch it leaves, as a node that comes back does. Then, before it takes anything
in the new epoch, it commits its **carry record**, every node that switches, whoever
- it carries for (out voters too: the heal counts their nodes),
- `_continuum/carried/<node ID>`: the digests of the envelopes it holds that the base
- lacks, whoever signed them (statements, values, proposals, votes and their
- releases), and what it held of them, as the snapshot states it for the base: which
- claim it held as late against which, or as giving way to which; which statements of
- a user since unvouched, or whose creation or vouch was cut off, count through the
- unvouch or the cut; which users it held as gone, which claims as final and what as
- dropped, beyond the snapshot. One record a node and epoch, of digests and of what
- the node held. Nothing tells it from a later change of the node, and nothing has to:
- it witnesses by what it names, not by when it was committed. A node that came to
- carry after the base commits, with its record, the `node` statement that named it
- (rule 2).
+ it carries for (out voters too), `_continuum/carried/<node ID>`: the digests of the
+ envelopes it holds that the base lacks, whoever signed them (statements, values,
+ proposals, votes and their releases), and what it held of them and of what the
+ snapshot holds: which claim it held as late against which, or as giving way to
+ which; which statements of a user since unvouched, or whose creation or vouch was
+ cut off, count through the unvouch or the cut; and which lengths of time, of those
+ the snapshot lists for the node, it saw broken after the base. One record a node and
+ epoch, of digests and of what the node held. Nothing tells it from a later change of
+ the node, and nothing has to: it witnesses by what it names, not by when it was
+ committed. A node that came to carry after the base commits, with its record, the
+ `node` statement that named it (rule 2).
* **Then the envelopes, once.** After its record the node takes from its peers, and
writes again, as they are, the envelopes its record names that the epoch doesn't
- hold yet. Any node commits such an envelope (a `node` statement only the node it
- names), and only where a carry record in the change's history names it: what no
- node held when it switched isn't taken in the new epoch. It is taken as it is
- signed, and never refused for what stands in the new epoch: whether it counts is
- resolved. So an envelope comes into the new epoch about once, and what each node
- witnessed comes as 32 bytes a node.
+ hold yet. Any node commits an envelope of the epoch before, as it commits any (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 an
+ envelope comes into the new epoch about once, and what each node witnessed comes as
+ 32 bytes a node.
* **A carry record witnesses** as the node's changes did in the epoch before: as a
change with what it names in its history, standing or not as it says. Against a
claim, where a node of that claim's side committed it; for an unvouch, or a vouch or
- a creation cut off, where a node of its signer or of a root did: the epoch's it
- leaves, whose roots and voters the record speaks for. So a claim that turns up later
- as signed in the epoch before is late against what a root's node's record names, and
- nothing rests on the order a node writes in. Against a claim the snapshot holds,
- what is carried over gives way.
+ a creation cut off, where a node of its signer or of a root did. So a claim that
+ turns up later as signed in the epoch before is late against what a root's node's
+ record names, and nothing rests on the order a node writes in.
+* **Carried over, and held by the snapshot.** What a claim carried over says its
+ signer saw isn't there to look at, so it and a claim the snapshot holds are ordered
+ as two claims out of each other's sight: by the carry records, and by what the
+ snapshot says of the one it holds. A claim settled at the base has every claim
+ carried over late against it; one not yet settled, those of the users whose nodes
+ the snapshot lists as having had it standing.
* **Its order and its numbers.** Of a user's statements of one kind, and of the
proposals of a matter, those the snapshot holds come first, then those carried
over, by the numbers they state, then those signed in the new epoch. So a number
@@ -1143,39 +1120,36 @@ it resolves, which every node works out itself.
new epoch is at its place: whoever writes in the new epoch has the last word over
what the epoch before held, seen or not. Of several carried over to one place,
one that another replaces is left out (Resolving).
-* **A cut carried over** is the list its statement carries (Cuts): what the key
- signed within the cut since the root change counts on, and nothing else of that
- key that the snapshot doesn't hold.
+* **A cut carried over** is the list its statement carries (Cuts).
* **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. 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. A remake's own proposal and votes aren't carried over: they are of
- their epoch, which has its one remake.
-* **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 carry record. What the nodes of a third of the voters of the epoch
- it leaves say, a node counted for one voter, is so. Every other length starts anew.
-* **A remake decided late** sends every node to a base that old. What was signed since
- comes along, about once: every node's carry record names what it holds and what it
- held of it, decisions among it. What it costs is the lengths of time that had begun,
- and whatever only a node witnessed that didn't come along.
-* **What a remake makes final.** A cut reaches no further back than the snapshot.
- What a key signed that counted at the base counts for good, though the key be cut
- off later from before; so for an unvouch. The days a vote takes are the time to cut
- off a stolen key and to sort out what is contested. After, what a thief did stands
- until it is undone by hand.
+ again.
+* **Lengths of time go on.** A node's stamps in the new epoch continue the one the
+ snapshot lists for it: a thing it held so there and at a stamp in the new epoch has
+ been so all the while, unless its carry record says it saw the thing broken after
+ the base. What its stamps in the epoch before showed after the base is read no other
+ way.
* **A node that was away** comes back as said below (Coming back after remakes).
* **A node that joins** is given a root change to start from, by whoever brings its
user in: the genesis change, or the ID of a later epoch.
-* **No other kinds.** `replace` and `import` put content nobody signed: they start a
- new swarm.
+
+**What a remake changes**, then, is nothing that counts, but for what it can't carry:
+an envelope signed two epochs back comes no more (Coming back after remakes); what only
+a node witnessed after the base, and named in no carry record because it never
+switched and doesn't come back, is lost with it; a decision decided after the base
+waits in the new epoch for the nodes of two thirds of the voters to take it up again.
+Who remakes, when, and from what base changes none of it: that is why the alive peers
+decide it, of whom a party running many nodes can be most.
For the registry the document is small: a statement is under a KiB, a node's alive
stamp with its digest and signature some 350 bytes, so a hundred nodes stamping
-daily write some 13 MiB a year. A remake a year is plenty for its size.
+daily write some 13 MiB a year. What makes a swarm remake is mostly what its writers
+cost in memory (Users), which grows with the history and with the writers:
+`remakeChanges` and `remakeWriters` keep it in bounds, at some 40 MB on every node at
+most.
### Coming back after remakes
@@ -1189,14 +1163,14 @@ in one of two ways:
as it keeps that epoch's document: `archiveRetention` at least, longer if its
operator says, and every epoch on a node kept as an archive. Peers say in the
handshake which epochs they keep. From such a peer the node syncs the rest of the
- epoch it is in, judging every change; sees the remake decided; builds the snapshot
- itself; and is in the next epoch, whose ID is the snapshot's hash. So on, epoch by
- epoch, as far as peers keep them: with an archive within reach, from any epoch to
- the swarm's, and for a node that joins, from the genesis change. Where the walk
- ends in another epoch than the node's peers are in, the node stops and shows it,
- for its operator to say which (`POST /admin/epochs/choose`): an archive can keep
- changes back, and a decision of long ago can be made up with keys stolen since.
- Keeping an archive is an application's; continuum answers for what a node keeps.
+ epoch it is in, judging every change; sees the remake committed (of two, the one
+ with the lower ID); builds the snapshot itself; and is in the next epoch, whose ID
+ is the snapshot's hash. So on, epoch by epoch, as far as peers keep them: with an
+ archive within reach, from any epoch to the swarm's, and for a node that joins,
+ from the genesis change. Where the walk ends short of the epoch the node's peers
+ are in (an archive can keep a remake's commit back), the node stops and shows it,
+ for its operator to give it the ID (below). Keeping an archive is an application's;
+ continuum answers for what a node keeps.
2. **By an ID, on its operator's word.** Where no peer keeps the epoch any more, the
node can't check how the swarm got from there to here. Its operator gives it the
ID of the epoch to go to (`POST /admin/epochs/rejoin`), from a party it trusts:
@@ -1220,9 +1194,11 @@ Either way, what follows:
* **As a voter or a root** the user is what the decisions that hold there name it.
* **Its old document** goes to the archive, as today.
-A node moves to an older epoch, or to another of the same age that doesn't hold by the
-rule above, only by its operator's word (`POST /admin/epochs/back`,
-`POST /admin/epochs/choose`).
+A node in the other of two remakes of one epoch moves the same way, to the one with
+the lower ID: it holds the epoch both came from, builds the snapshot from that base,
+and carries over what it holds, envelopes signed in the epoch it leaves among them
+(What every node judges). To any other epoch a node moves only by its operator's word
+(`POST /admin/epochs/rejoin`, `POST /admin/fork`).
### The policy changes by a decision
@@ -1275,8 +1251,8 @@ rest, or for a policy the others won't have. A fork is proposed, and binds nobod
holds, or another), and, if it likes, who votes there and who the roots are.
Where it names none, they are as they hold. Voters may vote for it: that shows
who would go, and decides nothing.
-* The proposer's node names the base, as a remake's coordinator does, when its user
- says so, votes or none.
+* The proposer's node names the base in its record of the proposal, when its user says
+ so, votes or none.
* A node follows if its operator says so (`POST /admin/fork`, naming the proposal and
the base): it builds the snapshot at the base with what the proposal says, carries
over what it holds beyond the base, and goes on in that epoch. A node that doesn't
@@ -1304,10 +1280,6 @@ follows every decision. Its operator has it refuse:
the node starts with them refuse nothing: the node shows them.
* **By hand** (`POST /admin/decisions/refuse`, naming the proposal): any decision of
the epoch the node is in.
-* **By how late a remake comes** (`remakeAge`, the policy's): how long after it took a
- base up, by its own clock, a node follows a remake decided on it at once. One
- decided later it doesn't, until the new epoch's carry records count for more than a
- third of the voters (Partitions).
What refusing does:
@@ -1330,7 +1302,6 @@ What refusing does:
different epochs, no syncing between them. On each side the voters are those its
decisions name, and a side with too few of them names its own, by a fork. A node
moves to the other side by its operator's word.
-* **A remake** is refused by staying: the epoch a node is in goes on as it was.
So every number is the swarm's to set, and each party's to bear or not. A decision
that lets one voter decide for all is followed by those who don't mind.
@@ -1368,7 +1339,7 @@ signs) and the signature, over all the rest. Beside those, by kind:
| `release` | `of`, the digest of the claim, vote or proposal given up; or `self`, the user giving itself up (signed with a first key) |
| `claim` | `claimKind` and `name` |
| `propose` | `matter`, `holds` (below), `matterNumber` (its number among its matter's proposals: Decisions) |
-| `vote` | `proposal`, its digest; `ends`, when it runs out; for a remake `base` (its heads), with no `ends` |
+| `vote` | `proposal`, its digest; `ends`, when it runs out |
A proposal's `matter` and what it `holds`:
@@ -1382,7 +1353,6 @@ A proposal's `matter` and what it `holds`:
| `votersName`, naming a kind and a name | the user ID it is given to |
| `voters` | the voters' IDs |
| `roots` | the roots' IDs, and for each root left out which root has each name a rule gives it |
-| `remake` | `coordinator` (a node's ID), `switchDelay` |
| `fork` | the policy to go on with, and, if it likes, `voters` and `roots` |
A fork is no matter: a vote for one counts toward nothing, shows who would go, and
@@ -1392,13 +1362,13 @@ leaves a voter's one vote a matter alone.
is:
* **A record of a proposal**, `_continuum/decisions/<proposal>/<node ID>`: `proposal`;
- of a remake, `base` (heads) and `epoch` (the ID it built from it, a voter's node);
of a fork, `base`, the proposer's node.
* **A carry record**, `_continuum/carried/<node ID>`: `from` (the epoch it left),
- `digests` (of the envelopes it holds that the base lacks), and what it held of
- them: `late` and `givesWay` (pairs of claims' digests), `through` (statements that
- count through an unvouch or a cut: their digests), `gone` (user IDs), `final`
- (claims' digests), `dropped` (what is uncovered: digests).
+ `digests` (of the envelopes it holds that the base lacks), and what it held of them
+ and of what the snapshot holds: `late` and `givesWay` (pairs of claims' digests),
+ `through` (statements that count through an unvouch or a cut: their digests),
+ `broken` (lengths of time the snapshot lists for the node that it saw broken after
+ the base).
* **A member entry**, of the shape its policy's version gives it, within
`limits.entry`: what it is today (its addresses, what it reaches, whether it is
ready, its alive stamp), and `writersFor` (the user its writers count for: Users)
@@ -1432,21 +1402,21 @@ A change is valid if, in the document at its dependencies:
of a proposal, or its carry record, 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`), its own records of proposals and its carry record, it
- writes only envelopes, each naming the swarm, its epoch, its path, its user and
- user ID, and for a statement what its signer saw (`seen`, changes in this change's
- history) and, where statements of its kind are numbered, the number that gives it,
- signed with a key that is that user's there and not retired there. Any node commits
- it, but a `node` statement, which the node it names does.
+ within `limits.entry`), its own records of proposals, its carry record, and what it
+ writes of a remake as in every swarm (its ack; a coordinator's proposal and
+ decision, of the kind `compact`), it writes only envelopes, each naming the swarm,
+ its epoch, its path, its user and user ID, and for a statement what its signer saw
+ (`seen`, changes in this change's history) and, where statements of its kind are
+ numbered, the number that gives it, signed with a key that is that user's there and
+ not retired there. Any node commits it, but a `node` statement, which the node it
+ names does.
4. In a register (`_continuum/users/<name>`, `_continuum/claims/<kind>/<name>`): only
a new entry under its own digest. Under `_continuum/decisions/<proposal>`: only the
- node's own record, once, of a proposal that is there: of a remake, the base its
- coordinator's record names (the coordinator's own names it) and the ID built from
- it; of a fork, its proposer's node's own, naming the base, without votes; of any
- other, with votes for it in the change's history by more than `fractions.decide` of
- the voters, none released there. Under `_continuum/carried`: only the node's own
- carry record, once an epoch. Nothing replaced, nothing deleted, nor anything that
- holds a register.
+ node's own record, once, of a proposal that is there: of a fork, its proposer's
+ node's own, naming the base, without votes; of any other, with votes for it in the
+ change's history by more than `fractions.decide` of the voters, none released
+ there. Under `_continuum/carried`: only the node's own carry record, once an epoch.
+ Nothing replaced, nothing deleted, nor anything that holds a register.
5. A `create`: its name is one the kind `user` takes, and neither a creation of it nor
a user's claim of it as its own name stands there, 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
@@ -1469,19 +1439,18 @@ A change is valid if, in the document at its dependencies:
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; for a remake, naming the base a record of that
- proposal names, and the voter's only one in the epoch.
+ 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.
-**What is carried over**: an envelope naming the epoch before this one is held to
-less, and comes one way only: in a change that has in its history a carry record
-naming its digest. Any node commits it (a `node` statement only the node it names).
-What it says its signer saw isn't looked at, and its number orders only among what
-is carried over. Of 5 to 8 only what the envelope itself shows is asked: its
-signature by a key that is its user's there, its register, for a value that its
-`prev` is a value the snapshot or another carried over holds there, and that the
-root change doesn't list its digest. Whether it counts is resolved.
+**What is carried over**: an envelope naming the epoch before this one, or another
+remake of that epoch, is held to less. Any node commits it, as any envelope (a `node`
+statement only the node it names). What it says its signer saw isn't looked at, and
+its number orders only among what is carried over. Of 5 to 8 only what the envelope
+itself shows is asked: its signature by a key that is its user's there, its register,
+for a value that its `prev` is a value the snapshot or another carried over holds
+there, and that the root change doesn't list its digest. Whether it counts is
+resolved.
Where a rule goes by a user's name (6, 7) and the name has several creations there, a
user that lost it, as far as the change's history shows (another remains, Two claims),
@@ -1524,7 +1493,8 @@ the steps before:
outside a cut they set themselves, nor left out with their carrier. A user is
**out** where it counts through no `create` or `vouch` 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.
+ name; and gone it stays, whatever is vouched or cut off after. What stopped
+ counting for good (Cuts) counts no more, whatever comes 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; a user's claim of its own name
stands with it, and on where the creation doesn't. Of what stands for a name: the
@@ -1542,8 +1512,8 @@ the steps before:
* one named by the decision that holds on whose the name is: the other gives way;
* 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 carried over, the other held by the snapshot: as neither in sight of the
+ other, the snapshot saying whose nodes had the one it holds standing (Remakes);
* 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, where the other didn't stand
there only by an unvouch or a cut, the two are asked as neither in sight of the
@@ -1596,39 +1566,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). The same where two remakes of one epoch were both decided, which takes
-more than a third of the voters voting for both (Remakes).
-
-**A remake past `remakeAge`** splits the honest nodes for a while: those that got the
-decision within it follow, those past it wait in the epoch. It shows on both sides:
-those that wait hold the decision and see peers in the new epoch; those that followed
-see peers in the old one, the decision in their history (`GET /peers`, the dashboard).
-It heals by the new epoch's carry records, counted as what was seen for long is: a
-node for one voter, of the voters of the epoch that decided the remake, each record as
-it stood where it was written (a stop with a cut after it takes nothing back). A node
-that waits asks a peer in the new epoch for them once, when the two connect (their
-handshakes name their epochs), and the peer pushes it each one it takes after, as it
-takes it: nothing is polled. It judges them against the snapshot it builds from the
-base it holds. Read so, alike by every node, they only grow:
-
-* Once they count for more than a third of the voters, every node that waits follows:
- a node of an honest voter took it up in time, and the malicious alone count for
- less. A node whose operator refused the remake, by hand or by sending it back,
- doesn't: the heal moves only those that wait by `remakeAge`.
-* While they count for no more, the split stays, shown on both sides. A node that
- followed goes back only by its operator's word (`POST /admin/epochs/back`), as to
- any older epoch, and that refuses the remake: it drops the new epoch, as a node
- comes back from changes the others refuse (below), what its users signed there goes
- to the quarantine, to be signed again in the epoch it is back in, and the heal
- doesn't move it again. Meanwhile neither epoch decides what takes nodes of more than
- two thirds of the voters: each side's proposals wait, and a node moves on by word
- (`POST /admin/epochs/follow`, or back).
-
-The malicious choose when a split starts, by when they show the last record, and when
-the count crosses, by when they write their own carry records; not that the honest go
-back and forth, nor whether they follow, which takes nodes of honest voters. An epoch
-the honest nodes stay in, its voters' remake votes spent, moves on by word, not by
-votes.
+what it holds). Two remakes of one epoch both committed are no such thing: every node
+goes to the one with the lower ID (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
@@ -1713,14 +1652,7 @@ takes along those of the nodes that carry for a user it holds.
* **What an operator says**, on its own node and nowhere else, each shown where the
node waits on it (`GET /admin/epochs`, the dashboard):
* `POST /admin/epochs/rejoin`, naming an epoch's ID: go there, where no peer keeps
- the epochs between (Coming back after remakes).
- * `POST /admin/epochs/choose`, naming an epoch's ID: which, where two remakes of the
- epoch it left are both decided, or its walk through the archives ends elsewhere
- than its peers are.
- * `POST /admin/epochs/follow`, naming a decided remake's proposal: follow it now, for
- a node that waits past `remakeAge` (Partitions).
- * `POST /admin/epochs/back`, naming the epoch: go back to it, refusing the remake
- that left it; what its users signed since goes to the quarantine (Partitions).
+ the epochs between, or keeps them back (Coming back after remakes).
* `POST /admin/fork`, naming a fork's proposal and its base (Going apart).
* `POST /admin/decisions/refuse`, naming a proposal; `GET` and `PUT /admin/bounds`
(Refusing a decision).
@@ -1744,12 +1676,12 @@ at the change's dependencies alone.
**Promise 2.** Whether a change is valid depends on the change and its history; its
hash covers both. So honest nodes agree on every change, hold the same valid changes
once each has what the other has, and Automerge gives the same document for the same
-changes. Resolving is a function of the changes. Everything it reads
-is fixed by hashes: a statement's place is what it says it saw, a witness's word is
-its change's history, and a proposal is decided by its records' histories. A node's
-clock, and the order things reached it in, enter only into what its own node writes
-(its stamps, taking a proposal up, the base it takes), never into what it reads from
-the document. What must hold for this, and doesn't everywhere today:
+changes. Resolving is a function of the changes. Everything it reads is fixed by
+hashes: a statement's place is what it says it saw, a witness's word is its change's
+history, and a proposal is decided by its records' histories. A node's clock, and the
+order things reached it in, enter only into what its own node writes (its stamps,
+taking a proposal up, its acks, and as a coordinator the base), never into what it
+reads from the document. What must hold for this, and doesn't everywhere today:
* the root change given, never learned;
* no window without a policy (it is in the genesis change), and no syncing under a
@@ -1775,13 +1707,14 @@ the document. What must hold for this, and doesn't everywhere today:
**Promise 3.** A value counts only with an envelope whose signature checks against a
key that step 2 gives its user for the change that carries it. A key is a user's only
by statements signed with keys above it, up to its creation, signed by its creator,
-and so on up to a root, in the root every node was given; or by a decision, which
-is promise 7's. A node that carries doesn't sign in the user's place: the envelope
-names its swarm, epoch, path, user and user ID *(checked for swarm, path and user:
+and so on up to a root, in the root every node was given; or by a decision, which is
+promise 7's. A node that carries doesn't sign in the user's place: the envelope names
+its swarm, epoch, path, user and user ID *(checked for swarm, path and user:
`access::envelope::check`)*, so it counts nowhere else and for nobody else. A name is
held by a claim so signed, by a rule, or by a decision. Across a remake: every node
-builds the snapshot from changes it judged, so the snapshot holds only what counted,
-and what is carried over is signed as it was.
+builds the snapshot from changes it judged, so the snapshot holds only what counted or
+could, as envelopes with their signatures, and what is carried over is signed as it
+was.
**Promise 4.** Steps 3 and 4 name a holder only where exactly one claim remains.
@@ -1834,11 +1767,9 @@ a write is refused only by what its own history holds, and counts from the start
* *None that honest voters didn't vote for.* A record is valid only with votes for its
proposal in its history by more than 2n/3 of V, none released there: more than n/3
- of them honest voters'. (A remake's record needs none: a remake is decided only with
- votes for it, naming its base, by more than 2n/3 of V beside its records.) And a
- proposal is decided only with records that count for more than 2n/3 of V, for more
- than n/3 of them written by honest nodes, each while it held that many votes,
- running by its clock.
+ of them honest voters'. And a proposal is decided only with records that count for
+ more than 2n/3 of V, for more than n/3 of them written by honest nodes, each while
+ it held that many votes, running by its clock.
* *Not from the past.* So votes crafted later, or kept back until they ran out, bring
no honest node to take anything up, and the nodes of fewer than a third decide
nothing.
@@ -1867,22 +1798,8 @@ a write is refused only by what its own history holds, and counts from the start
with two stamps of one node that far apart: one of them honest, whose clock went
that far, and which held the thing so all the while. Fewer than a third, stamping
as they like, show nothing; and a node counts for one voter.
-* *A remake changes nothing.* The snapshot is a function of the base, which every node
- holds and judged itself. An honest voter's node takes up no base that leaves out
- what it held `baseAge` before, unless records of it count for a third of V, an
- honest one among them; and it records the ID it built: a remake is decided for one
- ID. What a node holds beyond the base it carries over itself, by its carry record,
- so what any honest node held comes along. And a voter's vote names its base, once an
- epoch: two bases are both decided only where more than a third of the voters signed
- for both.
* *Nobody is moved.* A node refuses any decision by its operator's word or bounds, and
- follows a fork by its operator's word alone; going back refuses the remake. A node
- that waits by `remakeAge` follows once the new epoch's carry records count for more
- than a third of V, a node for one voter, as each stood where written: one at least
- an honest voter's node that took the remake up in time. Fewer than a third, writing
- records as they like, move nobody, and nobody goes back but by its operator's word:
- so every honest node that waits ends where the honest that followed are, once they
- are enough.
+ follows a fork by its operator's word alone.
* *With other fractions.* Write d for `fractions.decide` and s for `fractions.seen`.
A decision no honest voter voted for takes d of the voters malicious. Two
proposals of one matter both decided, with nobody changing their mind, take more
@@ -1890,6 +1807,16 @@ a write is refused only by what its own history holds, and counts from the start
for two sides of a partition. What was seen for long holds against fewer than s
of the voters.
+**A remake changes nothing** (promise 2). The snapshot is a function of the base,
+which every node holds and judged itself, and holds whatever can still count: the next
+epoch resolves at its root as the base did, and nothing it leaves out could have
+counted again (For good, under Cuts). What a node holds beyond the base comes along
+with what it held of it, by its carry record, whatever base the coordinator chose: an
+honest node witnesses there as its changes would have. Lengths of time go on from the
+stamps the snapshot lists. So a remake from any base, by any node, at any time, moves
+nothing that counts; and of two, every node goes to the one with the lower ID, which
+counts nobody's nodes.
+
**Unvouching** takes away no more than its signer could have kept from seeing: what
the unvouched user signed stays if a node of the unvoucher or of a root committed a
change that has it in its history and not the unvouch. Those changes are taken back
@@ -2013,34 +1940,25 @@ far as the roots' nodes' witness.
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. A voter's one vote an epoch for a
- remake, never released, leaves nothing to undo; what it costs instead is said under
- what is not promised.
-* **One base a node and epoch**, the first it takes up. Alone, a voter is counted
- through any node of its, and a coordinator handing two bases to two nodes of each
- voter has both decided. Beside the votes, it strands voters: two remakes proposed at
- once, or a base handed first to nodes back from away, split the nodes, and a voter
- whose nodes took up one base votes for no other, so the epoch's remakes end with
- nobody malicious. The voter's own vote names the base, and a node takes up every
- base that passes. **Nor a base refused for good by nodes that saw it late**: an
- ordinary partition at the base would end the epoch's remakes. A base a third took up
- every node takes up, however old.
* **Saying what was held by the order of a node's first changes** after a remake: an
order says one thing, and what a node held of a claim, an unvouch and a value are
three. The node states them.
* **Every node writing again all it holds** after a remake, before taking anything:
each envelope since the base would come once for every node that held it, a
- month's statements times the nodes after a remake decided late. The nodes witness
+ month's statements times the nodes after a remake from an old base. The nodes witness
by digest, and the envelopes come once.
-* **An envelope of the epoch before taken from anyone, all the next epoch**: what a
- user signed and never sent, whoever got it could hand in, with a number of its
- choosing, and a value long replaced could come back over what the user wrote
- since. Only what a carry record names comes (which a node holding it can still
- see to), its numbers order only what is carried over, and a value of the new
- epoch has the last word.
+* **Remakes the voters decide**: a remake would be one more decision, with a base every
+ node checks, votes naming that base, a time after which nodes no longer follow,
+ and a heal for the split that time makes. A remake that changes nothing needs none
+ of it: any base serves, and the nodes remake as the document grows, as any swarm
+ does.
+* **Following the epoch most nodes are on**, as a swarm that isn't federated does
+ where two remakes of one epoch were committed: a party runs as many nodes as it
+ likes. The lower ID counts nobody.
+* **A remake that makes final what its base holds**, a cut reaching no further back:
+ how far a cut reaches would depend on when the swarm last remade, and remakes come
+ as the document grows. What stopped counting for good is what was seen so for
+ `final`, remake or not.
* **The epoch for those who refuse built wherever a proposal says it was signed**:
its signer would choose what refusing costs, up to a whole epoch carried over.
Nobody takes up a proposal that says it saw less than its node held a window
@@ -2069,9 +1987,9 @@ far as the roots' nodes' witness.
| Write or delete any user data | Only envelopes, of users it carries for; nothing plain, nothing deleted from a register |
| Write as any user | An envelope needs the user's key |
| Edit the member and user registries | Its own member entry, of a shape and a size; users come and go by statements, which only add |
-| Forge votes, commit a remake alone | Votes are users', signed; a decision takes two thirds of the voters, and every node judges the records; every node builds the snapshot itself |
+| Forge votes, commit a remake alone | Votes are users', signed; a decision takes two thirds of the voters, and every node judges the records. A remake it commits alone changes nothing that counts: every node builds the snapshot itself, and carries over what it holds |
| Make the swarm forget peers | A forget record of another's node is refused; whom a node talks to is its own |
-| Advertise an epoch a rejoining node follows | A node follows a remake it sees decided, or an epoch its operator gave it |
+| Advertise an epoch a rejoining node follows | A node follows a remake it sees committed, or an epoch its operator gave it |
| Be a joining node's first sync | Judged from the root change on, by the policy in it |
| Say it is ready, be a catch-up source | Still believed: it can hold changes back, not add any. A joiner syncs with the others after |
| Sign a token every node takes | Taken by the nodes whose operators named it |
@@ -2110,17 +2028,17 @@ know, takes tokens and logins by key as its operator says, writes no sessions in
document, keeps its writer over a clean stop, stamps as often as the policy says,
keeps its seeds and its user's other nodes as neighbours, keeps the document of an
epoch it left on disk and answers for it, keeps when it received each change (for
-`baseAge` and `window`, over a restart), keeps a quarantine on disk that holds
-envelopes, commits its carry record after a remake and writes again what the epoch
-lacks, takes no remake but one its voters decided, rejoins no epoch because peers
-advertise it, and refuses what its bounds say. For every swarm: the wire's version,
-with a handshake that says which epochs its node keeps, and a node that speaks the
-wire version before its own 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, a carry record, a party (for a budget), refusing a
-decision, bounds, the numbers.
+`window`, over a restart), keeps a quarantine on disk that holds envelopes, commits
+its carry record after a remake and writes again what the epoch lacks, takes compact
+remakes only, by `remakeChanges` or `remakeWriters`, and of two the lower ID, 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, a carry record,
+a party (for a budget), refusing a decision, bounds, the numbers.
## Continuum changing under a swarm
@@ -2138,10 +2056,9 @@ author remembered to say. So the design goes by what nodes compute:
prove that two nodes resolve differently, signed by both, at the first input where
they do: it shows (`GET /peers`, the dashboard) long before a remake would have sent
them to two epochs.
-* **A remake is taken up by its result.** A voter's node builds the snapshot from the
- base before it takes the remake up, and records the ID of the epoch it got. The
- remake is decided for the ID that the nodes of two thirds of the voters got. A
- node that got another stays where it is, and says so.
+* **A remake is followed by its result.** A node follows a committed remake only where
+ the snapshot it builds from the base has the ID the remake was committed for. A node
+ that gets another stays where it is, and says so.
* **A node checks itself before it writes.** Started with a version it didn't run
before, a node judges and resolves again what it holds *(docs: a node told that
policies disagree does so today)*, and compares with the stamps it holds of the
@@ -2225,7 +2142,7 @@ Unvouching:
| 22 | Unvouches a user it didn't vouch for; a root unvouches the users the root change holds, or those a root before it created | Refuse the first. What is the seats' is taken back once every root unvouched it: one root puts nobody out, where there are several | 3 | unit: `only_the_voucher_unvouches`, `the_seats_take_back_together` |
| 23 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and nothing else: who votes is the voters' word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` |
| 24 | Unvouches saying it saw little, to undo what the user did since | What its own nodes or a root's had seen of the user stays | as said under Unvouching | unit: `an_unvouch_undoes_nothing_seen` |
-| 25 | The unvouched user signs on, saying it saw nothing of the unvouch, or across a partition | Hold it as part of another's history only; it doesn't count; after healing every node finds the same | 2, 3 | unit: `past_an_unvouch`; sim: `an_unvouch_across_a_partition` |
+| 25 | The unvouched user signs on, saying it saw nothing of the unvouch, or across a partition | Hold it as part of another's history only; it doesn't count; once the partition is over every node finds the same | 2, 3 | unit: `past_an_unvouch`; sim: `an_unvouch_across_a_partition` |
| 26 | A user is unvouched: what of those it brought in, and its names? | One that another vouched for stays in, without doing anything. The others are out from the same point; a vouch after brings them back whole. Their names wait | 4 | unit: `a_second_line_keeps_it`, `those_it_brought_in`, `a_vouch_brings_back` |
| 27 | An unvouched user's nodes keep sending | Refused as peers; nothing taken from them | 6 | sim: `nothing_from_an_unvouched_node` |
| 28 | 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` |
@@ -2280,7 +2197,7 @@ Keys:
| 62 | 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` |
| 63 | 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` |
| 64 | Cuts its own key off early to take back a vouch or a release | It is taken back, but for what is final; a vouch as by its signer's unvouch, from where the retirement was signed: without a second vouch the user is out, its names waiting until it is gone or a vouch comes | not promised | unit: `a_second_vouch_stands` |
-| 65 | 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` |
+| 65 | A key is retired on one side of a partition while it signs on the other | Once the partition is over, every node leaves out the same | 2 | sim: `a_cut_across_a_partition` |
| 66 | 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:
@@ -2290,17 +2207,17 @@ Decisions and remakes:
| 67 | Forges a vote; votes as a user that isn't a voter, or one that is gone | Refuse | 7 | unit, decisions: `a_vote_is_a_voters` |
| 68 | Brings in many users to vote, also while a list's votes run | They vote only if a decided list names them, which those who voted saw | 7 | unit: `who_votes` |
| 69 | A list of voters with the many users one user brought in; users put out between the votes and the decision, to shrink the list | The voters see the list, by IDs, before they vote for it, and propose one of their own instead. Nothing after the proposal changes it | 7 | unit: `voters_by_a_decision`, `a_list_is_fixed_when_signed` |
-| 70 | Records taking a proposal up without the votes, or with released ones | Refuse: every node judges a record against the votes in its history. A remake's record needs none: a remake is decided only by votes naming its base | 7 | unit: `a_record_needs_the_votes` |
+| 70 | Records taking a proposal up without the votes, or with released ones | Refuse: every node judges a record against the votes in its history. | 7 | unit: `a_record_needs_the_votes` |
| 71 | Carries for many voters that have no node, and records with votes that ran out | Taken: nobody but the recording node reads a vote's end. A voter without a node is the party that carries for it, for a record; what is seen for long counts that node once | not promised | unit: `a_record_counts_for_its_voters`; argued (Decisions) |
| 72 | Carries for a third of the voters, and keeps its records back: every decision waits, and comes on its day | The voters name another node, which records for them; their votes count meanwhile. A voter carried by nodes of two parties never waits for one. How many each node carries for shows | not promised | sim: `a_carrier_keeps_back` |
-| 73 | 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. A remake's votes don't run out, and count when they come | 7 | unit: `taken_up_while_the_votes_run`; sim: `a_decision_from_the_past` |
-| 74 | 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 a remake's | not promised | unit: `nothing_lower_is_taken_up`; sim: `decided_late` |
+| 73 | 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` |
+| 74 | 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` |
| 75 | 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` |
| 76 | 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` |
| 77 | 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` |
| 78 | 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) |
| 79 | 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` |
-| 80 | 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; a remake's names its base and runs while the epoch lasts | 7 | unit: `a_vote_runs_a_window` |
+| 80 | 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` |
| 81 | A decision lowers a limit; a user signs on saying it saw nothing of the decision. Or a decision lowers a limit for a day, and raises it again. Or it sets a number that makes no sense | Valid as written, and resolved by the limit that holds: what is past it doesn't count. Names claimed in sight of what fell past it are their claimants' for good. The number has the result it has | 6; not promised | unit: `a_lowered_limit_leaves_out_the_last` |
| 82 | Opens proposals without end | Refuse past `limits.proposals` | 6 | unit: `limits_on_proposals` |
| 83 | 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` |
@@ -2309,11 +2226,11 @@ Decisions and remakes:
| 86 | 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` |
| 87 | 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` |
| 88 | 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` |
-| 89 | Names a base for a remake that leaves out what the swarm holds | No honest voter's node takes it up, unless records of it count for a third of the voters, an honest one among them | 7 | sim: `a_stale_base_is_not_taken_up` |
-| 90 | A remake's coordinator names two bases, each to one of two nodes of every voter | A record counts for a voter only where its vote names the record's base, and a voter signs one such vote an epoch: one base is decided, or none, and the coordinator shows | 7 | sim: `two_bases_one_remake` |
-| 91 | 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` |
+| 89 | Runs most of the alive nodes: commits remakes from bases of its choosing, as often as it may; serves a snapshot of its own | Nothing that counts changes: every node builds the snapshot itself, carries over what it holds beyond the base, and follows a remake only once its base holds `remakeChanges` changes or `remakeWriters` writers. Each costs every node a snapshot | 2; not promised (how often) | sim: `every_node_builds_the_snapshot`, `remakes_no_sooner_than_the_changes` |
+| 90 | As a remake's coordinator, commits a base that leaves out a claim settled minutes before, and holds its accomplice's rival | The nodes that held the claim carry it over with what they held of it: a root's node's carry record has the rival late against it, as its change would have | 5 | sim: `a_base_that_leaves_out` |
+| 91 | Commits a remake of another kind (`replace`, `import`, `strict`), with content of its own | No node follows it: a federated swarm compacts only | 3 | unit: `compaction_only` |
| 92 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | A root's node named the real claim in its carry record, before it took anything in the new epoch: the pretender's claim is late against it | 5 | unit: `a_carry_record_witnesses`; sim: `a_pretender_after_a_remake` |
-| 93 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Refuse what no carry record names. A node that holds such an envelope can still name it in its own record: then a value carried over has no word against one its user signed in the new epoch, and a claim is late against what a root's node's record named | 3 | unit: `only_what_a_carry_record_names`, `the_new_epoch_has_the_last_word` |
+| 93 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Taken from any node, as within an epoch: a value carried over has no word against one its user signed in the new epoch, and is left out where another carried over replaces it; a claim is late against what a root's node's record named; a number orders only among what is carried over | 3 | unit: `carried_over_from_any_node`, `the_new_epoch_has_the_last_word` |
| 94 | Signs after the switch, as of the epoch before, statements and a proposal with numbers of its choosing | Carried over comes after what the snapshot holds and before what the new epoch signs: such a number orders only its signer's statements among what is carried over, and the proposal outranks none of the new epoch | 6, 7 | unit: `carried_over_in_between` |
| 95 | Writes a carry record naming what it likes, or several, or one of its own after taking from peers | One a node and epoch. What it names is its node's word, as a change of that node would have been: a contest where it is a root's or the claimant's, no more | 5 | unit: `one_carry_record_a_node` |
| 96 | Unvouched a user, then has a node of its own stamp, weeks later, a change that has the user's claim and not the unvouch, to bring the claim back over one made in sight of it | Whether the claim stood is read where the later one was signed, with the witnesses there: one made after brings nothing back. A root's node doing so makes the two contest, in the open | 5 | unit: `a_witness_after_the_fact` |
@@ -2324,63 +2241,56 @@ Decisions and remakes:
| 101 | A root cuts off the key it created users with, from before the creations, to take their names, final ones too, where only the roots create users; or a thief of a root's key gives a moved-in user first keys | A root's creation another root's node had seen stays the claim of the name, and its first keys: a turned root takes back only what the other roots hadn't seen, never a settled or final name. A thief's creation made out of their sight falls; one made in it the voters undo | 5; not promised | unit: `a_roots_creation_outlasts_its_cut_where_another_root_saw_it` |
| 102 | A root's node, beside a thief, commits with a fresh writer on heads without the retirement a change holding what the thief's sock signed, to keep it in past the cut | A root's node witnesses past a cut, as against an unvouch: the sock stays in by it, in the open, shown with the root (`GET /registry/users/<name>`). An accomplice's vouch keeps it in too | not promised | unit: `a_cut_has_its_signers_witnesses` |
| 103 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several carried over to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
-| 104 | 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` |
+| 104 | Signs a claim "in the epoch before" of a name the snapshot holds | It is late against the snapshot's claim where that was settled at the base, or where a node of its side had that standing; else the two contest, as claims out of each other's sight do | 5 | unit: `carried_over_against_the_snapshot` |
| 105 | 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` |
-| 106 | Keeps the last record of a remake back, and shows it a month later | Every node goes to that base. Its carry record names what it holds and what it held of it (who saw what first, decisions since), and each envelope comes once. A key rotated since keeps what its retirement lists. What a third of the voters' nodes held as gone, final or dropped stays so; other lengths start anew | not promised | sim: `a_remake_decided_late`; unit: `a_retirement_lists_what_it_keeps` |
-| 107 | Has voters vote for a second remake of an epoch, beside one that hangs | A voter signs one remake's vote an epoch, never released: two bases are both decided only where more than a third of the voters signed for both. No node that switched moves again by itself | 7 | sim: `one_remake_vote_an_epoch` |
-| 108 | A partition at the base: the nodes of a third of the voters take it up, the rest see it after they held more than it has | Every node takes up a base whose records count for a third of the voters, however old, and the remake is decided | 7 | sim: `a_base_seen_late` |
-| 109 | Proposes a remake beside another voter's; or hands its base first to nodes back from away, or one an hour old that such a node takes up, so that the nodes take up one base and no other | A node takes up every base that passes, one record a proposal. A client offers a vote only for a base whose records count for more than two thirds of the voters, which every node takes up, and shows the other remakes under way: a vote goes to a base every voter's node can take up. Only the votes keep two bases from both being decided | 7 | sim: `two_remakes_proposed_at_once` |
-| 110 | Proposes a twin of a remake under way, or as its coordinator names two bases to two nodes of each voter, so that honest votes split and the epoch's remakes end | Clients offer a vote for one of the remakes that name the same voters and roots (most votes, then the lowest digest), and none for a proposal whose coordinator named two bases. Honest voters signing within the same minutes can still be split | 7; not promised | sim: `a_twin_remake_gets_no_votes` |
-| 111 | Votes for a remake with the others, keeps its node's record back once they changed their minds, and shows it when it likes | Those who voted for the remake vote for no other in the epoch: it comes on the day its last record does. A node follows a remake at once only within `remakeAge` of taking its base up; past it, once the new epoch's carry records count for more than a third of the voters. Voters who split between two remakes end the epoch's remakes, and those left go apart | not promised | sim: `a_remake_held_by_its_last_record` |
-| 112 | Holds its node's record of a remake back, and shows it when some honest nodes are past `remakeAge` from taking the base up and some aren't | Those within it follow, those past it wait, and both sides see it. Once the new epoch's carry records count for more than a third of the voters every node that waits follows; until then those that followed stay, or go back by their operators' word, their users' writes there quarantined to be signed again. A remake shown long after its time is followed by the malicious alone | not promised; healed | sim: `a_remake_between_the_bounds_heals`, `a_remake_long_past_its_time` |
-| 113 | Holds its own carry records back, or takes them back by stopping its node with a cut, or carries for honest voters without nodes, to steer whether a split heals forward or back, and when | The heal counts a node for one voter, each record as it stood where written; nobody goes back but by its operator's word. The malicious choose when a split starts, not whether the honest follow nor that they go back and forth | not promised; 7 | sim: `a_heal_the_malicious_cant_steer` |
-| 114 | Shows a remake long after its time, to sweep the nodes that carry for no voter into an epoch with the malicious voters' nodes alone | Every node takes a base up and counts `remakeAge` from then; past it, a node of no voter waits for the heal as any node does | 7 | sim: `a_late_remake_takes_no_node_of_no_voter` |
-| 115 | Lets a split stay, the honest that followed sent back by their operators, then writes its own carry records so the count crosses, for what the users signed again to come along twice | Going back refuses the remake: the heal doesn't move such a node again, and what its users signed again stays in the epoch it went back to | 4, 7 | sim: `going_back_refuses_the_remake` |
-| 116 | 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` |
-| 117 | Tells a node that was away of an epoch that isn't the swarm's | The node rejoins no epoch that peers advertise: it finishes the old one from archives and builds the next itself, or takes the ID its operator gave | 1 | sim: `away_over_a_remake`, `back_by_an_id` |
-| 118 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `carried_over_one_epoch_only` |
-| 119 | A version builds another snapshot from a remake's base | Its node records another ID. The remake is decided for the ID two thirds got; the node stays, and says so | 7 | sim: `a_remake_by_its_result` |
-| 120 | A decision on the roots names its proposer the only root, or leaves a root out; the root left out signs on as one, and its node witnesses on | The voters see whom a proposal names before they vote for it. A root is one where the decision naming it holds, read where each thing it did was done: what it signs after it is left out is an ordinary user's, its node's changes after witness as no root's, and it is out unless someone vouches for it | 7 | unit: `roots_by_a_decision`, `a_root_where_it_is_one` |
-| 121 | With the keys of two thirds of voters since replaced, stolen later, makes up a decision of then; or a list of voters of its own, with the number of the one that replaced them and a lower digest | What voters that others replaced decide counts only in sight of the proposal that replaced them: the first decides nothing. The second holds only until the list it would replace is final: no decision of its matter proposed out of sight of a final one holds | 7; not promised before final | unit: `the_voters_before`, `a_final_decision` |
-| 122 | Two thirds of the voters turn on the rest | They name the roots and who votes, remake, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) |
-| 123 | Offers a statement signed on the other side of a fork | Refuse: it names its epoch | 3 | unit: `signed_for_its_user_id_and_epoch` |
-| 124 | A fork naming its proposer the only voter and root | A node follows only by its operator's word, which names the proposal; what that says shows | 7 | sim: `a_fork_by_choice` |
-| 125 | A decision breaks a node's bounds: the voters let one of them decide for all | The node refuses it and moves to the epoch built without it, the same for every node that refuses, with what it held: they go on together | 7 | unit: `bounds_on_the_numbers`; sim: `those_who_refuse_meet` |
-| 126 | Proposes saying it saw only the epoch's root, so that those who refuse carry the whole epoch over | No honest node takes up a proposal that says it saw less than the node held a window before: it isn't decided | 7 | unit: `a_proposal_says_it_saw_enough` |
-| 127 | Says it refuses a decision, or hands out the ID of an epoch without it, to draw nodes there | A node goes there by its own bounds or its operator's word only | 1 | unit: `refusing_is_ones_own` |
+| 106 | Commits a remake from a base a month old | Every node goes there, and its carry record names what it holds beyond the base and what it held of it (who saw what first, decisions since); each envelope comes once. A key retired since keeps what its list names. Lengths of time go on from the stamps the snapshot lists, each node's record saying what it saw broken | 2 | sim: `a_remake_from_an_old_base`; unit: `a_retirement_lists_what_it_keeps` |
+| 107 | Commits a second remake of an epoch beside another, its ID ground lower; or many | Every node goes to the one with the lower ID that it builds, carrying over what it holds, envelopes of the other among them: nothing is lost, and no count of nodes decides. Each costs every node a snapshot, lowest ID first, until one comes out | 2; not promised (how often) | sim: `two_remakes_go_to_the_lower` |
+| 108 | A thief's statements are in the base of a remake | They are as they were: the snapshot holds them with their signatures, and a cut set after takes them back as it would have. A remake makes nothing final | 3 | unit: `a_cut_reaches_across_a_remake` |
+| 109 | Releases a user's claim with a stolen key, and an accomplice claims; the user cuts the key off two months later | What was seen given up for `final` has stopped counting for good: the release stands, as the accomplice's claim does, final by then. A remake or none changes nothing of it | not promised (protection from a stolen key) | unit: `stopped_counting_for_good` |
+| 110 | 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` |
+| 111 | 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` |
+| 112 | A version builds another snapshot from a remake's base | Its node gets another ID than the remake was committed for, stays, and says so: two IDs for one base show | 2 | sim: `a_remake_by_its_result` |
+| 113 | A decision on the roots names its proposer the only root, or leaves a root out; the root left out signs on as one, and its node witnesses on | The voters see whom a proposal names before they vote for it. A root is one where the decision naming it holds, read where each thing it did was done: what it signs after it is left out is an ordinary user's, its node's changes after witness as no root's, and it is out unless someone vouches for it | 7 | unit: `roots_by_a_decision`, `a_root_where_it_is_one` |
+| 114 | With the keys of two thirds of voters since replaced, stolen later, makes up a decision of then; or a list of voters of its own, with the number of the one that replaced them and a lower digest | What voters that others replaced decide counts only in sight of the proposal that replaced them: the first decides nothing. The second holds only until the list it would replace is final: no decision of its matter proposed out of sight of a final one holds | 7; not promised before final | unit: `the_voters_before`, `a_final_decision` |
+| 115 | Two thirds of the voters turn on the rest | They name the roots and who votes, remake, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) |
+| 116 | 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` |
+| 117 | 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` |
+| 118 | 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` |
+| 119 | Proposes saying it saw only the epoch's root, so that those who refuse carry the whole epoch over | No honest node takes up a proposal that says it saw less than the node held a window before: it isn't decided | 7 | unit: `a_proposal_says_it_saw_enough` |
+| 120 | 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 |
|---|---|---|---|---|
-| 128 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
-| 129 | Forks its node's actor | The nodes that took each split; one offered both holds proof and refuses the node; a side drops by its operator's choice | not promised | sim: `a_forked_actor_is_proven`, `a_side_drops_a_fork` |
-| 130 | Holds changes back, or passes on some | They come by other nodes; a joiner caught up with it syncs on | 6 | sim: `withheld_changes_arrive` |
-| 131 | Places its nodes around a victim by choosing their keys | The victim's node keeps its seeds and its user's other nodes as neighbours; a claim not settled for long shows. It costs time, not names | 5, 6 | sim: `around_a_victim` |
-| 132 | Hands a joining node another root change, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
-| 133 | Signs a token for any user with its node's key | Taken only by a node whose operator named the signing node | 3 | unit: `a_token_of_ones_party` |
-| 134 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` |
-| 135 | Lies in its member entry (ready, reached, stable); publishes a short window there to make every node stamp hourly; writes an entry of any size | Sync and trees bend; nothing gets in that way. How often nodes stamp is the policy's; an entry has a shape and a size, or the change is refused | 6 | unit: `an_entry_has_a_shape`, `stamps_by_the_policy`; argued (Reaching the others) |
-| 136 | Sends envelopes that don't check, without end | Refuse each (a signature costs about 30 µs to check *(docs)*); the node is refused as a whole after the first of its own | 6 | sim: `a_refused_node_costs_little` |
-| 137 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` |
-| 138 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` |
-| 139 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_the_user_an_entry_names_beside_others` |
-| 140 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` |
-| 141 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` |
-| 142 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` |
-| 143 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it: nothing bounds a change's operations | not promised (a bound on what an epoch's document costs) | argued |
-| 144 | Crafts a change Automerge won't take, or that writes in an object nowhere to be found | Refuse *(checked: the rules refuse the second today)*; only the message that brought it fails | 1 | unit: `a_change_writing_nowhere` |
-| 145 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, operations numbered against its dependencies', a gap in its actor's changes, an operation named that is elsewhere or outside its history, an operation Automerge's transactions never write (an element written over naming the one inserted after it, an insert that replaces, a deletion or an increment inserted, a deletion named as replaced), a table written into, a value written at a mark's begin | Refuse before Automerge sees it, by the change and its own history alone: applied, such a change makes a node panic, save a document that doesn't load, or part from nodes it reached in another order | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `a_gap_in_an_actors_changes_is_refused`, `operations_named_at_the_wrong_place_are_refused`, `operations_outside_a_changes_history_are_refused`, `only_what_transactions_write_passes`, `only_what_holds_a_value_is_replaced`, `no_table`, `no_mark`, `what_passes_leaves_automerge_sound`, `a_batch_is_checked_against_itself`, `a_change_refused_after_its_check_stands_in_for_nothing` |
+| 121 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
+| 122 | 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` |
+| 123 | 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` |
+| 124 | 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` |
+| 125 | Hands a joining node another root change, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
+| 126 | 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` |
+| 127 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` |
+| 128 | 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) |
+| 129 | 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` |
+| 130 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` |
+| 131 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` |
+| 132 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_the_user_an_entry_names_beside_others` |
+| 133 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` |
+| 134 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` |
+| 135 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` |
+| 136 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it: nothing bounds a change's operations | not promised (a bound on what an epoch's document costs) | argued |
+| 137 | 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` |
+| 138 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, operations numbered against its dependencies', a gap in its actor's changes, an operation named that is elsewhere or outside its history, an operation Automerge's transactions never write (an element written over naming the one inserted after it, an insert that replaces, a deletion or an increment inserted, a deletion named as replaced), a table written into, a value written at a mark's begin | Refuse before Automerge sees it, by the change and its own history alone: applied, such a change makes a node panic, save a document that doesn't load, or part from nodes it reached in another order | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `a_gap_in_an_actors_changes_is_refused`, `operations_named_at_the_wrong_place_are_refused`, `operations_outside_a_changes_history_are_refused`, `only_what_transactions_write_passes`, `only_what_holds_a_value_is_replaced`, `no_table`, `no_mark`, `what_passes_leaves_automerge_sound`, `a_batch_is_checked_against_itself`, `a_change_refused_after_its_check_stands_in_for_nothing` |
Rules, and the swarm as it is:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 146 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from the nodes of more than two thirds of the other voters at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` |
-| 147 | Stamps a wrong digest, to keep the nodes that upgrade from writing; one of three voters does | A node stops only where it differs from the nodes of more than two thirds of the other voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody`, `of_three_voters` |
-| 148 | A policy version a node doesn't know: in the root, or decided | It doesn't sync, and takes no such proposal up: a policy is decided only with two thirds of the voters' nodes knowing it | 1 | unit: `no_sync_under_an_unknown_policy`, `an_unknown_policy_isnt_taken_up` |
-| 149 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
-| 150 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
+| 139 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from the nodes of more than two thirds of the other voters at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` |
+| 140 | Stamps a wrong digest, to keep the nodes that upgrade from writing; one of three voters does | A node stops only where it differs from the nodes of more than two thirds of the other voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody`, `of_three_voters` |
+| 141 | 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` |
+| 142 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
+| 143 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
## The registry on it
```
@@ -2436,7 +2346,7 @@ it trusts for that.
## Stages
Each leaves the system working, and is a few patches with its tests, which leave
-their vectors. At every stage the existing tests pass untouched (150).
+their vectors. At every stage the existing tests pass untouched (143).
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
@@ -2444,7 +2354,7 @@ their vectors. At every stage the existing tests pass untouched (150).
yet, takes tokens and logins by key as its operator says, keeps ended sessions to
itself, stamps as the policy says, and writes a member entry of the policy's shape
and size. What the genesis change sets for the swarm as a whole is read from the
- policy. Tests: 132 to 135, 142, 145, 148, 150, and the policy's existing tests
+ policy. Tests: 125 to 128, 135, 138, 141, 143, and the policy's existing tests
under a policy from the genesis change. Those of a crafted change, and of a crafted
committer, exist already: screening refuses those in every swarm.
2. **Statements.** The users' registers (`create`, `key`, `node`, `vouch`, `release`);
@@ -2466,12 +2376,12 @@ their vectors. At every stage the existing tests pass untouched (150).
read from the stamps; final. `GET /registry/claims` with what makes a claim late;
values marked in `GET /store`. A node keeps its seeds and its user's other nodes as
neighbours, leaves out members that name another epoch, and shows a claim long
- unsettled. Tests: 7, 9, 10, 13, 15, 16, 36, 38, 39, 43 to 46, 49, 52, 53, 128, 130,
- 131.
+ unsettled. Tests: 7, 9, 10, 13, 15, 16, 36, 38, 39, 43 to 46, 49, 52, 53, 121, 123,
+ 124.
6. **Cuts.** `retire` and the keys above, a node that stops, a cut never reaching its
own statement, what a cut takes back, what doesn't count left out, the value before
- read again, the client listing what stopped counting. Tests: 14, 20, 47, 48, 51, 54
- to 58, 65, 66.
+ read again, what stopped counting for good, the client listing what stopped
+ counting. Tests: 14, 20, 47, 48, 51, 54 to 58, 65, 66, 109.
7. **Unvouching.** `unvouch`, a vouch or a creation cut off as by an 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
@@ -2480,7 +2390,7 @@ their vectors. At every stage the existing tests pass untouched (150).
8. **Coming back.** The drop an operator asks for, a forked actor proven and shown
with what the roots' nodes hold, the budget and the share per party, the writers
counted per user, for the one a node's member entry names, a node keeping its
- writer over a clean stop. Tests: 129, 136 to 141, 143, 144.
+ writer over a clean stop. Tests: 122, 129 to 134, 136, 137.
9. **The registry.** Import, export, and a federated swarm of the simulations with the
registry's kinds and a few hundred hosts. From here it can be tried: users, hosts,
names, a root that settles, names that become final. It isn't to be relied on yet.
@@ -2494,30 +2404,28 @@ their vectors. At every stage the existing tests pass untouched (150).
contested name is, a name the rules leave to the voters; a decision of the voters
before counted only in sight of the list that replaced them; a final decision. The
simulations start from a root change naming several voters. Tests: 23, 63, 67 to
- 86, 120, 121, 149.
+ 86, 113, 114, 142.
11. **Versions.** The digest with every stamp, a node checking itself before it
writes; for every swarm, a node that speaks the wire version before its own, and a
- handshake that says which epochs its node keeps. Tests: 146, 147.
-12. **Remakes.** The proposal with its coordinator; the base, every one a node finds
- holding what it held `baseAge` before, however old where records count for a
- third, one record a proposal, judged without votes; votes naming it, one a voter
- and epoch, offered by clients only where records count for two thirds; taking a
- remake up by its result, the snapshot every node builds, what it leaves out and
- what can't be written again; carrying over: every node's carry record, then each
- envelope once, in its order, with the new epoch's word last on values; a
- retirement's list as its cut; decisions and what was seen for long, over a remake;
- what becomes final. A node keeping the epochs it left on disk, peers answering for
- them and saying which; a node walking them, or rejoining by an ID its operator
- gave, and by none that peers advertise. Tests: 89 to 95, 103 to 110, 116 to 119.
+ handshake that says which epochs its node keeps. Tests: 139, 140.
+12. **Remakes.** Compaction only; a node proposing and acking by `remakeChanges` and
+ `remakeWriters`, and following such a remake only, by its result; the snapshot
+ every node builds, with whatever can still count and how far each length of time
+ ran, what it leaves out and what can't be written again; carrying over: every
+ node's carry record, then each envelope from any node, in its order, with the new
+ epoch's word last on values, and a claim carried over against the snapshot's; a
+ retirement's list as its cut; decisions over a remake; lengths of time going on;
+ two remakes of an epoch, to the lower ID. A node keeping the epochs it left on
+ disk, peers answering for them and saying which; a node walking them, or rejoining
+ by an ID its operator gave, and by none that peers advertise. Tests: 89 to 95, 103
+ to 108, 110 to 112.
13. **The policy by a decision.** The policy as a matter, a node that doesn't know it,
what it no longer covers: shown aside, taken away by its user only, dropped after
- a time, moved at a remake. Tests: 30, 50, 87, 88, 148.
+ a time, moved at a remake. Tests: 30, 50, 87, 88, 141.
14. **Going apart, and refusing.** A fork followed by an operator's word, with who
- votes and who the roots are on its side. Refusing a decision: a node's bounds, how
- late a remake it follows at once (`remakeAge`) and how the split heals, a waiting
- node's fetch of the new epoch's carry records, going back as refusing, the epoch
- without the decision, what a node takes along. Tests: 111 to 115, 122 to 127. From
- here it can be relied on: the rules change by decisions.
+ 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: 115 to 120. From here
+ it can be relied on: the rules change by decisions.
## What was checked, and what is assumed
@@ -2563,8 +2471,8 @@ Checked in the code:
(`document::meta`, `swarm::members`); the genesis change doesn't set them. A
federated node reads them from its configuration alone (`--libp2p-relays` exists).
* 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.
+ what it holds beyond it (`remake::snapshot`, `remake::delta`). A federated node tells it
+ from the changes beyond the base, which it holds.
Checked upstream, in Automerge 0.12: a second change at an actor's number is refused,
with the whole batch it came in (`DuplicateSeqNumber`); the change that made an
@@ -2591,13 +2499,14 @@ Measured upstream, with Automerge 0.12.0 alone, on histories of small writes to
with the same values in the same order whichever came first.
From the docs: a node under an unknown policy receives without judging; every node
-takes a token any member signed, and lets in by key any user of the registry; where
-a refused member shows; the cost of checking a signature; a node keeps the documents
-of epochs it left for a while (`archiveRetention`: 2 epochs, 30 days), and every node
-builds a remake's snapshot itself today; a node that was away rejoins the epoch
-enough ready members advertise, and has its own writes carried over within the
-replay window, the rest quarantined; a member votes for one remake of its epoch at a
-time, and a compaction's base is fixed by the coordinator when it commits.
+takes a token any member signed, and lets in by key any user of the registry; where a
+refused member shows; the cost of checking a signature; a node keeps the documents of
+epochs it left for a while (`archiveRetention`: 2 epochs, 30 days), and every node
+builds a remake's snapshot itself today; a coordinator fixes the electorate in its
+proposal; a node that was away rejoins the epoch enough ready members advertise, and
+has its own writes carried over within the replay window, the rest quarantined; a
+member votes for one remake of its epoch at a time, and a compaction's base is fixed
+by the coordinator when it commits.
Assumed, to be shown as it is built:
@@ -2625,8 +2534,9 @@ Assumed, to be shown as it is built:
* A node can commit its carry record (the digests of what it holds beyond a base, and
what it held of it) before it takes anything from a peer, at a registry's size.
* What was seen for long is kept as the node goes, per voter's node and per thing
- watched (a user out, a claim holding its name, a thing uncovered), costs little,
- and is built again from the changes at a start.
+ watched (a user out, a claim holding its name, a decision holding, a thing
+ uncovered), costs little, and is built again from the changes and the snapshot at
+ a start; the snapshot holds it at a registry's size.
* The digest of the registry as it resolves is cheap enough to make with every stamp
at a registry's size, and to make at another node's stamp now and then.
* A version can speak the wire version before its own.