aboutsummaryrefslogtreecommitdiffstats
path: root/docs/federation.md
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-14 12:17:21 +0000
committertv <tv@krebsco.de>2026-11-14 12:17:21 +0000
commitbc85717d37a3ebd22bad967aedcda89ce363d244 (patch)
treeea4feaf6b76120c0ed09d5f93e47ccc790af7d64 /docs/federation.md
parent33db2b33d6f39b14c8ceee9c1f3cc6b8ff378d11 (diff)
federation: envelopes name their branch, and floors keep out what a remake left out
An envelope was taken in the epoch it named and the next, and the root change listed what its base held of the epoch before. So a base that left out what the epoch before had brought in sent those envelopes two epochs back, and refused them; one user able to commit a remake on its own changes erased whatever was signed after the last snapshot it didn't choose. And a node away over two remakes lost what its user had signed meanwhile. An envelope now names the branch it was signed on: a fork or a refusal begins one, the genesis change the first, and a remake stays on the branch it is on. An envelope signed in an earlier epoch of its branch is brought along from however many remakes back. What a remake left out is kept out by floors instead of the list: for each user and kind of statement, the highest number a remake left out; a statement brought along at or below it, and not in the snapshot, is refused. Every statement is numbered, votes too. A value needs no floor: one left out names in its `prev` a value that is gone. What a floor refuses goes to the quarantine of the node that holds it, at a switch as on coming back.
Diffstat (limited to 'docs/federation.md')
-rw-r--r--docs/federation.md166
1 files changed, 84 insertions, 82 deletions
diff --git a/docs/federation.md b/docs/federation.md
index b9c3ef3..98085d3 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -315,10 +315,10 @@ grows. A statement is signed by one user and says one thing:
to carry it, is a statement's place wherever its place matters: carried a second
time, by anyone, it is where it was. Its envelope names the register as its path.
* **A user is its creation.** The `create` statement's digest is the **user ID**, and
- every envelope the user signs names it, with the swarm and the epoch it was signed
- in. Two creations of one name are two users with two sets of keys; which has the
- name is decided below, and a key listed in both signs for the one its envelope
- names.
+ every envelope the user signs names it, with the swarm and the branch it was signed
+ on (Going apart). Two creations of one name are two users with two sets of keys;
+ which has the name is decided below, and a key listed in both signs for the one its
+ envelope names.
* **A user the root change holds** has the ID given there, and needs no creation. It
may be there without keys (a registry moved in from elsewhere): then it is in, has
its name and what the root change holds in its name, and nobody signs for it, until
@@ -1121,22 +1121,23 @@ envelopes are brought along as they were signed (below).
* 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 digests of the envelopes the base holds that were signed in the epoch it
- leaves.
+ * the floors (below).
* **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,
- brought along, 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.
+ values, members) and by what stopped counting within the last `final`, and by a
+ floor for each user and kind of statement; 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 comes along across any number of
+ remakes, so what a remake left out (a stolen laptop's key and node, retired long
+ since) could be handed in again. So the snapshot holds, for each user and each kind
+ of statement, a **floor**: the highest number of that user's statements of that kind
+ that this remake or one before left out. A statement brought along at or below its
+ user's floor for its kind, and not held by the snapshot, is refused. A value needs
+ none: one left out names in its `prev` a value no longer there, or replaces one it
+ doesn't name, and is refused for that (rule 7).
* **Brought along.** 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 **switch record**, every node that switches, whoever
@@ -1153,11 +1154,12 @@ envelopes are brought along as they were signed (below).
`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 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.
+ hold yet. Any node commits an envelope brought along, as it commits any (a `node`
+ statement only the node it names). One a floor refuses goes to the quarantine of the
+ node that holds it, its client listing its own user's to sign again. 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 switch 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
@@ -1197,12 +1199,12 @@ envelopes are brought along as they were signed (below).
user in: the genesis change, or the ID of a later epoch.
**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 switch 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.
+a statement a floor refuses comes no more; what only a node witnessed after the base,
+and named in no switch 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.
What a remake bounds, and what everything costs, is said below (What it costs).
@@ -1235,13 +1237,11 @@ in one of two ways:
Either way, what follows:
-* **What it holds and the swarm never got.** What was signed in the epoch just before
- the one the node arrives in is brought along: the node commits its switch record
- when it arrives, and writes again what the epoch lacks. What was
- signed further back isn't: an envelope is taken in its epoch and the next, no
- later. Its own user's go to the quarantine, and the client lists them for the
- user to sign again. A claim signed again is a new claim, after what was claimed
- since.
+* **What it holds and the swarm never got.** What it holds of its branch is brought
+ along, from however many remakes back: the node commits its switch record when it
+ arrives, and writes again what the epoch lacks. What a floor refuses goes to the
+ quarantine, and the client lists its own user's for the user to sign again. A claim
+ signed again is a new claim, after what was claimed since.
* **What it finds of its user**, as the snapshot has it. There, with its keys, nodes
and names: the node carries for it as before, and writes its member entry anew. Or
out, its names waiting. Or gone, and so not in the snapshot: then no node takes the
@@ -1314,9 +1314,11 @@ rest, or for a policy the others won't have. A fork is proposed, and binds nobod
stays in the epoch it is in, which goes on as it was.
* Both sides have the same history up to the base and the same swarm ID, and from
there different epochs. Their nodes don't sync, and leave each other out as
- neighbours. A statement signed on one side counts for nothing on the other: it
- names its epoch. What was signed in the epoch both came from counts on both, and
- a node carries for its user on a side only by writing there.
+ neighbours. A fork begins a **branch**, which its epoch's ID names (the genesis
+ change begins the first), and a remake stays on the branch it is on: a statement
+ signed on one side counts for nothing on the other, as it names its branch. What was
+ signed in the epoch both came from counts on both, and a node carries for its user
+ on a side only by writing there.
* On each side the voters are those its decisions name, the ones that went the other
way among them. A side that keeps two thirds of them decides on those who stayed. A
side with fewer decides nothing until it names its own, by a fork of its own.
@@ -1343,13 +1345,12 @@ What refusing does:
(`GET /registry/decisions`).
* **The epoch without it.** A node that refuses a decision moves to the epoch built
where its proposal was signed (at the changes the proposal says its signer saw,
- which no honest node took it up without holding all it had held `window`
- before):
- the registry as it resolves there, the policy, the voters and the roots as they
- are there, and the digest of the proposal refused, which makes it no other epoch
- and no proposal there. Every node that refuses the same decision builds the same
- epoch, whenever it does. So those who think alike meet there without arranging
- it.
+ which no honest node took it up without holding all it had held `window` before):
+ the registry as it resolves there, the policy, the voters and the roots as they are
+ there, and the digest of the proposal refused, which makes it no other epoch, begins
+ a branch of its own, and is no proposal there. Every node that refuses the same
+ decision builds the same epoch, whenever it does. So those who think alike meet
+ there without arranging it.
* **What it takes along.** As with a remake, the node brings along what it holds
beyond that base, decisions among it but the one refused. So refusing costs what
a remake costs whose base is a window older than the proposal was taken up, and
@@ -1363,13 +1364,13 @@ So every number is the swarm's to set, and each party's to bear or not. A decisi
that lets one voter decide for all is followed by those who don't mind.
This is how Bitcoin changes its rules. Nobody decides for anyone: nodes run the rules
-their operators chose. A change comes into force once enough of those who count
-signal that they run it, at a height named beforehand. Nodes that won't have it keep
-their rules, and with them their chain, the same up to there. And a transaction that
-would count on both chains is kept to one by naming its chain. Here the signalling is
-the nodes taking a proposal up, which takes knowing its policy; refusing is keeping
-one's rules; the height is the base; and the epoch in every envelope keeps a
-statement on its side.
+their operators chose. A change comes into force once enough of those who count signal
+that they run it, at a height named beforehand. Nodes that won't have it keep their
+rules, and with them their chain, the same up to there. And a transaction that would
+count on both chains is kept to one by naming its chain. Here the signalling is the
+nodes taking a proposal up, which takes knowing its policy; refusing is keeping one's
+rules; the height is the base; and the branch in every envelope keeps a statement on
+its side.
### What each payload holds
@@ -1377,12 +1378,12 @@ The fields each rule reads; a version adds none that a rule reads without a poli
saying so (Continuum changing under a swarm). Names of fields are the design's, the
encoding the first stage's.
-**Every envelope** (a statement): `swarm` (the swarm's ID), `epoch` (the epoch it is
-signed in), `path` (its register, under its own digest), `kind`, `userId` (its
-signer's ID; a `create`'s signer is the creator), `seen` (the hashes of the changes
-its signer had seen), `number` (the number of its kind among its user's statements:
-Users), `signingKey` (the public key that signs) and the signature, over all the rest.
-Beside those, by kind:
+**Every envelope** (a statement): `swarm` (the swarm's ID), `branch` (the branch it is
+signed on: Going apart), `path` (its register, under its own digest), `kind`, `userId`
+(its signer's ID; a `create`'s signer is the creator), `seen` (the hashes of the
+changes its signer had seen), `number` (the number of its kind among its user's
+statements: Users), `signingKey` (the public key that signs) and the signature, over
+all the rest. Beside those, by kind:
| Kind | Fields |
|---|---|
@@ -1397,7 +1398,7 @@ Beside those, by kind:
| `propose` | `matter`, `holds` (below), `matterNumber` (its number among its matter's proposals: Decisions) |
| `vote` | `proposal`, its digest; `ends`, when it runs out |
-**A value's envelope**: `swarm`, `epoch`, `path` (its place), `userId`, `signingKey`,
+**A value's envelope**: `swarm`, `branch`, `path` (its place), `userId`, `signingKey`,
`prev` (the digest of a value that counts at its place where it is signed, or none),
the value (or `null`, putting nothing there), and the signature. It says nothing of
what its signer saw: where a value was signed, wherever a rule asks, is the change
@@ -1455,14 +1456,14 @@ A change is valid if, in the document at its dependencies:
of a proposal, or its switch record, and the committer carries for a voter that is
out there.
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, its switch record, and what it
- writes of a remake as in every swarm (its ack; a coordinator's proposal and
+ within `limits.entry`), its own records of proposals, its switch 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 and its user's 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.
+ its branch (this one, or one this one came from), its path and its user's ID, and
+ for a statement what its signer saw (`seen`: changes in this change's history, or,
+ for one brought along, none of this epoch's) and 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 fork, its proposer's
@@ -1497,14 +1498,15 @@ A change is valid if, in the document at its dependencies:
9. `_continuum/access`, the swarm ID, the epochs, and what the root change sets for
the swarm as a whole: never.
-**What is brought along**: 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`
+**What is brought along**: an envelope signed in an epoch before this one, on its
+branch or one it came from (its `seen` names none of this epoch's changes), is held to
+less, from however many remakes back. 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 brought along. 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 brought along holds
-there, and that the root change doesn't list its digest. Whether it counts is
-resolved.
+there, and, for a statement, that it is above its user's floor for its kind or held by
+the snapshot. 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),
@@ -1733,14 +1735,14 @@ with the epoch (Automerge: writers, history).
|---|---|
| a change | its bytes, on disk and once on the wire; in memory 0.2 KB and its bytes, and 4 B for every writer of the epoch; when it was received, kept beside it |
| a writer | 4 B of heap for every change of the epoch, those before it too; a signature in every transfer of the whole history |
-| a statement | under a KiB; 32 B in the next root change's list where it was signed in the epoch before, in each retirement's list that keeps it, in each switch record that names it |
+| a statement | under a KiB; 32 B in each retirement's list that keeps it, in each switch record that names it |
| a value | its envelope, a few hundred bytes for a host; kept replaced while not stopped counting for good |
| a node | its member entry, `limits.entry` at most; a stamp each `stamp`, some 350 B; a writer a run; a record a proposal it takes up; a switch record a remake |
| a user at its limits | some 470 statements standing (keys, nodes, users created, vouches, proposals, a kind's claims), under half a MiB, and `limits.writers` writers |
| a claim | its statement; while it has a rival, what each witness had seen, kept as the node goes; until it is final, a length watched for each voter's node |
| a cut | 32 B for each statement and value it keeps |
| a root's node | a change a `witness` at most while claims reach it |
-| a remake | the snapshot built by every node, the registry gone over once; 32 B in the root change for each envelope signed in the epoch left; a switch record a node, 32 B for each envelope beyond the base it holds; each such envelope written once more; the epoch left, on disk for `archiveRetention` |
+| a remake | the snapshot built by every node, the registry gone over once; a floor for each user and kind it left something out of; a switch record a node, 32 B for each envelope beyond the base it holds; each such envelope written once more; the epoch left, on disk for `archiveRetention` |
| a signature | some 30 µs to check *(docs)* |
What bounds it:
@@ -2223,7 +2225,7 @@ More policies later are more data where a rule has a parameter, and a new rule i
continuum, with a policy of its own, where it hasn't; either way a decision.
What changes in continuum besides the rules, under the federated policy only: policy
-version 2; the envelope's payload names the user ID, the epoch, and for a statement
+version 2; the envelope's payload names the user ID, the branch, and for a statement
what its signer saw; a node is given its root change, syncs under no policy it doesn't
know, takes tokens and logins by key as its operator says, writes no sessions into the
document, keeps its writer over a clean stop, stamps as often as the policy says,
@@ -2321,7 +2323,7 @@ Statements and users:
| 2 | Puts another user's statement into a change of its own node; a `node` statement naming another node | Take the first: any node commits any user's statement, and chooses when, not what its signer saw. Refuse the second: a `node` statement only the node it names commits | 3 | unit: `any_node_commits_a_statement` |
| 3 | Commits a user's claim, lets it settle, then stops its node with a cut from before that change, for an accomplice to claim the name | A node's cut takes back what it witnessed and the writers it started, never what it carried: the claim counts as its user signed it, and its root's witness stands | 5 | unit: `a_stop_takes_back_nothing_carried` |
| 4 | Replaces or deletes a statement, or what holds the register | Refuse | 2, 3 | unit: `a_register_only_grows` |
-| 5 | Offers a statement again; or an envelope signed for another swarm, epoch, path or user ID | Nothing where it is there under its digest; refuse elsewhere | 3 | unit, exists for swarm and path: `what_an_envelope_must_be`; `signed_for_its_user_id_and_epoch` |
+| 5 | Offers a statement again; or an envelope signed for another swarm, branch, path or user ID | Nothing where it is there under its digest; refuse elsewhere | 3 | unit, exists for swarm and path: `what_an_envelope_must_be`; `signed_for_its_user_id_and_branch` |
| 6 | Commits a statement a second time, in a change with other dependencies, to move it | A statement is where it says its signer was (`seen`), whoever carries it and how often: nothing moves | 2 | unit: `a_statement_carried_twice` |
| 7 | Creates a user listing a victim's public key beside its own | The victim's envelopes name the victim's ID: they count for no other | 3 | unit: `a_key_in_two_creations` |
| 8 | A root other than the one the root change names for a moved-in user signs a `create` for it, with keys of its own, saying it saw nothing of the first | Refuse: only the root named gives a moved-in user its keys | 3 | unit: `first_keys_by_the_named_root` |
@@ -2449,18 +2451,18 @@ Decisions and remakes:
| 105 | 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` |
| 106 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several brought along to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
| 107 | 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: `brought_along_against_the_snapshot` |
-| 108 | 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` |
+| 108 | Hands in again what a remake left out: a stolen laptop's `node` and `key` statements, retired since | Refuse: its user's floor for its kind is at its number or above; a value names in its `prev` one that is gone | 3 | unit: `what_a_remake_dropped_stays_out` |
| 109 | Commits a remake from a base a month old | Every node goes there, and its switch 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` |
| 110 | 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, bringing along 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` |
| 111 | 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` |
| 112 | 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` |
| 113 | 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` |
-| 114 | 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: `brought_along_one_epoch_only` |
+| 114 | A node back after several remakes offers what its user signed epochs ago | Taken, from however many remakes back, unless its user's floor for its kind refuses it: then quarantined, for the user to sign again | 3 | unit: `brought_along_any_number_of_remakes` |
| 115 | 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` |
| 116 | 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` |
| 117 | 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` |
| 118 | Two thirds of the voters turn on the rest | They name the roots and who votes, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) |
-| 119 | 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` |
+| 119 | Offers a statement signed on the other side of a fork | Refuse: it names its branch | 3 | unit: `signed_for_its_user_id_and_branch` |
| 120 | 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` |
| 121 | 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` |
| 122 | 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` |
@@ -2567,12 +2569,12 @@ their vectors. At every stage the existing tests pass untouched (147).
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`);
- the user ID, the epoch and what its signer saw in an envelope; nodes carrying for
- users by their own word, and the rule for committers by it; nothing plain; the
- limits, and the order past them. First, the payloads: each statement's fields and
- the member entry's shape, settled, so that tests leave vectors. Resolving, step 2
- without cuts, and `GET /registry/users`. The client signs statements. Tests: 1 to
- 7, 9, 12, 13, 19, 20, 23, 36.
+ the user ID, the branch, a number for every statement and what its signer saw in an
+ envelope; nodes carrying for users by their own word, and the rule for committers
+ by it; nothing plain; the limits, and the order past them. First, the payloads:
+ each statement's fields and the member entry's shape, settled, so that tests leave
+ vectors. Resolving, step 2 without cuts, and `GET /registry/users`. The client
+ signs statements. Tests: 1 to 7, 9, 12, 13, 19, 20, 23, 36.
3. **Namespaces.** The rule, with `userSigned` below a name. Tests: 35, 37. From here
the registry runs with users and hosts, names not yet unique.
4. **Claims in sight.** Kinds, names as they are written, their characters, rules by