aboutsummaryrefslogtreecommitdiffstats
Commit message (Collapse)AuthorAgeFilesLines
* federation: what acks are for in a federated swarmtv34 hours1-3/+5
| | | | | | | Acks stay continuum's, by node, but in a federated swarm a node follows a decision it can build without counting them, so what they decided was nobody's to say. They tell an honest coordinator when to commit, so that fewer nodes are away; they are no safeguard.
* federation: a node a remake left behind for a version, moved by its operatortv34 hours1-4/+7
| | | | | | | | A remake that races a version leaves the nodes that took it in the old epoch. Its operator moves such a node without a fork or an empty document: it has the node drop the version it took, the base then holds the version it reads, it switches, and the new epoch writes the version again from the votes replayed, as any node writes one it holds passed.
* federation: forks before remakestv35 hours1-7/+8
| | | | | | | | | Forks are what any group carries on by, and promise 3 rests on them; remakes are there only for Automerge's sake. Forks come at stage 4 and remakes at stage 5: until then a federated swarm that grows too large starts afresh by a fork whose version names the same parties, keys and rules. And a writer forked splits the nodes for good only until stage 2, where an operator may have its node drop what it took.
* federation: what a version names anew, by a number, nothing unsignedtv35 hours1-99/+99
| | | | | | | | | | | | | | | | | | A version setting a party's keys or node list had the change writing it write an envelope without a signature at the party's place, `prev` empty and `seq` 0, and only that change, so that it was ahead of every set before it: a kind of envelope of its own, a rule on who writes it, the same written again with the version, and a genesis and a fork writing them too. Each version gives, for each party's keys and node list, the number of the version that named them anew (`since`): its own where it does, else that of the version it changes. A party's keys are those of its set where the set names a version numbered at least that; otherwise those the version names; its node list the same. Nothing is written for it, the document holds no envelope without a signature, and what a key an earlier version named writes at a history from before still counts no more.
* federation: an operator may have its node drop what it tooktv35 hours1-6/+18
| | | | | | | | | | | Where keys voted twice, or a writer forked, each node kept what it took, and the sides came together only by a fork, a node with an empty document, or its peers' word. An operator may have its node drop a version, or any change, with everything built on it, as continuum drops a change its node took and the rules refuse (`drop_taken`), and take what the others hold: no peer's word moves a node, its operator's does. So either side may join the other without what parts them, as the design request asked, without a fork.
* federation: wordings that said more than the design doestv35 hours1-15/+17
| | | | | | | | | | | | Which federation a swarm follows is in each version, not in its policy's place; a fork's first version changes the one current at its heads, not `null`; a place given back shows what its party signed before only where nothing replaced it since; a remake's snapshot is a function of its base and its record, so two remakes at one base are two epochs; honest nodes agree once they sync but where keys voted twice, a coordinator decided two remakes, or a writer forked; and what a node taken off its list commits from a history before ends with the next remake's base, as no later version orders it.
* federation: the writers a node starts, boundedtv35 hours1-4/+10
| | | | | | | | | Every writer costs every node memory for as long as the epoch lasts, and nothing bounded the writers a node starts: one listed node starting one with every change runs every other out of memory before a remake could be built, which the design called slow, not wrong. A federated swarm bounds the writers a node starts in an epoch, judged at a change's history as any rule is: a rule, and stage 1's.
* federation: a party that voted twice read from its votes, by a tooltv35 hours1-9/+11
| | | | | | | | | | | A node reported a party that voted twice, judging each copy of its votes by the history it was taken at, so that a vote committed again elsewhere framed nobody; and the next remake left those histories out. The votes alone tell it: a `true` and a `false` on one proposal, or a `true` on two proposals of one version where both passed or neither is dead by all the votes cast, as an honest party backs another only once the first is dead. A tool over the votes the parties' clients keep reports it, later too; a node reports the versions it refused.
* federation: a node takes no token another node issuedtv35 hours1-23/+22
| | | | | | | | | | | A node took tokens from the nodes its party lists, and without a user registry every user it lets in may do everything. A party's list is written by a key its version names, or set by a version: so two thirds of the parties, or a thief of that key, could list a node of their own as the party's, issue a token under any name there, and have the party's own nodes take it, against "the design rules nothing about what happens on a party's own nodes". A node takes only its own tokens; a party logs in to each of its nodes.
* federation: of two versions that come together, the first judgedtv35 hours1-4/+4
| | | | | | | | A node holding two versions that change the one it reads, having taken neither, took neither until its operator named one. But where one comes first it is taken anyway, and two come together only by how a sync message was cut: the state, and the endpoint naming one, guarded nothing. A node takes the first it judges.
* federation: what a replay refused, tried again; a client votes by its owntv35 hours1-4/+8
| | | | | | | | | | | A replay puts changes neither of which saw the other by their clocks. A party's `true` committed again at a history before the nays that freed it, its clock set between, came before those nays in the replay and was refused, though the old epoch took it: a proposal that passed there might not pass in the new one, and a party not finding its vote might vote again. What the new epoch refuses is tried again once the rest is replayed, and a party's client keeps what its party voted and votes by that, never by what a node shows.
* federation: a node shows whether a proposal is a versiontv35 hours1-1/+4
| | | | | | | | | | A proposal is taken whatever its text, and asked whether it is a version only where it is written as one. One that isn't is voted on, never passes, and dies only by nays: two thirds backing it bind the federation to its version for good, and a client reading JSON otherwise than the nodes backs what no node writes. A node shows whether a proposal is a version by the federation it knows, and a party's client backs none that isn't.
* federation: what a node's API users may have it committv35 hours1-0/+3
| | | | | | | | Without a user registry, every user a node lets in may do everything, and `--protocol-writers` say who writes protocol data; what of that held in a federated swarm the design didn't say. Whoever a node lets in may have it commit what the rules take, envelopes and the node's own protocol data; `--protocol-writers` names nobody.
* federation: sizes among what the federation's number namestv35 hours1-8/+11
| | | | | | | | | Nothing bounded a version, a key set, a node list, a path or a value: a version larger than a sync message carries would be written where it passed and reach nobody, and nodes built with different bounds would take different changes. The sizes each may have are the federation's number's, each within what a sync message carries, and stage 1 sets them.
* federation: a member at a remake's base is a node its party lists theretv35 hours1-9/+10
| | | | | | A node follows a remake only where it is a member at the base: listed there, or listed and registered, the design didn't say. Listed: a node its party listed registers in the new epoch as it would have in the old.
* federation: a passed version written as soon as a node holds it passedtv35 hours1-5/+6
| | | | | | | | Any member wrote a passed version; when, and which, the design didn't say: every node that sees it passed, the one that took the last vote, or one after a wait. A node writes it as soon as it holds it passed; the same version written by several is one, as a node takes a version it took written again.
* federation: a federation's genesis built from its first versiontv35 hours1-18/+24
| | | | | | | | | | | | A federation's genesis change, judged by none, was its founding node's: what else it held (values at places, votes) nobody checked, and the swarm's name was the one its node drew or remembered, so two federations started under one name took each other's envelopes. It is built byte for byte from the first version alone, as a fork's genesis is from its version and heads, and holds the policy, the swarm's name, the version and what it sets, nothing else; the swarm is named by the version's hash, and a node joining builds the genesis and checks it. The genesis writes no topology: a federated swarm runs continuum's own.
* federation: what a fork's genesis leaves out, by which versiontv35 hours1-8/+9
| | | | | | | | | | A fork's genesis left out what a snapshot does, the federation's versions, member entries and the swarm's name. It didn't say what of continuum's other data it holds (remake records, acks, earlier epochs' metadata), nor whether what counts no more is read by the fork's first version or the one current at its heads: two founders deciding apart build two swarms where one is meant. It holds none of continuum's own data, and reads what counts no more by the version current at its heads.
* federation: a `prev` names what the place holds, whoever signed ittv35 hours1-1/+4
| | | | | | | | A party writing first where another's envelope is (a place given to it, an envelope a dropped key wrote) could name that one as replaced, `seq` one more, as judging at a change's history needs, or start anew; two builders deciding apart would refuse each other's envelopes. It names that one.
* federation: a map made only on the way to what a change writestv35 hours1-11/+14
| | | | | | | | | | | A change wrote nothing where rules say who writes but `@` keys and the maps on the way to them, never deleting or replacing one. It didn't say that a map is made only on the way to an `@` key the same change writes: one builder would take any member's maps in any party's namespace, left empty for good, another wouldn't. Nor that a map is made only where none is: a map made where one is, naming it as replaced, hides what it held, votes under `_continuum/federation` among them. Both are said, for the federation's own paths too.
* federation: `{party}` matches only a party's nametv35 hours1-2/+4
| | | | | | | | Where a rule's `{party}` segment met a segment naming no party, one builder would match it with a writer that is nobody, another wouldn't match and let a later rule decide, and the two would judge a write at `names/r/foo` apart where a `names/r/*` rule follows. It doesn't match, which is the reading the wiki example needs.
* federation: a party's `true` and `false` on one proposal both counttv35 hours1-1/+4
| | | | | | | | | Where a party's `true` and `false` on one proposal are both in one history, the design didn't say whether it voted yes, no, both, or what the place read as; one builder's node would take a version, or another party's next `true`, where another builder's refused it. Both count: then a history that holds more votes never takes back a pass or a death.
* federation: two decisions for one epoch, and an abort, its coordinator'stv35 hours1-8/+17
| | | | | | | | | | | | | | | | A remake's decision was its coordinator's alone, but a member could abort a remake that expired, as each node's clock said: the one place the design waited on time. And a coordinator writing two decisions for one epoch, showing each to some nodes, left honest nodes in two epochs for good, as continuum's following of most peers, and rejoining sideways, are gone. The abort is the coordinator's too, and a remake left undecided binds nobody. A node holding two decisions for its epoch follows neither, says so, and leaves it to its operator; on its operator's word it builds the remake named of the epoch before its own, from the old document it keeps, and switches, what it wrote since replayed. Not promised and Attacks say so.
* federation: a place's value among the envelopes their party's keys signedtv35 hours1-16/+23
| | | | | | | | | | | | | | | | A place's value was the first of all the envelopes it held, by version, then `seq`, and it counted only while its key was its party's. So a key the party had dropped, by a member committing at a history from before the drop, wrote ahead of the party's envelope, replacing it, with a higher `seq` each time the party wrote again: nothing at the place counted until a version named the party's keys anew. A place's value is the first of the envelopes there that a key their party holds signed; judging, and the envelope a `prev` names, go by all of them as before. And a party signs again what should stay after the set that drops a key, not only before: what the dropped key writes at a history from before can't name that as replaced, and counts no more, so it takes nothing out.
* federation: stage work for screening and a new node's partytv36 hours1-10/+13
| | | | | | | | Screening judges a batch at a frontier that every change touching what the rules read moves, or a later change of the batch is judged at heads it doesn't hold: stage 1 moves it for what the federation reads too. And a node syncs with members only, but is one only once its own entry names its party: stage 3 shows the party in the handshake before that.
* federation: no version replayed across a remaketv36 hours1-19/+25
| | | | | | | | | | | | | | A node switches only where the version it reads is written at the base. So a node that switches took no version written after it, and what it replays names the version current at the base, or one before: the replay of versions, each in one change with what it sets, after the votes that passed it and whatever names the version before it, was there for no node. It goes, and with it two `true`s cast at once, replayed one after the other, undoing a version that passed. The version a node reads is asked as it reads it when it switches: one it takes while it builds the snapshot leaves it where it is, as one taken before.
* federation: the old epoch synced with nodes still on ittv36 hours1-4/+9
| | | | | | | | | | | A node leaves its epoch only for one it built itself from a base it holds; but continuum stops syncing the old epoch once it switched, so a node away across a switch lacked some of the base and stayed until its operator moved it, on most remakes where nodes come and go. A node syncs the old document with nodes still on that epoch for as long as its own setting keeps it, and a node that lacks some of the base syncs it from them, each change judged there, and builds then.
* federation: a fork taken only on history a node holdstv36 hours1-14/+17
| | | | | | | | | | | | A node holding the old document left an epoch only for one it built itself, but took a fork's heads' history, where it lacked some, on its peers' word: a founder could name heads holding a change it sent nobody, a version written without votes say, and the genesis would carry what that change set. A node holding the old document takes a fork only where it holds the heads' history, syncing what it lacks from the old swarm, each change judged there; otherwise it says it can't check and leaves it to its operator. Only a node with an empty document takes a fork on its peers' word, as it takes an epoch.
* federation: a snapshot leaves out the entries of nodes no longer listedtv36 hours1-4/+8
| | | | | | | | | | Nothing is deleted within an epoch, and a snapshot left out only what is or names a version before the current one, which no member entry does: the entry of every node its party stopped listing, every node reinstalled under a new ID among them, stayed for good. A snapshot leaves out the entry of a node its party doesn't list at the base; a node listed again registers again. A fork's genesis holds no member entries already.
* federation: a version refused for its side, its committer nottv36 hours1-4/+7
| | | | | | | | | | A node refuses a version that doesn't change the one it reads, valid at its history or not. Continuum refuses as a whole a member whose own change broke a rule, sending it nothing more; a version valid where it was written breaks none, and its committer, often an honest member on the other side of keys that voted twice, would stay cut off after the operators settled. It isn't refused as a whole, and the node reports it apart from changes against the rules.
* federation: a proposal refused where its text isn't its place's hashtv36 hours1-3/+5
| | | | | | | A proposal was taken whatever its text, yet named by the hash of its version: one builder took a proposal whose text hashes elsewhere, another refused it, and their nodes parted. It is refused: the hash asks nothing of what a version may say, so every node asks it alike.
* federation: a version a node took, written again, takentv36 hours1-5/+6
| | | | | | | | | | | A node took a version only where it changed the one it read, or was that one written again. A member that was away writes a passed version itself, at a history where the version before is current, and the others took the next version meanwhile: its change writes neither the version they read nor one changing it, so they refused it and everything the member built on it, an honest member split off. A node takes a version written again wherever it is one the node took.
* federation: versions a node takes, epochs it builds, values in `@`tv37 hours1-354/+408
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What the design leaned on that didn't hold, and what it can do without: * A vote counts as cast wherever its version is current, so the keys an earlier version named could pass another proposal on it at a history from before the version that followed, raise its number alone, and be read by every node. A node takes a version only where it changes the one it reads; another it refuses, reports, and leaves to its operator. Two that change one are written only where keys voted twice: each node keeps the one it took, and the parties fork. The lower hash goes. * A node left its epoch on its peers' word (catching up), or for a remake at any base its coordinator named. It leaves an epoch only for a compaction it built itself, from a base it holds, a member there, the version it reads written there; the decision is the coordinator's alone, and how long the old document is kept the node's own setting. The check that a remake reads as the old document goes, with remakes of other kinds. * Housekeeping within an epoch shrank nothing (Automerge keeps every operation), and an emptied place read whatever anyone put back. Nothing is deleted in an epoch but by a party's own `null`; a snapshot and a fork's genesis leave out what counts no more and is or names a version before the current one. Rule 7, putting back and the replay's deletions go. * A key could hold an envelope and a map at once. A place's value is in its `@` key, which never holds a map, so no key is both; `**` stays. * A key set dropping the key that signed it counted no more by the rule for values. Sets are checked only where written, and signed, as node lists are, only by keys the version names, so a party revokes a key of its set by itself. What a version sets for a party (keys, and now node lists, as the first version and a fork's do, so that a group without listed nodes can fork) is one envelope, `prev` empty, `seq` 0. * The federation's envelope is `cv3.`, so that swarms that aren't federated read nothing new; neighbours are kept partly by party; the krebs users who will vote are the parties, the others in a group. * The share is two thirds, the field gone; `went/` goes. And what two builders would decide apart: a version's bytes its JCS encoding, validity asked where it is written as a version, the rule grammar's edges, keys holding `/`, the double-vote report against a vote committed again elsewhere, one list of the protocol data a federated swarm takes, the Automerge version a rule, releases working together, the swarm key, a yes that can't be taken back, what stage 1 covers and that its swarms are for tests.
* federation: the first member in the genesis, node lists by partytv40 hours1-35/+57
| | | | | | | | | | | | | | | | | | | Nothing made a federation's first node a member, so nothing after its genesis change was ever taken. The genesis change holds its node's party's node list, naming that node, and the other parties' lists come in through it. A list counts as its party's, whichever of its keys signed it, until the party writes another: no change of keys leaves a swarm or a fork without members, and signing the list again with the keys goes. A fork's genesis is said to be a function of its first version and the heads alone. Closed is at, within and above, a member's entry too, and the swarm's topology is closed with the rest. Smaller: keys differ by keys; a party changing keys adds the new ones, signs again with one, then drops the old; the keys a version sets name the version being written; rule 6 is read at the deleting change's history; a party may keep the keys its version names offline. Rows for the genesis list, stranded lists and a stolen voting key.
* federation: votes by their version's keys, a federation starts emptytv41 hours1-91/+119
| | | | | | | | | | | | | | | | | | | | | A vote and a proposal now count by the keys their version names for their party: every version names every party's keys, and the parties are the names of those keys. So a vote is checked from itself and its version alone, and a remake replays it as cast in whatever order key sets of its party go around it; replaying votes before key sets, which no order could meet where two parties' key sets and votes cross, goes, with the rule treating two key sets at once as voting twice. A party's own key change reaches its votes with the next version naming its keys. A federation's genesis change is its swarm's first, so it starts empty: content before it would be a change judged by none. A fork's genesis is built byte for byte, so one version and one set of heads make one swarm. A member's entry is its member's only, removed whole; logouts, sessions and forgotten nodes are closed, and a write at the policy's place refused. Rule 7 waits for what was written beside a `null` too; a `null` housekeeping deleted after a base is back for an epoch. A party signs its node list again with its keys. "Why it holds" says what a remake keeps. Rows for what this answers.
* federation: started by its genesis change; votes kept across a remaketv43 hours1-119/+133
| | | | | | | | | | | | | | | | | | | | | | | | A federation starts with a swarm of its own, its genesis change writing the federated policy and the first version: nothing is from before it, so the time before, the federating change and values from before go, and nothing writes the policy's place after the genesis change. A running swarm doesn't become federated; that is left as a road not taken. A remake replays a party's votes before its key sets where neither saw the other, so a vote counts as cast across a remake too; a party that wrote two key sets at once is answered as one voting twice. A version is replayed in one change with the keys it sets, and a replay holds for any base. A `null` the epoch's first change holds goes only at a remake, and housekeeping deletes one only where this epoch's history holds what it covers. A node is a member while the party its own entry names lists it; another party's list does nothing. A proposal counts as written, like a vote. A fork is named by its first version and the heads it names, in its genesis change; `went/` says where to those who follow. Leftovers: the unsigned key envelope's meta; "can bring back" reaching deletions; the first link checked against the place as the deletion leaves it; "is left out"; the attack rows, renumbered.
* federation: the highest number, a double vote answered by a forktv44 hours1-98/+154
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The current version is the written version with the highest number, of two with one number the lower hash: a number is checked where its version is written, so this is the end of the chain, read without the versions behind it, which housekeeping may delete. A double vote both sides built on can be read one way and then the other while votes cast before the sides met come in, and what was written under the version not read ranks with the other's, a thief's key set among them. The parties answer it by forking without the party that voted twice; a report of one comes from the history, never from the document as a whole. A node's party is its operator's, in its configuration: another party listing it changes nothing. Replay goes by history and by the version named, deletes what counts no more beneath a new holder's chain, and may leave out a `null` once a later version is current; housekeeping may delete a `null` once all it covers was signed by keys its party dropped. The federating change is the one the policy's writes lead back to, and one beside it is refused: a tie broken by hash would let a change made later to look as old take its place. A fork's first version names the highest at the fork's heads, the fork is named by its genesis change's hash, and joiners are told whose keys the fork changed. Leftovers: the keys a version sets spelled as an unsigned envelope; client advice out of the rules; `null` at a proposal's place gone; literal rules before `{party}` ones; node lists in stage 1; rows for what this opens.
* federation: versions in the meta, the longest chain, leaving by forkingtv46 hours1-178/+246
| | | | | | | | | | | | | | | | | | | | | | Every envelope's meta names the version current where it was written, and a place's value goes by version number, then seq, then digest: what is signed under a later version is ahead of any chain written at a history from before it, by a former holder or a dropped key. Only a version revokes a key; the change writing a version writes the keys it sets. The current version is the end of the longest chain of written versions, a tie decided by the lower hash where they part: a version written late beside one the parties went on from changes nothing. A party that voted twice shows by its two signed votes, which nodes report and clients keep; taking it out is a version. Votes count by the keys at their own history and go only with their version. Becoming federated is closed by the rule continuum keeps for a swarm turned strict; leaving is a fork. A fork's genesis holds only the group's version, numbered past the highest, and is the new swarm's name. Any envelope deleted can be put back; the first-envelope rule goes. Replay is continuum's chain replay, with versions in the order written. The attack table gains the rows these open.
* federation: order by seq and number, votes of yes and no, forks as swarmstv2 days1-252/+326
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What a place holds is read by its envelopes' `seq`, the current version by its number, a party's keys by one envelope's `seq`: nothing by the order of operations, which a change's writer steers. - A version is a string named by its hash, numbered, written at `versions/<hash>` by any member once it passed, counting by its votes and not its writer, and current only once written. - A vote is `true` or `false` at `votes/<party>/<version>/<proposal>` and never changes. A proposal passes with the share's yeses and is dead once the nays leave too few; a party backs one proposal at a time, and another once the first is dead. So a split ends on its version. Two versions with one number are written only if a party voted twice; the lower hash is read. - A party's keys are one envelope, or what a version set. A first envelope at a place names its party's keys, so it can't be put back once they changed; deletions need no rule of their own. - Rules start with a literal segment; `{party}` is a whole segment; a writer is a party, `{party}` or `false`. How names and addresses are spelled as paths is the application's. - What counts no more: five things; any member deletes them, judged by the document the deleting change makes. - A fork is a swarm of its own, started from the document with the version the group wants. - Becoming federated closes the history before it. A node that didn't hold the epoch before takes a remake on its peers' word, which promise 1 now says. Tokens come from one's own party's nodes only. - A list of attacks, each with what happens and how it is tested.
* federation: a key added again can bring back what it signedtv2 days1-1/+1
| | | | | "Would" read as a promise someone might rely on; whether a key added again brings anything back is nothing the design says.
* federation: a removed key is the party's not to add againtv2 days1-1/+2
| | | | | | Nothing remembers removed keys, so no node can refuse one added again; the design says it is the party's to keep from doing, as it would bring back what that key signed.
* federation: what counts no more, listed; forks need no writetv2 days1-50/+67
| | | | | | | | | | | | | | | | | | | | - What counts no more is listed, five things and nothing else: a value where its party may not write; one whose key went; a deletion once its party holds none of the keys it names; a proposal on a version that isn't current, and its votes; the value not shown of two written at once. - Any member deletes those, but what stopped counting because its key went only its party, until it holds no keys at all; housekeeping thereby empties a place only where nothing could be put back, so an envelope that replaced nothing never comes back. A deletion names the keys its party held, and stays while it holds any of them; a removed key is never added again. - A fork is following the chain that begins with a proposal; nothing is written for it. `went` stays apart, and so does voting, which moves nobody. - A version may name another federation, or none with the policy the swarm goes on with. - Several people may keep one party, and one person be in several.
* federation: forks are proposals, following is private, housekeeping by any ↵tv2 days1-69/+88
| | | | | | | | | | | | | | | | | | | | | | | | | member - A swarm becomes federated by writing the federated policy with its first version, at genesis or later; what was written before counts only where a party signed it as the first version allows. - A rule's writer is `true` or `false` for every party or none, and `share` two whole numbers ([2, 3]), so nothing needs parsing or rounding. - At most `limits.proposals` of one party's proposals on one version are held at a time; it deletes one to make room. - The keys a version sets are written as the party's keys by the change that makes the version current; the version holds them for nothing else. - What doesn't count may be deleted by any member, judged by what counted at the deleting change's history; the writer that made it stale deletes it, others only what they find stale. An envelope signed with a key still held can be put back where nothing is. - Every proposal is a chance to fork: a group follows one by writing it as the current version of a chain named by its hash. No forks path. - What a party's nodes do of themselves (following others, voting by bounds) is their operators' business and written nowhere.
* federation: parties vote, rules say who writes, remakes only carrytv3 days1-248/+231
| | | | | | | | | | | | | | | | | | | | | | | | | | | | The design asks less of continuum and of remakes: - Parties vote; there are no voters apart from them. - The policy's rules say who writes where: paths with `*`, `**` and `{party}` (`names/{party}.r`), each naming its writer, the first that matches deciding; shared identifiers are rules, given by versions. The federation's own paths are fixed by its number. - A swarm says which federation it follows (this design is 1); a change to the federation is a design of its own with the next number. - A passed proposal is written as the chain's current version by any party; what lapsed, or doesn't count, any party may delete. - A value counts only while the key that signed it is its party's: a removed key takes back all it signed, the party signs again what was its own. Deletions stay until the key of what they deleted goes. - Agreement holds while fewer than a third of the parties vote twice, as the design now says. - A party without nodes writes through any node; node lists say who is a member and whom a node syncs with. - Remakes are continuum's, when and with whom it likes, of any kind that loses and adds nothing; writes after the base are each judged again, with no replay window. - A fork is a chain of its own within the same document; nodes follow one chain and sync with its parties' nodes only. - What Automerge limits are recommendations; denial of service breaks no promise.
* federation: rewritten around a policy its voters changetv3 days1-2755/+303
| | | | | | | | | | | | | | | | | | | | | | | | | | | The design is rewritten from the start, around what it is for: handing out identifiers and giving every party a namespace everyone reads. A party is a voter. The policy is a chain of versions: the voters and their keys, the kinds of shared identifiers and who holds each, and the numbers. A proposal changes one version, and becomes current once two thirds of that version's voters voted for it; a vote is never replaced, and one voter's two votes at once count for neither, so at most one proposal changes a version and every node that holds the same votes reads the same policy. Identifiers are given, taken back and given again by versions, never first come; nothing waits on time. A change is judged at its history by the version current there; what counts is read by the version current in the document. A stolen key is replaced by its party, or by a version. Remakes start the document anew for Automerge's sake only: acks by voter, a majority of them; the snapshot holds what counts; every envelope after the base is judged again, within a replay window counted in epochs. Any group forks with the version it wants, and nodes follow by their own rule, which may name parties to follow and vote with. Gone: roots, vouching and lines, claims and witnesses, lengths of time, cuts, floors, branches, switch records, and the catalogue of attacks.
* federation: a branch and a floor, for the glossaryfederation-1tv3 days1-3/+4
| | | | | | | The words this round adds to those the glossary gets with the federated case: a branch, which an envelope names; a floor, which keeps out what a remake left out; and a party, now for writers as for a budget.
* federation: leftovers, and what the snapshot and the genesis change nametv3 days1-33/+49
| | | | | | | | | | | | | | | | | | * One node commits a remake alone, as the trust table and the code have it; what is not promised, Remakes and the row of most nodes said the alive peers did. * What a third of the voters do at once, stamping as they like, now names a decision final and what stopped counting for good. * The voters are no longer an epoch's: what is not promised, promise 7's argument and a row said so. * Why it holds says how a remake changes nothing as it now does. * A remake's proposal and decision, continuum's records, are said to be no proposal or decision of the voters. * The snapshot names, for each user it holds without keys, the root that gives them, and the genesis change's fields are said. * A node builds one snapshot a coordinator and epoch at most. * What to watch has the signals of remakes this round needs. * The attack table ends before the next heading.
* federation: two final decisions of one mattertv3 days1-84/+90
| | | | | | | | | | | Two sides of a partition both decide where more than a third of the voters have nodes and votes on each. Past `final` each decision is final on its side, and when the sides meet, "no decision of its matter holds instead whose proposal wasn't signed in sight of it" blocked both ways. Two final decisions of one matter now give way to each other as decisions not final do: the higher number, then the lower digest; for who votes, first the one the roots' nodes saw decided first.
* federation: what is brought along, against what the snapshot holdstv3 days1-71/+77
| | | | | | | | | | | | | | A value brought along counted while its user had signed none at its place in the new epoch. So a node that held back a value its user had handed it, and that the user had since written past, wrote it after a remake whose snapshot held the newer one, and it showed until the user wrote there again. It now gives way to the snapshot's value at its place unless its `prev` names that one. And what a proposal brought along was signed in sight of, which a final decision and the voters before ask, couldn't be looked at: such a proposal is now in sight of all the snapshot holds and of nothing brought along.
* federation: what waits, and what stops counting for goodtv3 days1-14/+19
| | | | | | | | | | | | | | | Anything past its limit stopped counting for good once seen so for `final`, so a limit lowered for that long left out for good every key, node, creation, vouch and claim past it, raised again or not. And where `gone` is longer than `final`, a user that gave itself up lost, at `final`, what the text says a cut takes back until it is gone. What was past its limit already where it was signed still stops counting for good; what only a limit lowered since puts past it waits, as long as the limit is lower. A user that gave itself up is out by its own word, and what it had waits with it until it is gone. And the numbers say what a `final` of nothing does: no cut brings back anything given up.