aboutsummaryrefslogtreecommitdiffstats
path: root/docs
Commit message (Collapse)AuthorAgeFilesLines
...
* federation: a snapshot leaves out the entries of nodes no longer listedtv43 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 nottv43 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 hashtv43 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, takentv43 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 `@`tv43 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 partytv46 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 emptytv48 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 remaketv2 days1-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 forktv2 days1-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 forkingtv2 days1-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 signedtv3 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 againtv3 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 writetv3 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 ↵tv3 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.
* federation: no party sets the pace of remakestv3 days1-126/+133
| | | | | | | | | | | | | One user reached `remakeWriters` in two hours with its sixteen creations' writers, or `remakeChanges` within a day at its budget, and did it again in every epoch: a remake every two hours, an archive each, a snapshot each on every node. Writers now count per party, as the budget does, so creating users starts no more of them; no remake comes before the epoch has been seen for `remakeAfter` (recommended 7 days); and the budget recommended is 60 changes, 1 MiB and 10 000 operations a party an hour, plenty for a registry.
* federation: a party is headed below the rootstv3 days1-26/+30
| | | | | | | | | | | | A party for a budget was a user with the users below it that no line reaches but through it. Every line starts at a root, so a root's party held every user only it had brought in: one newcomer writing at the budget's pace stalled the root's witness changes at every node. A user's party is now headed by the highest user below the roots through whom all its lines pass: a user a root created heads its own, and a root is its own party. A root's node's witness changes, one a `witness` at most, draw on no party.
* federation: decisions on who votes, by the roots' witnesstv3 days1-54/+64
| | | | | | | | | | | | | | | | | | | The voters before couldn't be read for who votes itself: of two decisions on who votes by one list, either could be taken as the one that replaced it. Of the same number, the lower digest held, and a list made up by the voters a decision replaced, voters no more and of whom nothing is assumed, could hold and become final. Of decisions on who votes made by one list, the first decided now holds: one is late against another where a root's node committed a change with the other decided and it not, and a later one is a decision of voters already replaced; where the roots' nodes show both orders or neither, the higher number, then the lower digest. And a node takes a proposal up only where it says its signer saw all the node held a window before it takes it up, not before it received it: a list proposed in January can't be decided in June, so the voters before lose a window's decisions at most.
* federation: a root left out backdates nothing as a roottv3 days1-41/+46
| | | | | | | | | | | | | | | | Whether a user is a root is read where each thing it did was done. A root the voters left out signed creations, each saying it saw only changes from before the decision, and they were a root's there: the seats', without a limit, taken back only by every root together. And one change of its node, on heads from before the decision, witnessed as a root's and contested every name not yet final. What a root a decision leaves out signed, and what its nodes committed, is now a root's only where that decision's proposal was signed in sight of it, or where another root's node had it in its history without the decision, as for the voters before. What it settled and created before keeps its standing; what it backdates is an ordinary user's.
* federation: any node aborts a remake that expiredtv3 days1-80/+87
| | | | | | | | | | | | A member acks one remake an epoch until it is aborted, and in a federated swarm only a coordinator wrote of a remake beside the acks. So a node that proposed the moment a remake was due and never decided, or an honest coordinator that died, ended the epoch's remakes, and with them the bound on its heap. Any node now aborts a remake that expired, once a grace has passed by its own clock, as an operator does in every swarm; the abort frees the acks. A remake committed is followed whatever abort came beside it.
* federation: of two remakes of one epoch, the one the voters' nodes went totv3 days1-78/+84
| | | | | | | | | | | | | | | | Of two remakes of one epoch every node went to the lower ID, and nothing bounded how late the second came. So one node, keeping the epoch as an archive, committed a second remake a month into the next epoch, its ID ground lower, and every node moved to it; a node walking the archives went the same way, into whatever branch that node continued. The one whose new epoch holds switch records of nodes of more than a third of the voters, a node counted for one voter, now comes first; the lower ID decides only between two that both do, or both don't. A remake committed late, beside one the swarm went to, moves nobody, and a walker reads the same from the two new epochs. The paragraph under Partitions that repeated the rule goes.
* federation: a switch record says what began after the basetv3 days1-82/+93
| | | | | | | | | | | | | | | | | | | A length that began after a remake's base had nothing in the snapshot, so it started anew in the next epoch: a claim final after the base was contestable again, a user gone after it waited again. A decision decided after the base waited for the nodes of two thirds of the voters to take it up again, who may be gone by then. And a node's change written between its switch record and the envelopes it named witnessed against them. A switch record now also names each length that began for its node after the base, from the stamp it began at; the claims it held standing with no rival there; and the proposals it took up after the base, which are its records in the new epoch, judged against the votes brought along. Every change a node commits after its switch record reads what the record names as in its history. The length by which something stops counting for good is among the lengths the snapshot and the switch records list.
* federation: a remake's base holds a third of the voters' stampstv3 days1-84/+91
| | | | | | | | | | | | | | | With any base followed, a coordinator could keep every snapshot at a base of its own changes: honest envelopes then never enter a snapshot, and lengths of time stay out of it. A check by how old a base is at each node can part honest nodes, by when each got the decision. A node follows only a remake whose base holds stamps of nodes of more than a third of the voters, each written once its own history held the epoch's threshold. A stamp's history is all its node had seen, so such a base holds what a third of the voters' nodes had seen once the epoch was due, and every node reads that from the base alone: none follows where another doesn't. Without a third of the voters' nodes stamping, no remake passes, as nothing is decided.
* federation: envelopes name their branch, and floors keep out what a remake ↵tv3 days1-82/+84
| | | | | | | | | | | | | | | | | | | | | | | | left out An envelope was taken in the epoch it named and the next, and the root change listed what its base held of the epoch before. So a base that left out what the epoch before had brought in sent those envelopes two epochs back, and refused them; one user able to commit a remake on its own changes erased whatever was signed after the last snapshot it didn't choose. And a node away over two remakes lost what its user had signed meanwhile. An envelope now names the branch it was signed on: a fork or a refusal begins one, the genesis change the first, and a remake stays on the branch it is on. An envelope signed in an earlier epoch of its branch is brought along from however many remakes back. What a remake left out is kept out by floors instead of the list: for each user and kind of statement, the highest number a remake left out; a statement brought along at or below it, and not in the snapshot, is refused. Every statement is numbered, votes too. A value needs no floor: one left out names in its `prev` a value that is gone. What a floor refuses goes to the quarantine of the node that holds it, at a switch as on coming back.
* federation: brought along, and switch recordstv3 days1-86/+88
| | | | | | | | | | | "Carried over" is continuum's word for replay: a node's writes written again by path, the last writer winning. The federated swarm does something else after a remake: envelopes written again as they were signed, and what each node held of them recorded. Envelopes are now "brought along", and a node's record of what it held when it switched is its "switch record" (`_continuum/switched/<node ID>`). The Remakes section says that continuum's replay doesn't run under the federated policy.
* federation: what it asks of the document, and where Automerge sets limitstv3 days1-113/+170
| | | | | | | | | | | | | | | | | The design leaned on Automerge in places it didn't say: writers that cost memory, one change per writer and number, changes Automerge applies and shouldn't, the order of values written at once, maps made at one key, history held in memory, bytes that versions must agree on. A section near the start says what the design asks of the document, and nothing else of it is read: changes named by their hashes, each judged at its history; the document at a set of changes, the same on every node; a writer for each change; history kept as long as the store keeps it, and remakes. A section at the end says, for each of Automerge's seven limits, what Automerge does, what the design does about it, and what would go without it. Every rule that is there only for one of them points to it in place. "Writer" is the design's word for the identity a node writes under; "actor" stays with Automerge.
* federation: the words this round added, for the glossarytv4 days1-3/+5
| | | | | | | The words the glossary gets with the federated case: final, of a decision too; stopped counting for good; the voters before; and the alive peers and their acks, as the design names what continuum calls the electorate and its votes.
* federation: leftovers of rules since made generaltv4 days1-14/+14
| | | | | | | | | "By any node" under Decisions said for votes what is now every statement's rule; it says so in a line. And the voters no longer remake: the row of two thirds turning says what they still can. A matter's examples name who votes and who the roots are; and the list of those who take part goes by who voted or signed anything that stands, since an epoch no longer spans a term.
* federation: what to watch, and when to acttv4 days1-2/+54
| | | | | | | | The design showed much and said nowhere who looks at what, nor when to act. A section says it for each who acts, a node's operator, a user, a voter and a root: each signal, where it shows (an endpoint, and a metric beside it), the threshold the design recommends, and what to do. What a node put off shows (`GET /admin/put-off`), beside taking it.
* federation: what it coststv4 days1-6/+52
| | | | | | | | | | | What every node pays was scattered over the text: what a statement, a stamp, a cut's list and a carry record take, a snapshot a remake, a signature's check. A section of its own says it per thing (a change, a writer, a statement, a value, a node, a user at its limits, a claim, a cut, a root's node, a remake, a signature), in memory, on disk, on the wire and in time; what bounds the changes and the writers, and so an epoch's heap (some 42 MB at the remake numbers recommended); what nothing bounds; what was measured; what is assumed cheap.
* federation: a user's claims of one name, counted once, released togethertv4 days1-166/+171
| | | | | | | | | | | | "A user's own claims of one name are one, ordered against others by the earliest" left three things open. They are ordered by the first of them that stands, by the numbers they state and then the digest, so a duplicate committed after a release doesn't carry the released one's witness. They count once toward the kind's limit, so a node that held duplicates back can't commit them to push the user's later claims past it. And a release gives up every claim of that name of its user but those signed in sight of it, so a user gives a name up with one release, though a node may still hold a duplicate it handed out.
* federation: the payloads hold what the rules readtv4 days1-21/+29
| | | | | | | | | | | | | | | | | | | | | Six places where a rule read a field the payloads didn't have: * a value's envelope, with its `prev`; and since a value says nothing of what its signer saw, where it was signed is the change that carries it; * `unvouch` of a user the root change holds without a creator, which has no `create` or `vouch` to name: `for`, its ID; * `release` of a name a decision gave or made over, which has no claim of its holder's to name: `claimKind` and `name`; * `firstKeys` holds its cut's `keeps`, as every cut does; * the matter `name` names the kind beside the name; * a member entry says which open proposals its bounds would refuse (`refuses`). `key` named three things in one payload; the signing key is now `signingKey`, the key a `key` statement adds `added`, the one a `retire` retires `retired`. And `user`, the signer's name beside its ID, goes: nothing compared the two.
* federation: catching up has a number of its owntv4 days1-5/+6
| | | | | | | | | | A node that comes back writes nothing before it caught up with the peers it keeps, or `witness` passed: one number meaning two things. A peer that delays what the node lacks for a minute had a root's node, back from a day off, write blind. `catchUp`, recommended 10 minutes, lets a swarm choose how long such a node waits. Past 32 heads, the STATUS names them by a digest, so the node goes by the sync that follows it.
* federation: what a party's budget countstv4 days1-26/+35
| | | | | | | | | | | | | | | | | A node takes a party's changes no faster than a budget, and the design never said what the budget counts nor recommended one. It counts changes, their bytes and their operations an hour, recommended 600, 4 MiB and 100 000 a party: a change of a few bytes that holds a million operations draws on it too, and a change larger than what is left of the hour is taken all the same, its party's next changes waiting until it is paid. A node's changes draw on the party of the user its writers count for, whatever they carry. A root's node wrote once more for every claim that reached it, so one party's claims and releases had every root's node write without end. It now writes once a `witness` at most, for all claims that reached it meanwhile: 1 440 changes a day with a minute, within its party's budget.
* federation: `limits.writers` recommended at 64tv4 days1-6/+9
| | | | | | | | | | Every writer costs every node 4 bytes for every change of the epoch, those before it started too. At a year of a hundred nodes' daily stamps, one user that starts 1 024 writers costs every node some 143 MB; 64 cost some 9 MB there, and 2.5 MB at the `remakeChanges` an epoch now reaches. 64 writers are a node restarting weekly for more than a year; a swarm whose epochs last longer than that (few nodes, writing little) sets it higher, as the text now says.
* federation: a key's own retirement takes back nothing seentv4 days1-6/+9
| | | | | | | | | | | | A key retires itself only from where it stands, its cut holding all it signed that the retiring change's history holds. But whoever commits the retirement chooses that history: on dependencies from long ago a stolen device key retired itself from there, and what its user had signed with it since was outside the cut. A key's own retirement now takes back nothing that a node of its user or of a root had in its history without it, as far as an unvouch reaches. A key above still cuts a stolen key off from before the theft.
* federation: the voters' cut takes back a root's creationstv4 days1-20/+26
| | | | | | | | | | | | | | | | A root's creation outlasts a cut of that root's key where another root's node saw it, so that a root that turns can't take back settled or final names. A thief of a root's key kept the same way every moved-in user it gave first keys to, past the root's cut and past the voters' too, to be undone one decision a user. A cut a user sets (the root itself, or a thief of its key) still leaves what another root's node saw; the voters' cut, by first keys they give a root, takes back what the cut-off key created outside it, whoever saw it: two thirds of the voters undo a stolen root key in one decision, and no root does alone. With one root nobody else saw anything: its cut takes back a name only its creation holds, final or not, as the text now says beside the one voter.
* federation: a claim in sight past an unvouch or a cut, by the roots' nodestv4 days1-96/+100
| | | | | | | | | | | | | | | | | A claim signed in sight of another that was down there only by an unvouch or a cut is ordered against it by lateness, over all the changes. The text counted the nodes of the other's side, the other claimant's own among them: a claim hidden, cut off and brought back then contested one made rightly in sight of it, and an unvoucher's own stamp, made weeks later, brought a claim back over one made in sight of the unvouch. For these pairs the roots' nodes alone are the witnesses: the claimant saw the other, and the unvouch or the cut, and said so, so neither its own old stamps nor the other claimant's nodes count. Two claims and Resolving say so too, the leftovers of the earlier reading go from the "else" under Claims, and the registry shows such a claim as held while the unvouch or the cut stands.
* federation: nothing is left out with the node that carried ittv4 days1-182/+183
| | | | | | | | | | | | | | Any node commits any user's statement, yet a statement still counted only where its node committed it within that node's cut: a party that stopped its node with a cut from before took back what the node had committed for anyone, a settled claim among them, and an accomplice had the name. A node's cut now takes back what the node witnessed and the writers it started, never what it carried. With it go the leftovers of the rule that only a user's node carries its statements: the attack row and its test, the trust table, the API. An out voter's node commits its carry record beside its records, and peers take its changes for both.
* federation: a moved-in user's first keys come from the root named for ittv4 days1-54/+64
| | | | | | | | | | | | | | | | | | The root change names, for each user it holds without keys, the root that gives them; no other root's `create` gives keys. Two roots' creations no longer compete, so a contest arises only where that root signs two: they are ordered as claims are, with the other roots' nodes alone as witnesses, so a twin on old dependencies is late for good once another root's node saw the first. Which creation gives the keys is read over all the changes, as which claim holds a name is, and no longer where each statement was signed: read there, a twin was the only creation at whatever place its maker crafted, and its keys signed as the user. While two contest, nothing signed with the keys of either counts, until the voters give first keys; what the keys they give signed counts then. A decision on the roots that leaves a root out says which root gives the keys it was named to give.
* federation: remakes are continuum'stv4 days1-465/+375
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A federated swarm remakes as every swarm does: a node proposes and coordinates, the alive peers ack, every node builds the next epoch itself. The voters no longer decide remakes, so the base check, the votes naming a base, `baseAge`, `remakeAge`, the heal, and the admin actions `choose`, `follow` and `back` go. What the federated policy adds: * compaction only, and no sooner than the epoch's history holds `remakeChanges` changes (recommended 10 000) or its changes started `remakeWriters` writers (1 000): every node proposes and acks by these numbers, and follows only such a remake; * any base serves: the snapshot holds the registry at the base with whatever something signed later could still change (envelopes with their signatures, what was given up and hasn't stopped counting for good, what the order among claims rests on, how far each length of time has run), and every node carries over what it holds beyond the base with what it held of it; * envelopes of the epoch before come from any node, as within an epoch; a claim carried over and one the snapshot holds are ordered as two claims out of each other's sight, not by the base; * lengths of time go on across a remake, each node's carry record saying what it saw broken after the base; * of two remakes of one epoch, every node goes to the one with the lower ID. A remake made a cut reach no further back than its snapshot. With remakes as frequent as the document grows, that would leave a stolen key's work standing after an hour. So what was given up, replaced, left out by a cut or past its limit, and was seen so for `final`, has stopped counting for good, remake or not; that is what a remake leaves out.
* federation: who votes and who the roots are, by decisionstv4 days1-172/+185
| | | | | | | | | | | | | | A remake no longer names the voters and the roots: each is a matter the voters decide, as a number is, and holds until another decision of it. Whether a user is a root is read where each thing it did was done, so a decision changes nothing done before it. What the votes of before could still do once others vote, a remake used to put out of reach. Two rules do it now. A decision of voters that a decision on who votes replaced counts only where that decision's proposal was signed in sight of it decided. And a decision seen holding for `final` is final: no decision of its matter whose proposal wasn't signed in sight of it holds instead, whatever its number.
* federation: what each payload holdstv4 days1-0/+59
| | | | | | | | | | | The design named fields in passing and listed none, though stage 2 settles the payloads first. A section lists the fields each rule reads: every envelope's (swarm, epoch, path, kind, signer, what it saw, its number, the key and signature), each statement kind's, a proposal's matter and what it holds (a remake's switch delay among them), a vote's; a fork's vote, which counts toward no matter; and what a node writes plain: a record of a proposal, a carry record, a member entry with the user its writers count for and the digest it computes.