aboutsummaryrefslogtreecommitdiffstats
path: root/src
Commit message (Collapse)AuthorAgeFilesLines
* store: a fold names itselftv21 hours3-0/+8
| | | | | | 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.
* federation: fixed bytes of events, versions, roots and sizestv22 hours2-0/+127
| | | | | | | | | | | 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.
* federation: properties over generated federationstv22 hours2-0/+576
| | | | | | | | | | | | | | | | | | | | | 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.
* federation: the model, a second reading of the federationtv22 hours2-0/+532
| | | | | | | | | | | 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.
* federation: the JCS test asks escapes JCS doesn't write, as escapestv23 hours1-2/+4
| | | | | | 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.
* federation: a test for each attack marked unittv23 hours2-0/+1184
| | | | | | | | | | | | | | | | 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: the federation as the store's foldtv23 hours3-1/+947
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | `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.
* federation: events and checkpoints as bytes, and a harness that signs themtv23 hours3-0/+610
| | | | | | | | | | | | | | `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.
* federation: versions, their rules, and the paths they matchtv23 hours2-0/+539
| | | | | | | | | | | | | | | `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.
* federation: keys, node IDs and signatures, each spelled one waytv23 hours2-0/+148
| | | | | | | | | | | 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.
* federation: JSON written one waytv23 hours2-0/+452
| | | | | | | | | | 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.
* store: a fork refuses what the store it came from builds on what its root keepstv24 hours1-1/+2
| | | | | | | 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.
* store: the fold says how large an event may be, and the document judges by ittv24 hours3-1/+14
| | | | | | | | 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.
* federation: groups that parted come together as parties come in, not by mergestv24 hours3-61/+27
| | | | | | | | | | | | | A merge, a fork at heads of several stores, named every party's keys anew, so that a party wrote its key set again before anything a key of its set signed counted there; and kept each side's values side by side, so that a value a party replaced on one side came back where the other side's write had the lower ID. Letting the other side's parties in, by a version or a fork naming them, who sign again what they keep as a party's client signs again what a move refused, does the same with nothing new. So a fork is at heads of one store: the fold makes its root from that store's state, and the store from its own heads (`Store::fork`). Merges' rows go, those after them move up, and Roads not taken says why, with merging in place.
* store: properties over generated historiestv24 hours3-0/+444
| | | | | | | | | | | | | | | | | | | | Two to four writers, each knowing what it wrote and what was written when it last caught up with the others, write the test fold's events on one or two events they know. Eras and cuts are numbered by their history, each number written once, or, for some properties, as often as it comes. A store offered them is checked against the whole history, read from the root with nothing forgotten: * it holds the same whatever order the events come in: every order putting each after what it builds on, for up to six events; some shuffled beyond; and backwards, where every event waits until the first comes; * it judges every event as the whole history does, the store's own refusals aside; * what builds on a refused event is refused; * what it took is above its checkpoint's heads, the cut naming the checkpoint among it, and it reads as its checkpoint and what it took, and as its whole history; * a node starting from its checkpoint holds what it holds. A failing history is cut down, events taken out with what builds on them for as long as it still fails, and printed.
* store: the test fold judges a cut by the checkpoint current at its historytv24 hours1-23/+83
| | | | | | | | | | | | | | | | A cut names heads above those the latest cut of its history names, and holding that cut, or, where its history holds none after the checkpoint the state starts from, heads after that checkpoint or its own; as federation.md has a version name heads after the checkpoint current at its history, at which that one is current too. It judged them by the checkpoint the store holds, which isn't the one current at the history of a cut taken in the same offer as the cut before it, before the store moves. A cut is above its heads as store.md says, each of its dependencies one of them or above them, so that moving to them refuses none of what named them. Of a checkpoint's heads, whose history a state starting from it doesn't hold, it takes none as built on another, nor on what the checkpoint keeps: starting from a checkpoint at two heads, one of them kept, it took the other as built on it, and refused the cut naming them.
* store: what is above some heads names nothing before themtv24 hours1-0/+9
| | | | | | | | | An event above some heads has each of its dependencies among them or above them, not only them all in its history. The store holds after its checkpoint only events whose dependencies are its heads and the events after them, and so it holds every event above them: one naming an event before them as well is refused by a node that moved, and never taken by one starting from the checkpoint, which never held what it names. Tests show it for an event offered after the move and one taken before it.
* store: forks and mergestv24 hours1-0/+87
| | | | | | | | The fold makes a fork's root from the states at heads of one store, or of several, which merges them, and what makes the fork; the store gives it the states, and the events the root keeps, from the stores holding them. A node holding those heads checks a root by building it. A fork and the stores it came from take nothing of each other: what each writes after builds on what the other doesn't hold.
* store: moving to a checkpoint, and starting from a pinned onetv24 hours2-8/+235
| | | | | | | | | | | | | Once the fold names heads of a later checkpoint (events after the store's, none in another's history), the store builds the checkpoint at them, keeps what the fold keeps, forgets what came before them, and refuses every event not above them, with what waits on such an event. What it forgot is held as accounted for: brought again, it is held, and an event built on it isn't above the heads. A store starts from a checkpoint its operator pins, its events building on the heads the checkpoint was built at. A node starting from a checkpoint must judge the event that named it as every node does; the fold for the tests counts the heads of the checkpoint a state starts from as after the checkpoint current at them, so that it does.
* store: a node's own refusals, and its operator's dropstv24 hours1-0/+126
| | | | | | | | | | Where its history takes an event but the fold has the node refuse it by what it took before (the federation's second version changing one), the store refuses it as its own. An operator may have the node drop events taken after its checkpoint, with everything built on them, and refuse them from then on; what the checkpoint keeps, or holds by ID, isn't dropped, as every event after it builds on that. The operator takes either back by allowing it, and what was refused for being built on it, to be offered again. The fold for the tests shows both with its eras.
* store: a store held in memory, and a fold for its teststv24 hours3-0/+803
| | | | | | | | | | | | | | | A store starts from its root, with the events the root keeps, and holds the events taken after it. An event offered is taken once the store holds its dependencies, where it is above the store's heads (built on an event after them, or on all of them) and the fold takes it at its history: the state its history reads as, folded from the checkpoint. An event waits for what it builds on, and is taken when that comes; one built on a refused event, or whose bytes are none of the fold's, is refused, with what waits for it. The fold made for the tests judges by history (a put refused where its key is locked), reads by what counts (a key's latest put, then the lowest ID), refuses by what a node took before (two eras of one number), and moves to checkpoints (cuts), as the federation does, so that the later stages' tests have something to exercise.
* federation: the feature, and the store's foldtv24 hours3-0/+131
| | | | | | | | | | | | `federation`, a feature of its own, builds what `docs/federation.md` and `docs/store.md` design, stage by stage; without it continuum builds and behaves as it does. The aliases build with it, and `docs/development.md` says so. Its first part is the store's: an event's ID, the SHA-256 of its bytes written as 64 lower-case hex digits and read back only so, and the `Fold` trait as `docs/store.md` gives it. The trait reads a checkpoint's parts too, the heads it was built at and the events it keeps, which a node taking a pinned checkpoint needs; the design names it. Nothing uses either yet, but a test.
* screen: `Screening::of`'s doc on `of`tv29 hours1-1/+1
| | | | | `of`'s doc line sat above `policed`'s, as its first line, and `of` had none.
* screen: a test's actor named through `document`tv30 hours1-1/+1
| | | | | | The test of a value hiding the policy's place made its actor through `automerge::` outside `src/document`, which the test that Automerge stays behind `document` refuses. It names `document::ActorId`.
* screen: what is at the policy's place found in every map on the waytv31 hours2-5/+87
| | | | | | | | | | | | | | | | A node judges what it receives once anything is at the policy's place (`Screening::policed`), as a read shows it. But a read shows the newest of the values written at once at a key, merging maps only where that one is a map: a string written at `_continuum/access` beside the map holding the policy, and newer, hides it. So the policy's place read as empty, a change putting `"signed"` into the hidden policy went unjudged where it came alone, and deleting the string left a strict policy no change was refused for. Whether anything is at the policy's place is asked of every map of each key on the way to it, read or not (`store::held_anywhere`), as `store::by_seq` walks them. A swarm with nothing there is screened as before.
* screen: what reads as no policy has what is received judgedtv37 hours1-5/+47
| | | | | | | | | | | | | | | | | A node judges what it receives only once the document holds a policy, or a batch writes at a key named `policy` (`Screening::policed`); and an envelope holding `null` at the policy's place reads as none. So a change putting `"signed"` at `values` in a map beside such an envelope, writing at no key named `policy`, went unjudged where it came alone, and a later change deleting the envelope left a strict policy that no change was refused for. Nodes that took the second in one batch with others refused it, and the rest dropped it once told: apart until then, by how changes were batched. A node judges what it receives once anything is at the policy's place, whatever it reads as. A swarm with nothing there is screened as before; one whose policy's place holds what reads as none is judged by none but the rule that refuses turning strict, as a swarm without a policy is.
* state: a strict policy written where none judges, refused before it leavestv39 hours2-5/+26
| | | | | | | | | | | | | Every node refuses a change writing a strict policy where the policy isn't strict (`rules::turns_strict`), whatever the policy before. But a node judges its own changes before they leave (`judged_here`) only under a policy judging every change: in a swarm without one, a strict policy written through its API was taken there and refused by every other node, with everything the node built on it. A change that leaves a policy where there was none to judge it is judged as every node will judge it, too. A change in a swarm that has no policy after it is judged by none, as before.
* remakes: a map made on the way names no group's usertv39 hours1-10/+79
| | | | | | | | | | | | | | | Under a strict policy a group of other writes goes as, and is named for, the last change by history that touched its path, at it, below it or above it. A change writing its first entry makes the maps above it on the way, and touches them: where two users wrote their first entries below one map at once, each making it, the later change touched the other's path, and the other's write was replayed as its user's, refused by every node, quarantined. The change a group goes as is the last that wrote at its path or below it, or replaced what was at a path above it (`last_written`): one that made a map above it, finding nothing there at its history, didn't. Swarms that aren't strict don't ask.
* policy: strict only where its values is a stringtv39 hours1-31/+32
| | | | | | | | | | | | | | | The policy was read in typed JSON, so that an Automerge text spelling "signed" at its `values`, which no operation `rules::turns_strict` asks of writes, turns no swarm strict. But that read every policy anew: a setting that wasn't a string, or a text at `signatures`, made a policy no node knows in swarms that aren't strict, which read it as before. The policy is read in plain JSON again, as it was, and only its strictness asks more (`policy::of`): it reads strict only where its `values` is a string in typed JSON, an envelope read as its payload. A policy that would read strict only through a text, at `values` or holding the policy, is one no node knows. Every policy that doesn't read strict reads as it did.
* remakes: a group named for the change it goes astv42 hours1-12/+3
| | | | | | | | Under a strict policy a group of other writes goes as the last change by history that touched its path, above or below it, but was named for the last that wrote at it or below: where the last replaced a map above the path, the group went as one change and was judged as another's user's. It is named for the change it goes as now.
* config: a strict bootstrap policy found as the document reads ittv42 hours2-8/+14
| | | | | | | | A strict `--bootstrap-policy` is refused with `--remake`, but whether it was strict went by its JSON as given, where the node reads the policy as written into the document: a strict policy given as an envelope passed, and its genesis change was refused only once the node had started. Both now read it as written (`policy::as_written`).
* store: the policy's reading unmarked however it endstv42 hours1-3/+9
| | | | | | | `signs_values` marks, for its thread, that the policy is being read, so that the reading doesn't ask itself again; a panic within it left the mark, and that thread read every strict place by Automerge's order from then on. The mark is now taken off when the reading returns or unwinds.
* policy: read only as continuum writes ittv42 hours2-11/+64
| | | | | | | | | | | | | | | | | | | A swarm turns strict only at its start or through a strict remake, and a change writing a strict policy where the policy isn't strict is refused, found by its operations: `"signed"` put at the policy's `values`, or an envelope asking for it put at its place. But the policy was read in plain JSON, where an Automerge text reads as a string, and writing a text is no such operation: `{"$text": "signed"}` at `values`, through the typed API, turned a swarm strict that nothing refused, with a time before it nothing closes. The policy is read in typed JSON now (`store::read_plain_as`): what continuum writes there reads as it is, plain JSON or an envelope, and a text, a counter or bytes as itself, tagged; a setting that isn't a string makes a policy no node knows (`policy::read`), as a version it doesn't know does. So no text turns a swarm strict, and the operations `rules::turns_strict` asks of are the only ways to. A policy holding none of these reads as before.
* remakes: of one change, its other writes replayed before its linkstv44 hours1-4/+21
| | | | | | | | | | | | Under a strict policy, links and other writes go by where their change is among those replayed, and of one change the links went first. Both were judged at that change's history, without the other; a link can only take away there what the other writes relied on (a capability revoked), never give what they needed, so they go first now. A group of other writes was placed by its last change by history but named the user of its newest by clock; it names the user of the last by history now, as it goes.
* rules: a swarm turns strict only at its start or through a strict remaketv44 hours4-255/+81
| | | | | | | | | | | | | | | | | | | | | | A strict policy written into a running swarm left a time before it: changes written there, beside the turn, were refused by the nodes that took the turn first and taken by the others where they came first (a signed policy that isn't strict, among them, unseated the turn there); and a remake whose base preceded the turn had every switching node replay the turn as one of its own, each refusing the others'. A change writing a strict policy where the policy at its history isn't strict (`"signed"` at its `values`, or an envelope there asking for signed values) is now refused, in every swarm. A swarm turns strict at its start (`--bootstrap-policy`) or through a strict remake, each its epoch's first change: no change of a strict epoch is from before its policy, and the rule for the time before goes, with the walk that found the changes that turned a swarm strict and what kept them (`before_strict`, `turned_strict`, `Reads::strict_now`, `Reads::turned_now`, `store::writers`, `store::made`, `changes::in_history`). The strict swarm's simulation starts strict. access.md says so, and that a strict swarm can't move to a policy its nodes don't know by writing it.
* config: a strict swarm starts emptytv44 hours1-4/+12
| | | | | | | | | | | | `--genesis --remake` writes the content as a change of its own before the one recording the first users and `--bootstrap-policy`. With a strict policy, that content change was a time before the policy, on which any member could build a change judged by none. A strict `--bootstrap-policy` with `--remake` is now refused: a swarm strict from its start starts empty, and one started from content turns strict through a strict remake, which keeps only what an operator looked over. A policy that isn't strict starts from content as before.
* store: one reading of the policy's placetv45 hours1-48/+75
| | | | | | | | | | | | | | | | Whether values are ordered by `seq` (`signs_values`) read the policy's place itself, the first value alone and a map by Automerge's choice of each field, while the policy as judged (`policy::of`) read it through the store, which orders by `seq` only where `signs_values` says so, and merges every map there. They parted: a signed policy that isn't strict beside a newer plain one that is read as not strict for the one and strict for the other, and two maps, the newer without the field asking for signed values, the other way round. `signs_values` now asks `policy::of`, and the store orders the policy's own place by `seq` wherever any value there asks for signed values, and what is within the policy as written, so the two are one reading. Asked from within that reading, it answers false rather than ask again.
* remakes: other writes replayed with the links by historytv45 hours1-23/+111
| | | | | | | | | | | | | | | Under a strict policy, the links of the chains to signed values went in the order their changes were made, but the other writes were grouped by time, and a link went before a group only where its time wasn't later. A write built on what a link grants (a capability in an entry its manager signed, a ban lifted, a declaration) went first wherever its clock was behind the link's, was judged where it wasn't granted yet, and was quarantined, though every node had taken it. Under a strict policy the other writes now go by where the last change that wrote them is among those replayed (`between`), with the links, and keep their times for later replays. Without a strict policy there are no links, and the groups go by time as before.
* rules: the changes that turned a swarm strict found once for its headstv45 hours2-20/+58
| | | | | | | | | | | | Every change judged under a policy that isn't strict, in a strict document, walked back to the changes that turned it strict, each step reading every change the document holds. Only changes from the time before reach it in an honest swarm, but a member can send crafted ones at an old history, each costing every node a walk. The changes are now read once per walk (`store::made`), and what the walk finds is kept for the document's heads (`Reads::turned_now`), as whether its policy is strict is.
* rules: a strict swarm stays stricttv45 hours1-1/+31
| | | | | | | | | | | | | | | | | A strict policy could be written over with one that isn't, or deleted, by a user who may manage the policy. While the swarm was relaxed so, nothing was asked of the time before it turned strict: a change written beside that turn was taken, and once the swarm turned strict again, built on, a node judging that change while strict from the first turn (one back from away, a joiner) refused it, and every node it told dropped it with the second turn and everything after. Under a strict policy, the policy is now written again only as strict: an envelope there whose value isn't a strict policy, a signed `null` among them, is refused. So a strict swarm has one change that turned it, and the time before it stays closed; to leave it, start a new swarm from its content. A swarm that isn't strict writes its policy as it did.
* rules: the document's own policy read once for its headstv46 hours1-4/+19
| | | | | | | | | Every change judged under a policy that isn't strict, in every swarm, read the document's own policy to ask whether the time before a strict policy applies: in a swarm without a policy, where a change was judged for nearly nothing, a read of the policy for each. It is now read once for the document's heads and kept while the batch is judged at others (`Reads::strict_now`), read again once the document takes more.
* store: values ordered by seq as the policy a read shows saystv46 hours2-25/+86
| | | | | | | | | | | | | | | Whether values are read by `seq` went by whether any value at the policy's place asks for signed values, not by what the policy reads as. Where the place holds two, they part: a signed policy that isn't strict read before a plain one that is, or two maps, the newer not strict. Such a swarm judged as not strict and read by `seq`. Now the policy's own place is read by `seq` where any value there asks for signed values, so an older policy put back beside a strict one can't undo it; every other place is read by `seq` only where the policy that read shows is strict (`policy::read`, which `policy::of` reads with). A swarm whose policy doesn't read as strict reads every place as Automerge has it.
* remakes: a signed place already held is kept like any write that losestv46 hours1-1/+9
| | | | | | | Where the new epoch holds as high a `seq` at a signed place as the old one reads, the chain isn't replayed: it was counted as superseded and left out even with `--superseded-writes quarantine`, unlike every other write a newer one superseded. Now it goes to the quarantine then too.
* remakes: links replayed in the order their changes were madetv46 hours1-31/+143
| | | | | | | | | | | | | | | | | Under a strict policy, the links of the chains to signed values were ordered across places by their changes' timestamps. How a link is judged in the new epoch depends on what was replayed before it: a key added to a user's entry, a capability granted. A write signed with a key added a moment before, through a node whose clock is behind, went first, was refused and quarantined, though every node had taken it. The changes replayed (`between`) now come each after those it builds on, clocks deciding only between changes neither of which saw the other, then the lower hash; the links follow that order, and an envelope takes its time from the first change that wrote it there. remakes.md says so, and what becomes of a place where a link is refused. Without a strict policy there are no links, and nothing changes.
* remakes: a chain replayed to what its part of the replay ends attv46 hours1-4/+51
| | | | | | | | | | | | | A rejoin replays in two parts: what was written before it began, then what was written during it. A chain to a signed value was read to what the old document reads now, from the envelopes written within the part: a value written again during the rejoin made the first part's chain lead to an envelope that part doesn't hold, and the second part's start from one it doesn't either. Both were quarantined, and the new epoch kept the base's value. Each part's chain now leads to what the old document reads where that part ends.
* rules: the time before strict is the change that turned it, written again or nottv47 hours3-37/+136
| | | | | | | | | | | | | | | | | | | | | | | | | | A change written under a policy that isn't strict was refused, in a strict document, unless it was in the history of the change that wrote the policy value the document read now. So the policy written again by a node that held a change from before, taken beside the strict policy, put that change in the new writer's history: that node kept it, every other node refused it, and the new policy with it, and the node was cut off. Now the reference is the change that turned the swarm strict: one that wrote a strict policy where the policy at its history wasn't, found by following back the writes of what the policy holds (`store::writers`). A change written under a policy that isn't strict is refused where such a change is beside it, neither in its history nor built on it. A policy written again, strict over strict, names the same change. One turning the swarm strict beside it is refused like any other. Of two at once neither is preferred: any rule choosing one, the lower hash say, would let a change made later to look as old take the place of the one every node took, and every node would drop it with all that was built on it. So two members turning a swarm strict at once split the nodes that took one from those that took the other; access.md says to turn it from one.
* store: a signed value chosen by seq is named sotv2 days1-5/+13
| | | | | | | | Where the policy asks for signed values, a place's value is chosen by `seq`, but conflict reports still called the choice `newestWins`, and the code and the architecture still said "newest" of what a read shows. A report names it `highestSeq`; the rest says "the one a read shows".
* rules: nothing added to the time before a swarm turned stricttv2 days2-0/+99
| | | | | | | | | | | | | | | | | | | A swarm turned strict by writing the policy into it kept the time before open: a change whose history lacks the policy's change is judged by the policy then, none or one that isn't strict, needs no signature there, and is taken whenever it comes, from any member. With values read by `seq`, an envelope planted at that time with the highest `seq` there is can never be followed: a ban, a user, a declaration, for good. Once a document's policy is strict, a change written under one that isn't is refused, received or held, unless it is in the history of the change that wrote the policy the document reads (`store::written_by`). A node that holds one beside that change, taken before it came, is told so by any peer that refused it (REFUSALS), judges it again, now refuses it too, and drops it with what builds on it, as for any change it took unjudged. A swarm strict from its genesis change has no such time; one whose policy isn't strict judges as before.
* swarm: a new swarm's policy recorded in its genesis changetv2 days7-1/+87
| | | | | | | | | | | | | | | | A swarm strict from its start had its policy written by its first user in a later change. A change is judged by the policy at its history, so any member could always add a change whose history is from before the policy: judged by none, needing no signature, taken whenever it comes. Since signed values are read by `seq`, an envelope planted there with the highest `seq` there is can never be followed: a ban, a user, a declaration, for good. `--bootstrap-policy JSON`, with `--genesis`, records the policy in the genesis change, with the first users: then no change of the swarm is from before it. It must be a policy this node knows, and a strict one needs `--bootstrap-keys`, or nobody could sign what decides who may do what.
* remakes: values signed by their users replayed as chainstv2 days1-3/+399
| | | | | | | | | | | | | | | | | | | | | | | | | Under a strict policy, a replay wrote at each path the old document's merged view: at a place of a value its user signed, the last envelope alone, whose `prev` names one the new epoch doesn't hold if the value was written twice since the base. Every node refused it, it went to the quarantine, and the new epoch kept the base's value: a remake rolled back every signed value changed twice since its base, and a rejoining node lost its own the same way. And the replay found what changed by Automerge's diff, which says nothing of a value that changed beside Automerge's own choice: where a place held two values at the base, a write replacing the one read by `seq` wasn't replayed at all. Now, under a strict policy, the places of signed values are found from the changes' operations as well as from the diff, and each is replayed as the chain that leads to the envelope the old document reads: every envelope from the one the new document holds there, following `prev` through the changes since the base, each in a change of its own by its signer at the time it was made, judged as every node will judge it. A place is replayed only where the new document holds a lower `seq` there; where no chain leads from what it holds, it goes to the quarantine. A path above such places is split into its keys. Without a strict policy nothing changes.