| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A second binary, behind the `federation` feature: a party's client, which signs its
party's events with one of its keys (`--key`, an OpenSSH private key file), puts them
through a node's API (`--node`, its user and password in the URL, or `--token`), and
keeps its party's record (`--record`), by which it votes, written before a vote is
sent (`federation::party`, run by `continuum::party`):
* `init PARTY` begins a record of `PARTY` on the version current now;
* `write PATH VALUE`, `keys KEY...`, `nodes NODE...` and `propose FILE` sign events on
the node's heads, recorded, and put;
* `vote PROPOSAL yes|no` votes on the proposal of that hash on the current version, by
the record: with a `true`, the votes on its party's earlier proposal, from the node,
checked, kept as the nays that freed it;
* `again` signs again, of the latest event it signed at each place, its key set and its
node list, what the node refuses as not above its checkpoint's heads, or as built on
one it refuses;
* `twice RECORD...` names, from the records of parties' clients, a party that voted
twice.
The feature brings reqwest along, the client's HTTP.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A party's client signs its party's events with one of its keys, read from an OpenSSH
private key file, unencrypted (`client::signing_key`), and keeps its party's record
(`client::Record`): the votes it cast, each as signed, with the versions they are on;
with each `true`, the votes that made its party's earlier proposal on that version dead,
as signed; and the events it signed besides. The record begins on the version current
then, and casts nothing on it; it is written whole or not at all.
It votes by its record, never by what a node shows (`docs/federation.md`, Changing the
policy): never `true` and `false` on one proposal, nor the same twice; a `true` only for
a version changing the current one, and one at a time, its earlier `true` on a proposal
the votes given make dead, each checked from itself and its version, which it keeps. It
signs again, of the latest event it signed at each place, its key set and its node list,
what a move refused (`Record::again`). And over the records parties' clients keep, it
names a party that voted twice (`client::voted_twice`): its `true` and `false` on one
proposal, or its `true` on two of one version, neither dead by all the votes.
JSON is taken as the federation takes it (`client::json`).
|
| |
|
|
|
|
| |
`GET /events/refused` says of each refusal its kind (`none`, `judged`, `builtOn`, with
the event it builds on, or `notAbove`), apart from why: a party's client signs again
what a move refused, which it tells so.
|
| |
|
|
|
|
|
| |
A party's client votes by the record it keeps, and keeps the votes that made its party's
earlier proposal dead; it reads them from a node, and checks them itself, as each is
signed. `GET /events/counts` names the proposals on the current version, by their hash,
each with the events proposing it and the votes on it, by ID (`State::ballots`).
|
| |
|
|
|
|
|
| |
What makes a signed event (`event::signed`) and what each does (`write`, `keys`, `nodes`,
`proposal`, `vote`), and a version event (`event::version_event`), move from the tests'
harness into `federation::event`, for a party's client to make them as the tests do: the
harness makes its events through them.
|
| |
|
|
|
|
|
|
| |
Everything the node is moves from the binary into a library (`src/lib.rs`), so that
other binaries can use it: a party's client of a federation next. The node's binary
(`src/main.rs`) runs it (`continuum::run`), which wires things together as `main` did.
The library's doc comments are prose, not examples to test (`doctest = false`); its
tests are the library's, as `cargo quick` and `cargo sim` run them.
|
| |
|
|
|
| |
The store's design says that the store at a node's API is built: putting events, and
showing what counts, what it refused, and its operator's drops.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Behind the `federation` feature, a node of a swarm holding a store has, at its API
(`docs/store.md`, Members; `docs/openapi.yaml`, Events):
* `GET /events`: its store's ID, its checkpoint's, its heads, and how many events it took
after its checkpoint;
* `POST /events`: an event put, whoever signed it, offered to the store and written into
the document at its ID unless the store refuses it (`422`, with why): taken, held, or
waiting for what it builds on;
* `GET /events/{id}`: an event the store holds, or its checkpoint, as its bytes;
* `GET /events/counts`: what counts as the store reads now: the current version, each
party's keys and nodes, the values at places, the members;
* `GET /events/refused`: what the store refused, its own refusals apart, its operator's
drops, and the rest with why;
* `POST /admin/events/drop` and `/admin/events/allow`: its operator has it drop what it
took, and take it back.
The events' endpoints are anyone's this node lets in, as the store's are; dropping and
taking back need `write` on `_continuum`, as what operators do. While a node holds no
store, they answer `404`.
|
| |
|
|
|
|
|
|
|
|
| |
A node's store takes events from elsewhere than its document too: one put at its API is
offered to it first (`Holding::offer`), to say what became of it. Its operator has it
drop events it took after its checkpoint, with everything built on them
(`Holding::drop_taken`), and takes them back (`Holding::allow`), the document's events
then offered again (`docs/store.md`, A node's own). After each, what the node keeps of
its own is written to its file where it changed, and the members are as the store reads
now.
|
| |
|
|
|
|
| |
The store's design says that members by the fold are built: each node of the party its
operator names, syncing with members only, its neighbours among them and some among its
own party's and those its operator names, and taking no token another node issued.
|
| |
|
|
|
|
|
|
| |
At its API, a node of a swarm holding a store takes no token another node issued
(`docs/store.md`, Members): whoever its operator lets in may use it, and its operator
lets in nobody through another node. A token every node of a swarm takes would let
whoever another operator let in in here too. `token::issued_here` refuses such a token
(`ElsewhereIssued`), behind the `federation` feature.
|
| |
|
|
|
|
|
|
|
|
| |
named
A node of a swarm holding a store keeps some of its neighbours among the members of its
own party and of the parties its operator names (`--store-neighbour-parties`), so that a
party listing many nodes can't be all of them (`docs/store.md`, Members): its neighbours
by the shared graph among those members alone, each as its entry names it, which every
node of its party computes alike, with those among all members.
|
| |
|
|
|
|
|
| |
In a swarm holding a store, a node computes its neighbours, and the member list's graph
writers' trees are built on, from the members its store names, each with the party its
entry names (`docs/store.md`, Members): the other entries name nodes it doesn't sync
with. While it holds no store, from every entry, as elsewhere.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A node of a swarm holding a store syncs with its members only (`docs/store.md`,
Members): the nodes its store names, each with the party its handshakes name, as the
store reads now. A handshake from any other goes unanswered, and what the node had with
it ends, as with a banned node; so does what it had with a member at its next message,
once the store names it no more (`swarm::peer::members`). The party a handshake names is
kept with the peer. While a node holds no store yet, joining, it can't tell, and takes
everyone of its swarm: its seeds, which take it only where its party lists it.
A node says whether it is a member itself, as its store reads, when that changes.
|
| |
|
|
|
|
|
| |
In a swarm holding a store, a node's handshakes name the party it is of (`docs/store.md`,
Members), so that a peer tells whether it is a member before its entry reaches it: HELLO
and HELLO_REPLY carry `party`, as `--store-party` says, None elsewhere and without the
`federation` feature. Wire format version 52.
|
| |
|
|
|
|
|
|
| |
The fold names the members, each with its group: for the federation, the nodes each
party lists, each as its party's (`docs/store.md`, Members). A node keeps them as its
store reads now, apart from the store, so that whoever asks doesn't wait while the store
takes events: `Holding::member` tells whether a node, of a party, is one, or that the
node holds no store and can't tell; `Holding::members` lists them.
|
| |
|
|
|
|
|
| |
In a swarm holding a store, a node's own entry names the party it is of (`docs/store.md`,
Members): `party`, as `--store-party` says, written at registration and kept so when it
changes over a restart, as the alias is; `members::party` reads it. Behind the
`federation` feature.
|
| |
|
|
|
|
|
| |
A secret its members share keeps out nobody, and its parties say who syncs; nor does a
user write its protocol data, as a node writes none but its own (`docs/store.md`,
Members). So `--store-root` and `--store-id` refuse `--swarm-key-file`,
`--swarm-key-create` and `--protocol-writers`.
|
| |
|
|
|
|
|
|
|
| |
A node's group is its operator's, in its configuration (`docs/store.md`, Members):
`--store-party NAME`, which `--store-root` and `--store-id` need, a party's name as the
federation spells one. The node keeps it with its store (`Holding::party`), to name it
in its entry and its handshakes. The options of a node of a swarm holding a store
(`--store-file`, `--store-checkpoint`, `--store-party`) set without either are refused
together.
|
| |
|
|
|
|
| |
Automerge writes no put of the value a key holds already, so the test can't have a node
write one: it judges such a change made by hand, a put of the event's bytes at its key,
at a history holding it.
|
| |
|
|
|
|
|
|
| |
The store's design says what of it is built: on Automerge, a swarm holding a store,
started from its root or joined by its ID, each change judged by what it writes, and
the store a node reads from its document, by what is its own, putting again what the
document lacks, from a pinned checkpoint where there is one; not yet members by the fold,
the store at the API, and remakes, of which such a swarm takes no records or acks.
|
| |
|
|
|
|
|
|
|
|
|
| |
Once a store moved to a checkpoint, a node reading it from the root could take what was
grown anew from the root since, by keys of versions long replaced: so its operator pins
the checkpoint (`--store-checkpoint`, by its ID), and the node reads its store from
there whenever it starts (`docs/store.md`, Pinned checkpoints). It finds it in its
document: at heads a proposal's version names, built from their history read from the
root, as any node builds the checkpoint it moves to (`Store::checkpoint_at`), the one
whose ID is pinned. Until the document holds it, the node holds no store, and says so
once.
|
| |
|
|
|
|
| |
`checkpoint_at` builds the checkpoint at heads the store took, its bytes and the events it
keeps, as the store does moving to a checkpoint, which now goes through it: so a node
can build one at heads it reads, to tell whether it is the one its operator pins.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A node puts again, in changes of its own, every event its store holds that its
document lacks (`docs/store.md`, What the store takes from the document): one it took
from the document it left, at a drop or a rejoin, or from a change it refused, whose
events the store is offered as from anywhere (`Holding::look`, every few seconds, of the
changes screening keeps). It puts each after its dependencies, what the checkpoint keeps
first, then what the store took after it in the order taken, up to 1 MiB of events a
change, once a wait of its own has passed: random, between one and ten seconds after
the document first lacked them, so that not every node puts the same, and none another
node put meanwhile, as it looks again when it writes.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A node of a swarm holding a store holds the store, read from its document
(`docs/store.md`, What the store takes from the document): `federation::held`. Whenever
the document changes, a worker reads the events it holds that the store wasn't offered
from it, under the document's lock, and offers them to the store without it, each taken
as from anywhere: once its dependencies are held, judged at its history. Another
document (a drop, a rejoin) is read as it comes, the store going on.
The node reads its store anew from its document whenever it starts, from the root, by
what is its own of it: the events it refused by what it took before, and those its
operator had it drop, which it keeps in a file (`--store-file`), written whenever that
changes, so that a store read anew in another order refuses what it refused before. A
file that doesn't read stops the node from starting; without one, a restart may take
what it refused.
|
| |
|
|
|
|
|
|
| |
A node refuses some events by what it took before (the federation: a second version
changing the one it reads), and others as its operator has it drop them; read anew, its
store would take events in another order, and so maybe the other one. `own` lists what
the store refused so, and `refusing` has a store starting out refuse them from the
start, whatever order the events then come in (`docs/store.md`, A node's own).
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Behind the `federation` feature, two options:
* `--store-root PATH` starts a swarm holding a store, or goes on with one, from the
store's root, as bytes in the file, which the federation must take as a root. With no
document to start on, the node builds the genesis change from it, as every node given
the root does, and is ready at once; a document to start on must be of the root's
swarm.
* `--store-id ID` joins one through seeds by its ID, the root's SHA-256 in hex. An empty
document of the first epoch takes as its root only that store's genesis change, built
again from the root it holds (`document::events::is_genesis`), whatever peers name:
the root pin doesn't wait for seeds, nor is disputed.
Either names the swarm the node joins, which a state file must remember too, and can't
be combined with the other, nor with what makes a new swarm's first change (`--genesis`,
`--bootstrap-users`, `--bootstrap-keys`, `--bootstrap-policy`, `--remake`,
`--genesis-root`). The root is read as a file of its own kind (`store`), counted among
the node's files.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Every node judges a change of a swarm holding a store by what it writes, at its history
(`docs/store.md`, What a change writes), in place of rules by path: `access::holding`.
It writes events, each at `_continuum/events/<ID>` the bytes whose SHA-256 that is, no
larger than the fold allows (the federation's 256 KiB), at a key held nowhere at the
change's history; and its node's entry, with the member list's map where there is none.
Everything else is refused, as closed: values outside `_continuum`, the policy, the
swarm's ID, users, bans, the topology, remakes and their acks. Nothing deletes or
replaces an event. A change names its node; the genesis change's writer names none, so
no change under it is taken but the genesis change.
In a swarm not holding a store, a change writing a policy naming one is refused: a swarm
holds a store from its genesis change, or not at all.
The inspector tells a put of bytes apart (`Action::PutBytes`), with the bytes, for the
events' check. All of it behind the `federation` feature.
|
| |
|
|
|
|
|
|
|
|
|
| |
`{"version": 2, "store": "<fold>"}` at the policy's place is a swarm holding a store of
that fold (`docs/store.md`, What the document holds). Behind the `federation` feature, a
node reads it as `Policy::Store` where the fold is one it has (`federation`) and nothing
else is written there: changes judged, and signed, as required; not strict. Its `store`
reads so only where it is a string, as `values` of a strict policy. A swarm holds a store
from its genesis change only, so `--bootstrap-policy` takes none.
Without the feature, a policy of version 2 stays one the node doesn't know.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
A swarm holding a store starts from its genesis change, which every node builds from the
store's root alike, so that one root makes one swarm (`docs/store.md`, What the document
holds). `document::events` builds it: it writes the policy naming the fold, the swarm's
ID (the root's) and the root at its ID, as bytes, each making the maps on its way, under
the writer made of the root ID's first 16 bytes, at time 0, without a message.
`is_genesis` tells such a change by building it again from the root it holds; `started`
is a document holding it, written to under a writer of its own; `ids` and `bytes` read
the events a document holds at `_continuum/events`. All of it behind the `federation`
feature.
|
| |
|
|
|
|
| |
A swarm holding a store names its fold in its policy, `{"version": 2, "store":
"<fold>"}`: the fold's name is a constant of the fold, `federation` for the federation and
`test` for the fold made for the store's tests.
|
| |
|
|
|
| |
store.md, federation.md and federation-tests.md say what of them is built: beside the
store held in memory, the federation as its fold, with its byte formats, and their tests.
|
| |
|
|
|
|
|
|
|
|
|
| |
Vectors (`docs/federation-tests.md`, Fixed bytes) for a write and its signature and ID,
the first version of two parties and its hash, the root it makes and its ID, a version
event, an event whose value holds names that UTF-16 units sort otherwise than bytes, and
events at federation 1's sizes and just past them: 256 KiB, 32 segments of 255 bytes,
64 nodes, integers to 2⁵³. Each value was computed apart from this code, by a script of
its own: JCS by hand, Ed25519 by another library, and the signature's blob as OpenSSH's
`PROTOCOL.sshsig` describes it, as `ssh-keygen -Y sign` makes it. Checking one against
`ssh-keygen` itself is left to whoever has it at hand.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Three to five parties write in their namespaces, change their key sets and node lists,
propose versions and checkpoints on what they last caught up with, vote, and write the
versions that pass; honest ones back one proposal on a version, an adversary votes as it
likes and signs as another party with its own key, or where it may not write. Over such
histories:
* the store judges every event, and reads, as the model does, offered the same events in
the same order, with an adversary and without;
* what builds on a refused event is refused;
* honest parties read the same whatever order the events come in, checkpoints and all;
* after a checkpoint, what the store took the model takes, reading the whole history but
for what the store refused as not above it, and the two read the same; the version
naming the checkpoint is taken;
* every version a store takes was backed by two thirds of the parties of the version it
changes, in its history;
* without a party voting twice, no two versions change one.
A failing history is cut down and printed.
|
| |
|
|
|
|
|
|
|
|
|
| |
The model (`docs/federation-tests.md`, The harness) reads the federation as
`docs/federation.md` says, as plainly as it can: every event judged at its history read
anew from the root, the version current there the highest-numbered written one, keys,
key sets, node lists, votes, passing and dead, version events and the heads a version
may name each worked out from that history alone; a node's own, the first of two
versions changing one; and what counts read from everything taken. It keeps nothing but
which events it took, and makes no checkpoint: slow and short, it is what the fold is
checked against. A test takes it through a version passing, offered last event first.
|
| |
|
|
|
|
| |
Two of the strings `json_written_otherwise_is_none` takes for none, an escaped U+2028
and an escaped `A`, stood in the file as the characters themselves, which JCS writes as
they are: the test took them for none, and they read. They are built as escapes now.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Each row of `docs/federation.md`'s attacks marked unit that the fold and the store in
memory answer has its test, named by its row (`federation_attack_12`), with events made
for it by the harness: keys that aren't their party's, bytes that are none, events of
another federation or a fork, writes where a party held or holds no place, key sets
and keys stolen or dropped, votes cast twice, at once, split, or at a history from
before, versions that are none or written again late, two versions changing one in
every order, forks and roots, checkpoints, events not above their heads, and heads a
version may not name.
`every_row_marked_unit_has_its_test` reads the table and this file, and checks that
every row marked unit has its test, or waits for a later stage (what a node, a party's
client or a tool does, and what a node tells of a fork), and that no test names a row
that isn't there.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
`Federation` is the store's fold for `docs/federation.md`. The state judging reads is
the state of an event's history, which the store builds from the checkpoint and that
history alone; so the version current there is the state's, the highest-numbered one
written, and a history holding two versions of one number is refused.
* A signed event's party is a party of the version current at its history. A write is
signed by a key among its party's (those of its key set that counts, else those its
version names) where a rule gives its party the place; a key set, node list,
proposal or vote by a key its version names.
* A vote is on the version current at its history, for a proposal proposed on it; a
`true` only where every other proposal its party backs on that version is dead.
Passing and dead go by the parties voting each way, a party with both counting for
both.
* A version event writes a proposal on the version current at its history, passed
there, which is a version changing that one; one naming a checkpoint names heads
after the current checkpoint at which it is current too, none in another's history,
the version event above them. A node keeps a version event only where it changes the
version it reads, or writes one it took.
* What counts is read by the current version: of each party's writes at a place it may
write, signed by a key among its party's, and of its key sets and node lists written
under a version at least their `since`, the latest, then the lowest ID. A checkpoint
keeps what counts at its heads and the proposals and votes on the version current
there; a fork's root what counts at its heads by its version; the members are the
nodes each party's node list names.
Tests take a federation through writes, a key set, a proposal passing, one yes at a
time, two versions changing one, a checkpoint and a node starting from it, and a fork.
Events are read with their signature checked once, where they are judged.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
`Event::read` reads an event and says what makes one none (`docs/federation.md`,
Events): bytes that aren't the JCS of the JSON they read as, larger than 256 KiB, with
no dependency or more than 64, not ascending, or a field missing or more; and of a
signed event, a party that is no party's name, a key or signature that doesn't read back
to itself or doesn't hold, a path, key set, node list or vote spelled otherwise. A
proposal is taken whatever it holds, named by its hash; a version event names a hash.
`Checkpoint` reads and writes `{"at", "keeps", "version"}`, a root among them, which is
no event.
The tests' harness (`docs/federation-tests.md`, The harness) makes parties with keys
from seeds, signs each kind of event as the design says, and spells versions out.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
`Version::read` reads a version by itself, and says what makes one none
(`docs/federation.md`, The policy): a field missing or more but for `checkpoint`,
another federation, a number and `changes` that don't go together, keys and node lists
not of the same parties, a party's name, its keys (one to 16, spelled as keys, none twice
in the version) and its node list (up to 64 node IDs, none twice), checkpoint heads, and
rules (a literal first segment and not `_continuum`, `{party}` once at most, `**` last
only, a writer that is a party of it, `"{party}"` where the path holds `{party}`, or
`false`; a path as a write's may be). `changes_validly` asks whether it changes another:
one past its number, its hash, and each `since` its own number or the other's with the
same keys, or node list. `writer` gives who writes at a path, by the first rule that
matches; `only_moves_on` whether it changes nothing but its number, what it changes and
its checkpoint.
|
| |
|
|
|
|
|
|
|
|
|
| |
A key is `ssh-ed25519`, one space, and its base64, padded and canonical, with no
comment, its 32 bytes an Ed25519 public key; a node ID is spelled as continuum spells
it, its key one too; and a signature is the SSHSIG blob of version 1 for the namespace
`continuum-federation`, hashed with `sha512`, its reserved field empty, its key the
event's, in base64, padded and canonical, unarmored, checked by continuum's strict
check (`access::sshsig::verify_blob`) and read back to what `ssh-keygen` writes around
it. `keys::sign` makes one, for clients and tests. Tests show each spelled otherwise
taken for none.
|
| |
|
|
|
|
|
|
|
|
| |
An event is the JCS encoding (RFC 8785) of a JSON object, within the limits federation 1
sets (`docs/federation.md`, Events). `jcs::read` gives the JSON bytes are only where
they are what JCS writes of it: names sorted by their UTF-16 units and none twice, no
whitespace, strings escaped as ECMAScript escapes them; and, beyond JCS, numbers only
integers from −2⁵³ to 2⁵³, strings only whole Unicode characters, and objects and
arrays nested up to 32 deep. Tests show what reads back and what is none, the order of
names by UTF-16 units that byte order gets wrong, and the depth.
|
| |
|
|
|
|
|
| |
The test of forks expected an event the store it came from took after the fork's heads
to wait in the fork, but it builds on the put the fork's root keeps, which comes before
the root, its one head: the fork refuses it, not above its root, as it refuses an event
built on what a checkpoint keeps.
|
| |
|
|
|
|
|
|
| |
JCS sorts an object's names by their UTF-16 units, not by their bytes or code points;
the two differ for a name from U+E000 to U+FFFF beside one beyond U+FFFF. Names in
events and versions are ASCII, but a value is any JSON: a vector with two such names
catches a builder sorting strings as Rust does. And vectors at federation 1's sizes and
just past them.
|
| |
|
|
|
|
|
|
|
| |
An event went into the change being filled unless it would take the events there past
1 MiB: whether a change was full hung on the next event. A node taking the root on its
operator's word couldn't tell a change cut short, sent first, from the one every node
builds, and by then held a change of that writer and number. Events now go into a change
until their bytes there reach 1 MiB, and the next event begins the next change: each
change is judged whole by itself.
|
| |
|
|
|
|
|
|
| |
remake
The text said such documents "remake apart". By its own rules they come together at the
next remake: one side decides, and the other rejoins its epoch; both decide, and of the
two, the lower ID.
|
| |
|
|
|
|
|
| |
The row said nodes rejoin the lower epoch once a generation. Each lower ID found moves
them again: of N tries, about ln N are lower than all before, so a billion hashes of a
small snapshot make some twenty rejoins of the whole swarm, each node putting again what
the new document lacks. Still slow, not wrong.
|
| |
|
|
|
|
|
|
|
| |
in one
An epoch's first change, which a rejoining node can't build, holds a snapshot: a made-up
one may hold another policy, or what is closed in a swarm holding a store (users, bans,
the topology). A node follows no epoch whose policy isn't its swarm's, and reads
nothing closed in one it follows.
|
| |
|
|
|
|
|
|
| |
The document took any bytes that hash to their key, while the fold bounds events (the
federation: 256 KiB): one change of any size filled every node until the next remake.
How large an event may be is a question of the change alone, so the fold says it
(`Fold::LARGEST`), the document refuses a change putting a larger one, and the store
takes such bytes as none.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
restart
A pin is an ID, and the document holds a checkpoint only at `_continuum/checkpoint`,
which only an epoch's first change writes: a swarm that moved once, and never remade,
held its checkpoint nowhere, and a node told to join from a pinned one had nothing to
start from. It finds it in its document: the document's checkpoint, or one the fold
moves to at the history of an event the document holds, built at those heads from what
the document holds, as the ID fixes its bytes whoever builds them. The document holds
what that takes, as no remake leaves it out.
And across a restart, a node reads its store from its document anew, from the
document's checkpoint or the one its operator pinned, by its own refusals and drops,
which it keeps in its file; it keeps nothing else of the store.
|