aboutsummaryrefslogtreecommitdiffstats
path: root/docs/remakes.md
Commit message (Collapse)AuthorAgeFilesLines
* docs: the strict remake among the kindstv30 hours1-2/+2
| | | | | | The glossary and the `kind` row of `remakes.md` named three kinds of remake; `strict` is the fourth, and takes `baseHeads` as `replace` and `import` do.
* remakes: of one change, its other writes replayed before its linkstv37 hours1-1/+2
| | | | | | | | | | | | 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.
* remakes: other writes replayed with the links by historytv38 hours1-1/+2
| | | | | | | | | | | | | | | 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.
* remakes: a signed place already held is kept like any write that losestv40 hours1-10/+11
| | | | | | | 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 madetv40 hours1-2/+6
| | | | | | | | | | | | | | | | | 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: values signed by their users replayed as chainstv42 hours1-0/+6
| | | | | | | | | | | | | | | | | | | | | | | | | 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.
* remake: replayWindow and archiveRetention in an octet-stream import's querytv8 days1-3/+4
| | | | | | | An import uploaded as `application/octet-stream` takes `rules`, `baseHeads`, `settle` and `switchDelay` in the query, but not the retentions: for those the document had to go base64-encoded in the JSON form. Now `replayWindow` and `archiveRetention` go in the query too, as JSON like the rules (`{"epochs":1,"age":"7d"}`, as in the body).
* remake: leave out earlier epochs' metadata past the replay windowtv8 days1-1/+1
| | | | | | | | | | | | | | | | | | | | | Every snapshot carried the metadata of all earlier epochs (`_continuum/epochs`) forward, so it grew by an entry, a clock per actor among it, with every remake. Only a rejoining node reads an earlier entry: a node on epoch P reads P+1's (its clock, when it was proposed, its replay window) and every one up to the swarm's epoch (kind, translation, whether it was strict). It replays only while P+1's replay window covers it; beyond, its writes are quarantined whatever the entries say. So a snapshot now leaves out the generations older than the oldest whose replay window still covers a node on the epoch before it (`snapshot::left_out`), judged by the remake's `proposedAt`: the same on every node, and earlier than any rejoining node's clock, so nothing a node can still replay through goes. Metadata that doesn't read stays, with all after it. A strict remake's metadata stays for good: by it a rejoining node, however far behind, tells a strict remake of a swarm strict already (`catchup::prepare`, which reads the generations it finds). There is at most one, short of such a remake. No new key and no change to the rejoin: a node beyond the window that finds some entries and not others quarantines with "cannot translate" rather than "outside the replay window".
* docs: proposing a remake under a policy the node doesn't knowtv9 days1-1/+3
| | | | | | Review 3: since 1184 a proposal is written as the user who asks, so under a policy the node doesn't know it answers 409 like every user write. remakes.md says so.
* remake: aborts written as the user who asks; no abort by timetv9 days1-2/+3
| | | | | | | | | | | | | | | | | Review 2, N3: 1150 let any member write an abort decision once a remake had expired a grace period ago, judged by the change's own time, the writer's word. A member could race the coordinator's legitimate commit with an abort dated as it liked; both taken, Automerge shows one, and nodes that acted on the commit split from those that didn't. The two writers of such aborts are operator requests whose endpoints already need write on _continuum/remakes: aborting an expired remake (DELETE /admin/remakes/{id}) and superseding one (POST /admin/remakes?force=supersede). Both now commit as the user who asks (the proposal and its vote with them, for a supersede), which the rules take as one who may write the decision. The clause judging an abort by its time goes, and with it the time the rules carried. An expired remake is still aborted through any member, by an operator.
* remake: turning a running swarm strict, keeping what an operator signedtv9 days1-1/+4
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Until a swarm is strict, the user a change names is its node's word, so any member could have planted registry entries, policy, bans or user-signed values as any user, plain or signed by a key it put there itself; writing the strict policy trusted all of it as it was. A remake of a new kind, `strict`, turns a swarm strict instead: * Its content is a manifest (access::strict): the swarm, the strict policy, and each value kept at the places values are signed, by the SHA-256 of its JSON, signed by an operator (ssh-keygen -Y sign -n continuum-strict). * Every node builds the next epoch as compaction does, keeping at the signed places only the values the manifest names, as they were at the base, and writing its policy (RemakeKind::protocol, the one kind that changes protocol data). Writes after the base reach the new epoch only by replays, judged by the strict policy. * A node votes for one only with its manifest signed by one of --strict-keys, keys given out of the document; without any, for none (logged once, `Not voting for a strict remake`), unless --follow-strict-remakes. A coordinator proposes only what it would vote for (403). Once a majority commits one, every node switches, as with any remake: refusing to switch would only cut a node off. * GET /admin/strict-manifest gives the manifest keeping everything held now, the values for review and the heads they are at; continuum-signed strict shows them, signs once confirmed and proposes at those heads. The sim a_swarm_turning_strict_through_a_remake: a member plants a registry entry as a manager; the operator's manifest leaves it out; a and b, given the key, commit; c, without, follows; the entry is gone and the policy strict everywhere.
* rules: an expired remake aborted by any membertv9 days1-0/+3
| | | | | | | | | | | | | | | | Under a policy, a remake's decision was taken from its coordinator only. A node aborting an expired remake whose coordinator is gone (DELETE /admin/remakes, after abortableAt) was refused by its own judgement (403), so such a remake could never be decided. The decision is now also taken from a user who may write it (the protocol writers), and an abort from any member once the remake expired a grace period ago (abortableAt, by the coordinator's grace period in the proposal). The rules have no clock of their own, so that is judged by the time the change says it was made: the writer's word, so a member could abort a remake early, as it could ask its coordinator to, but never commit one. Before then, an abort stays a request the coordinator applies.
* remake: replays judged before they go intv9 days1-0/+4
| | | | | | | | | | | | | | | A switching or rejoining node replays late writes as fresh changes naming each write's user, and nothing judged them before they left: a replay every node would refuse (a revoked capability, a second envelope at a signed path, readers changed) was refused everywhere, and with it everything the node wrote after it. Under a policy, replay_newest now judges each group it commits as every node will (rules::judge_held, in the new epoch); one they would refuse is taken back (forked at the heads before it, same actor) and its paths quarantined with the reason. replay_newest takes the epoch. Review finding 3 (remake replays).
* remake: replay from the quarantine where the user may writetv9 days1-1/+3
| | | | | | | | | | POST /admin/quarantine/{id}/replay needs write on _continuum, which never covers user data, and replayed every path of the entry as the user who asked: every node refused the user data in it. It now replays only the paths the user may write and keeps the rest in the entry (left), for one who may; 403 if the user may write none. Review finding 3 (quarantine replays).
* remake: replays keep their writerstv10 days1-1/+3
| | | | | | | | A remake's replay writes each value as the user who wrote it, splitting where several users wrote under a path, so replays are judged as the original writes. Auth plan M6 (remakes, 2.4).
* remake: forgetting and releasing name their usertv10 days1-1/+1
| | | | | | | Forget records and released quarantines name the user who made them, so they are judged by its capabilities. Auth plan M6.
* epochs and the rest recordedtv11 days1-3/+6
|
* add documentationtv2026-11-021-0/+410