aboutsummaryrefslogtreecommitdiffstats
Commit message (Collapse)AuthorAgeFilesLines
...
* federation: every base taken up, writers for one user, cuts as unvouchestv5 days1-292/+358
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Remakes. A node took up the first base it saw and no other, beside votes that name their base and are never released: two remakes proposed at once, or a base handed first to nodes back from away, split the nodes, and a voter whose nodes took one base up could vote for no other, ending the epoch's remakes with nobody malicious. A node now takes up every base that passes, one record a proposal; records count toward taking a base up however old without votes, and a remake's record is judged without them (as written, a record needed votes in its history that come only after it). Clients offer a vote only for a base whose records count for more than two thirds of the voters, showing the other remakes under way. The votes alone keep two bases from both being decided. What votes never released cost is said under what is not promised: voters who split end the epoch's remakes, and whoever holds a hanging remake's last record chooses its day; an operator bounds how late a remake its node follows, and refuses a later one by staying. A remake's vote runs while the epoch lasts, and the voters don't end it by a later proposal; said where every vote was said to. Writers. A node carrying for several users counted its writers for each, so one user past its limit put off every node that carries for it, for all their users. A node's writers count for one user now: the first that named it, as its own changes show. Names. - A creation or vouch cut off stops counting as its signer's unvouch would, from where the cut was set: a user only its creator vouched for is out from there, its names waiting, final ones too, until it is gone or a vouch comes. Before, everything it signed stopped counting at once. - A root releases its own `create` for a user the root change holds: two roots answering at once contest, and nothing ended it. - A `create` is refused where a user's claim of its own name holds the name, and a user has one such claim at a time. - A root's witness outside a claim's history makes two claims contest only where it had the other count through its own witness of an unvouch, as meant: a limit lowered and raised again leaves sight to decide. - What comes back over a later claim is said for a holder's own release, limit or cut too. Attacks: two remakes proposed at once, a remake held by its last record, a node carrying for a user past its writers, a creator cutting off a user only it vouched for, a crafted first change of a writer in a batch, a user's own name claimed again; row 124 with what transactions never write and the tests that show it. A limit lowered and raised again moves to the stage of decisions, a witness after an unvouch to unvouching. What was checked: the committer is named from a change's own history.
* federation: votes name a remake's base, a user's own name, writers per usertv5 days1-154/+206
| | | | | | | | | | | | | | | | | | | | | | | | | | | | The third reading against the text and the code: * A remake's base: the coordinator names it, a voter's vote names it, once an epoch, never released, and a record counts for a voter only where its vote names the record's base. A coordinator handing two bases to two nodes of each voter gets one decided or none. A base whose records count for a third of the voters every node takes up, however old: a partition at the base no longer ends the epoch's remakes. * Whether a claim stood where a later one was signed is read with the witnesses in that history; one made after brings nothing back, and a root's makes the two contest. A claim pushed past its limit by statements a cut leaves out comes back, as one released by a stolen key does. * A user claims its own name with its own key, which holds the name where its creator's key is cut off from before its creation. * A decision on whose a name is makes every other claim give way, two final ones too. * A root's creations giving keys to a user the root change holds are ordered as claims: one root coming after another gives none. * Writers are counted per user, as settled; a twin switches a node's writer only signed with its key. A node keeps when it received what. * Leftovers: an out voter's records taken from its nodes, the lists of a cut, the encoding among what can't change, a change's operations among what isn't bounded, stages, words. 129 attacks.
* federation: a root is a user, an epoch's first change its root changetv5 days1-38/+39
| | | | | | "Root" meant both a user and an epoch's first change. The first is now always the root change. The budget's test goes with the budget (stage 8), and a crafted change's tests, which exist, with stage 1.
* federation: what a cut brings back, what `prev` namestv5 days1-114/+132
| | | | | | | | | | | | | | | | | | The questions the design left: * A cut that takes back an unvouch brings its user in again. Its claims from before stood all along; what it signed while out comes to count later than it was signed, and gives way to what was claimed in sight of it. Gone stays gone. * A creation taken back by a cut is taken back as a vouch and as the claim of the user's name, not as the user: a vouch names a user by its ID, so with another vouch the user stays in, keys and claims, without a name. * `prev` names the value that shows where the envelope is signed; where several count there, any one of them, and the write replaces them all. * A carry record needs telling from no other change: it witnesses by what it names. A remake's proposal isn't carried over.
* federation: carry records, refusing within a window, digests by two thirdstv5 days1-161/+228
| | | | | | | | | | | | | | | | | | | | | | | | | | | | What was left open after the second reading: * After a remake every node first commits a carry record: the digests of what it holds beyond the base and what it held of it. It witnesses as the node's changes did. Then each envelope is written again once, by whoever finds the epoch lacking it, and only where a carry record names it. So a late remake doesn't bring every envelope once per node, and nobody hands in later what no node held at the switch. * What is carried over comes after what the snapshot holds and before what the new epoch signs: a number nobody could check orders only its signer's statements, and a carried proposal outranks none of the new epoch. A value of the new epoch has the last word over one carried over. * No node takes up a proposal that says it saw less than the node held a window before, so whoever proposes can't make refusing cost a whole epoch. * A node stops writing only where its digest differs from the nodes of more than two thirds of the other voters: fewer than a third stamping nonsense stop nobody, with three voters too. * A node carrying for a third of the voters, keeping its records back, is said, with what the voters do about it; a voter without a node names carriers of two parties. * Writers of a node stopped with a cut count for nobody. A limit lowered for a day gives names away for good, said.
* federation: what an operator does on its nodes is no part of ittv5 days1-90/+79
| | | | | | | | | | | | | The design asks that an honest federation bears whatever the malicious do, and rules nothing about a party's own nodes, which nobody could enforce. So: * Bans go: `ban`, `--follow` and their limit. Leaving a user out when reading is each reader's own, and a side note. * Whom a node lets in and what it lets them do is its operator's. Keys in the registry give nothing on a node by themselves. * A remake that leaves a root out says which root has each name a rule gives a root, so none is without a holder.
* federation: one base an epoch, sight decides alone, lists of voterstv5 days1-358/+477
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The design after a second reading against itself and the code: * An epoch has one remake: a voter's node records one base for its epoch and no other, and a later proposal is taken up only for that base, those voters and roots. No node that switched moves again by itself. The proposal lists the voters by their IDs and names its coordinator; nothing after it is signed changes the list. * A voter votes for its epoch, in, out or gone, and the nodes of one that is out commit their records and nothing else. A node takes up only a higher number than it took up. A record is read where it was written. * Of two claims, one signed in sight of the other: sight decides alone, asking whether the other stood where the claim was signed. Late is asked only where neither saw the other, and a claim late against one that isn't late against it is late for good. A final claim gives way to none but another final one. An earlier claim comes back over a later one only where a root's node had seen it hold the name before it went down. * What was given up or is left out by a cut comes before nothing, so a stolen key's statements stand in nobody's way once it is cut off. * A retirement lists what its cut keeps, so the cut holds after a remake. After a remake a node states what it held of what it carries over (which claim late against which, what counts through an unvouch, which value replaced which), where an order of changes said it; of several values at one place, one that another replaces is left out. The snapshot keeps the proposals that are open. * Giving a user up puts it out, and it is gone after `gone`: a cut takes it back until then. First keys for a user the root change holds are given once. * Writers are counted by a party's budget and put off past `limits.writers`, never refused. A party, for a budget, is a user with the users only it leads to. * A node that follows several users takes a ban where most of them state it. Between two stamps is read from their histories. The relays stay an operator's list. * What is asked of a change before Automerge sees it, as the code has it. 121 attacks.
* federation: a thousand writers a user, and what the limit doestv5 days1-2/+6
| | | | | `limits.writers` is recommended at 1024. A user whose nodes started that many starts no more until a remake; how many they started shows.
* federation: changes Automerge wouldn't write are refused todaytv5 days1-12/+13
| | | | | Screening refuses them in every swarm, so the design builds on it and no stage adds it.
* federation: why not an actor for every changetv5 days1-0/+18
| | | | | | | | | | | | | | An actor that is the hash of its change with the actor left out makes a fork of an actor two changes that every node holds: it can be made with Automerge 0.12's API and is checked with one hash. But Automerge keeps a slot per actor in every clock it caches and moves its indices for every actor that comes, so with an actor per change heap and time grow with the square of the changes: 32 to 257 MB and 2 to 20 ms per change applied at 10^4 changes, 2.7 GB and 0.16 s at 10^5 (measured with Automerge alone). A hundred nodes stamping daily write 10^4 changes in a hundred days. So a fork of an actor stays proven and named, not prevented.
* federation: a limit on the writers a user's nodes starttv5 days1-30/+52
| | | | | | | | | | | | | | | | A writer (an Automerge actor) costs every node heap in proportion to the document's history: about 4 bytes per change, a slot in each clock Automerge 0.12 caches. A document of 10^5 changes takes 42 MB with 10 writers and 435 MB with 1000 (measured with Automerge alone). Screening counts no actors, so a party starting a writer with every change adds gigabytes to every node. `limits.writers` (256 recommended) bounds what a user's nodes start in an epoch, judged as a change's history shows, and a federated node keeps its writer over a clean stop. Out of each other's sight such writers are valid and held: the nodes that made them are refused as peers, a party's budget bounds how fast they came, a remake leaves them out. Not promised: a bound on what an epoch's document costs.
* federation: only changes Automerge itself writestv5 days1-18/+41
| | | | | | | | | | | | | | | | Automerge 0.12.0 applies changes no honest node writes: one that lists an actor none of its operations names, one whose first operation is numbered below its dependencies' or at 2^32 - 1. It then gives back another change than the one it was given, saves a document that doesn't load, or panics (measured with Automerge alone). A party that crafts one stops the honest nodes, where a forked actor only parts them. So a change is refused before Automerge sees it unless its bytes are the ones Automerge encodes for it, every other actor it names has changes in its history, and its first operation is numbered one after the highest of its dependencies. An attack with its test, in the first stage.
* federation: several roots, final names, every voter countstv5 days1-820/+1168
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The design as it stands after being read against itself and the code: * A statement says where it was signed: its payload names the changes its signer saw. "In sight of", the order past a limit and a proposal's number are read from that, so carrying a statement a second time moves nothing. A statement that is counted states its number. * A node carries for a user once it committed the statement naming it itself. Tokens and logins by key are taken as a node's operator says. * Lines say who is in and nothing else. A claim's witnesses are its user's nodes and the roots'. * The roots are several, named by an epoch's root change like the voters: by the genesis change, then by each remake. What a root signed for another is the seats' once its signer holds none, and the roots take that back only together. * A claim seen holding its name for `final` by a third of the voters is final: no rival holds or contests the name after, whatever a root says and whatever is cut off. It takes no root. * A claim made in sight of one that didn't stand doesn't give way to it when it comes back (its user vouched for again, a limit raised); only a release or a cut that a cut takes back does that, until the later claim is final. Late is witnessed by a change that saw the other stand while the claim didn't. * A cut never leaves out its own statement, and takes back what the key it cuts retired, stopped and unvouched. Giving a user up takes a first key. * Every voter counts toward a decision: more than two thirds of all. Nobody is absent; a remake names those who take part, and a voter votes while it isn't gone. Any node of a voter takes a proposal up; every node judges a record against the votes in its history; a proposal is decided at a record that has two thirds of them in its history. A node takes up nothing lower than it took up, the highest number holds, and what hangs short of records shows and is ended by a later decision. A change is judged by what is decided in its history; the registry is resolved by what holds. * What is decided: numbers, the policy, first keys, the names of a user that is out, whose a contested name is, the voters' names, and a remake with the voters and the roots it names. * A remake: every node carries over what it holds beyond the base, whoever signed it, in its first changes and in order; the root change lists the digests of the base's statements, so nothing it left out is written again; decisions after the base are taken up again, and what a third of the voters' nodes held as gone, final or dropped stays so. An epoch's remakes are one matter. * A kind may name the characters of its names (lower case recommended); a kept name may be claimed, to stay through a change of policy. * The genesis change may hold users, without keys too, so a registry moved in has its users from the first change. * How often nodes stamp, a member entry's size, and what the genesis change sets for the swarm as a whole are numbers of the policy. * A node compares what it resolves with the stamps of the voters' nodes, and stops writing only where a third of them differ. Two wire versions spoken at once is a change for every swarm. * Stages: versions before remakes; the registry stage is for trying, the last for relying on it. 110 attacks.
* federation: all users are those there when a remake is proposedtv6 days1-36/+46
| | | | | | | | | | | | | | | | | | | | | | | A remake that names all users names those that count in its proposal's history, and still do at its base: the list is fixed with the proposal, so those who vote see it, and a user brought in while the votes run isn't on it. A fork's voters go the same way. And what reading the design from end to end found: * a remake does two things, not one: it throws history away and names who votes next; * nothing plain is written but a node's member entry and its records of proposals, said where namespaces are, too; * a node doesn't sync under a policy it doesn't know, whatever its version says; * two sides that only resolve differently show by their stamps; * on the wire a federated swarm's handshake says which epochs a node keeps, and a version speaks the one before its own: "no message changes" holds for a swarm that isn't federated; * three more things assumed: what was seen for long kept as the node goes, the cost of a digest with every stamp, two wire versions spoken at once.
* federation: voters named at a remake, versions, what is uncoveredtv6 days1-127/+216
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What the maintainer asked of the design: * Who votes is named by the remake's proposal: all users at its base, as recommended, or a list. So those who vote say who votes next, and nobody votes by a rule of who created it. What that costs is said with it: every voter named counts toward what a decision takes, and all users is whoever brought users in. * What a policy no longer covers is uncovered at once where the decision holds: shown aside by every node, taken away by its user only, changed by nobody, and dropped once it has been seen there for `uncovered` (a number; 0: at once). Within an epoch a rule moves nothing in the document; the remake moves it. * Being seen takes nothing but a node that is up: its stamp is renewed about daily whatever else is written. A node left running keeps its voter present; naming the voters deals with that. * A release of a vote is best effort. * Continuum changing under a swarm: versions agree by what they compute, not by a number. Every stamp carries the digest of the snapshot its node would build there; a remake is taken up by the ID each node built; a node checks itself against the swarm before it writes with a new version; a change of the rules is a change of policy, and a node knows a policy by everything in it; recorded vectors every version passes. What can't change, what changes freely, and when it is a fork. * Who may connect is outside the design; the swarm key is a note. The attacks are 84. future-work.md: several roots, present by the user's own signature, a guide to moving to another swarm.
* federation: lines, time from the stamps, the last decision holdstv6 days1-493/+624
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What the maintainer asked of the design, and what it changed: * Lines. A user is in while it has a line: a chain of creations and vouches from the root. When its creator goes, one that another vouched for stays without doing anything. The witnesses of its claims are the users on the lines it stands on: its creation's, and those of vouches it accepted (`accept`), so nobody gets a say about a user's names by vouching for it unasked. Why only its signer takes a vouch back is said where unvouching is. * Lengths of time are read between two stamps of one node, with what that node had seen at each: a voter is absent once a third of the voters saw it silent for long, a user gone once they saw it out. No clock is set against another, and why a third. * Decisions. A proposal is decided as soon as the nodes of two thirds of the voters hold its votes: at once, not at the end of a window. Any number are open at a time, within a limit a voter. Of the decisions of one matter the last holds, by which proposal was made in sight of which, so two decided at once stop nothing. A remake's base is named by its coordinator, a node of the proposer. * The policy changes by a decision, as a whole, with no remake: a remake throws history away and does nothing else. What a policy no longer covers doesn't count, and a remake keeps it aside for an epoch or drops it, as the policy says. Going apart by a fork stays for those a decision leaves behind. * What a remake leaves out, so that the document's size goes by what stands: a release is a statement in its epoch, the remake deletes. * Names are written as they are used, in the document and in the rules alike, and compared by their segments: structure, not meaning. A rule may leave a name to the voters to give. * Who vouched for whom changes nothing in who connects to whom: a node keeps its seeds and its user's other nodes as neighbours. The attacks are 83, the stages fifteen. future-work.md: guides to write (keys, the root, starting a swarm, voting, a registry), policies merged.
* federation: the fractions are numbers, a decision can be refusedtv6 days1-121/+169
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What the maintainer answered to the design's last two questions, and what follows from it: * The fractions are numbers of the policy like the others, changed by a decision to any value: the share of the voters present a decision takes (two thirds recommended), the share of all of them (half), and the share whose stamps make the swarm's time and a user gone (a third). What is promised of decisions is argued for the recommended ones; Why it holds says what other values carry. * Refusing a decision: a node follows every decision that counts unless its operator has it refuse, by bounds on the policy's numbers or by hand. It then moves to the epoch built at the decision's history without it, which is the same for every node that refuses the same decision: those who think alike go on together without arranging it. While a proposal's votes run, a node whose bounds it breaks says so. A remake or a change of policy is refused by staying. * A decision gives a user name with its namespace, as designed. * No open question is left. The options not taken that the questions listed are among the roads not taken: first users voting as soon as created, voters let in without a remake, other reaches of an unvouch, a gone user coming back, first keys by those who vouch, a registry of only what is signed, numbers the design fixes. The attacks are 78; the stages name them by their numbers. future-work.md: bounds on more than numbers.
* federation: numbers without constraint, names by a decisiontv6 days1-171/+164
| | | | | | | | | | | | | | | | | | | | | | | | | | What the maintainer answered to the questions the design had left: * Every quantity of the design is a number of the policy, in one table with what the design recommends (the times, the limits, how much a remake's base may lack, how long the root's node lets a claim wait). The genesis policy sets each, and a decision changes any to any value: nothing constrains them. The fractions aren't numbers. * While a user is out, the voters free its names or give them to another by a decision, whatever `gone` says; a policy without `gone` has the names wait until a vouch or a decision. * Nobody is put out by a vote, said where unvouching is, with what there is against a user that harms within the rules. * A node keeps the epochs it left for as long as its operator says, `archiveRetention` at least, and says which; so a node coming back, or one joining from the genesis root, walks every epoch where an archive is within reach, and shows where the walk doesn't end at its peers' epoch. * Settled, and listed so: who votes, from where an unvouch undoes, gone for good, first keys by a decision, what the root holds unsigned. Two questions remain: whether the fractions are numbers too, and whether a decision gives a user name with its namespace. future-work.md: an archive of every epoch.
* federation: the answers to its open questionstv6 days1-218/+387
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | What the maintainer answered to the design's open questions, in the design: * The numbers. The limits and the times are the policy's numbers, set in the genesis policy and changed by a decision: 64 keys, 64 nodes and 256 addresses a user for a start; `window`, `absent`, `gone`, `archiveRetention`. A lowered limit takes nothing away. * A user nobody vouches for is out, and its names wait for it: nobody else claims them. Out for 30 days, as the stamps of a third of the voters show, it is gone: its names are free, and no vouch brings it back. So whoever relied on a vouch that an unvouch or a cut took back has that long to find another, and loses nothing meanwhile. * First keys by a decision. The voters are above every user's first keys: they give a user that lost them new ones, with a cut for the old. The promises say so, and what isn't promised: a name against two thirds of the voters. * What a decision is made of (a proposal, a vote, its release, the decision) is taken in any node's change, so a user without a node votes at whatever node it reaches, or by a vote carried to one. Such a user names another party's node to carry for it. * Coming back after remakes: by the archives on nobody's word, epoch by epoch, as far as peers keep them; else by an ID the operator gives, never because peers advertise an epoch. A statement is carried over from the epoch before only; older ones are quarantined for the user to sign again. * Resolving reads the decisions first: nothing below changes them. * The questions that remain are put with their options: who has a vote and from when, whether the voters put a user out against those who vouch for it, from where an unvouch undoes, whether gone is for good, the price of first keys by a decision, and what the root holds unsigned. The attacks are 76; the stages name them by their numbers. future-work.md: barring a user by a decision, and voting made easy for a user without a node.
* federation: a design for a swarm kept by parties that don't trust each othertv6 days2-0/+1255
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | federation.md designs what the krebs registry needs of continuum: a swarm several parties keep, any of them possibly malicious. Nothing of it is built. It is a mode a swarm is started in: one that isn't federated stays as it is. * The parties, what an adversary can do, and what is promised to an honest node: only valid changes; the same document and the same resolved registry for the same changes; values signed by their users; one holder per name; a claim nobody takes once the root's node saw it; no waiting for anyone to write; and, with fewer than a third of the voters present malicious, decisions by two thirds of them. And what isn't: one history under a partition, a name never contested, decisions against a third, against keys stolen later, against a malicious voter on both sides of a long partition, or with half the voters gone; a swarm no forked actor splits. * The design, on the strict policy. The policy is in the root. Users come by statements that only add; a user is its creation, its keys a tree, its nodes those it names. Vouching and the line; unvouching, with what exactly it takes back. A namespace per user. Names of declared kinds claimed, with rules and limits as data, some kept for a user without a claim. Of two claims out of each other's sight, one is late where its own side can be shown to have seen the other first; where that leaves not exactly one, the name is contested, and a release gives it up. Cuts: what a key signed outside a set of changes stops counting, whenever it shows up; a key is cut off by one above it only. Bans change what those who follow read, not what anyone takes. * Decisions: votes signed by the voters, over days, by numbers the document holds and a decision changes. Who votes is in an epoch's root change: the root alone at first, then, with each remake, the users a root created, so nobody fills the votes without two thirds of those there agreeing. A time read from the document, by which those away for long don't count; a decision taken up by the voters' nodes while its votes run, and counting with two thirds of those present and more than half of all, so that honest voters never make two however long a partition lasts. The root's seat given anew by a decision, and what a root finds when it comes back. Remakes: the base is the decision's history, every node builds the snapshot from the registry as it resolves, statements are carried over, and what counted at the base is final. A change of policy as a fork each operator follows or not, as Bitcoin changes its rules; it may name who votes on its side, and is the way out for those a decision leaves behind. * What every node judges and how the registry resolves, how a partition shows and how a side comes back, links along the line, tokens of one's own party only. Why the promises hold, the roads not taken, what members are trusted with then, what is continuum's and what the application's, 69 attacks with the tests that show them, the registry's layout with moving in and writing out, fourteen stages, and ten open questions with a choice for each. future-work.md gets what the design leaves.
* screen: `Screening::of`'s doc on `of`tv42 hours1-1/+1
| | | | | `of`'s doc line sat above `policed`'s, as its first line, and `of` had none.
* screen: a test's actor named through `document`tv42 hours1-1/+1
| | | | | | The test of a value hiding the policy's place made its actor through `automerge::` outside `src/document`, which the test that Automerge stays behind `document` refuses. It names `document::ActorId`.
* screen: what is at the policy's place found in every map on the waytv43 hours2-5/+87
| | | | | | | | | | | | | | | | A node judges what it receives once anything is at the policy's place (`Screening::policed`), as a read shows it. But a read shows the newest of the values written at once at a key, merging maps only where that one is a map: a string written at `_continuum/access` beside the map holding the policy, and newer, hides it. So the policy's place read as empty, a change putting `"signed"` into the hidden policy went unjudged where it came alone, and deleting the string left a strict policy no change was refused for. Whether anything is at the policy's place is asked of every map of each key on the way to it, read or not (`store::held_anywhere`), as `store::by_seq` walks them. A swarm with nothing there is screened as before.
* docs: the strict remake among the kindstv2 days2-3/+4
| | | | | | 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.
* screen: what reads as no policy has what is received judgedtv2 days1-5/+47
| | | | | | | | | | | | | | | | | A node judges what it receives only once the document holds a policy, or a batch writes at a key named `policy` (`Screening::policed`); and an envelope holding `null` at the policy's place reads as none. So a change putting `"signed"` at `values` in a map beside such an envelope, writing at no key named `policy`, went unjudged where it came alone, and a later change deleting the envelope left a strict policy that no change was refused for. Nodes that took the second in one batch with others refused it, and the rest dropped it once told: apart until then, by how changes were batched. A node judges what it receives once anything is at the policy's place, whatever it reads as. A swarm with nothing there is screened as before; one whose policy's place holds what reads as none is judged by none but the rule that refuses turning strict, as a swarm without a policy is.
* docs/access: a strict policy given at genesis in the exampletv2 days1-3/+5
| | | | | | | The example of a strict policy wrote it through the API, which every node refuses where the policy isn't strict: a swarm turns strict only at its start or through a strict remake. It shows the genesis node given the policy, with its first user and their key.
* state: a strict policy written where none judges, refused before it leavestv2 days2-5/+26
| | | | | | | | | | | | | Every node refuses a change writing a strict policy where the policy isn't strict (`rules::turns_strict`), whatever the policy before. But a node judges its own changes before they leave (`judged_here`) only under a policy judging every change: in a swarm without one, a strict policy written through its API was taken there and refused by every other node, with everything the node built on it. A change that leaves a policy where there was none to judge it is judged as every node will judge it, too. A change in a swarm that has no policy after it is judged by none, as before.
* remakes: a map made on the way names no group's usertv2 days1-10/+79
| | | | | | | | | | | | | | | Under a strict policy a group of other writes goes as, and is named for, the last change by history that touched its path, at it, below it or above it. A change writing its first entry makes the maps above it on the way, and touches them: where two users wrote their first entries below one map at once, each making it, the later change touched the other's path, and the other's write was replayed as its user's, refused by every node, quarantined. The change a group goes as is the last that wrote at its path or below it, or replaced what was at a path above it (`last_written`): one that made a map above it, finding nothing there at its history, didn't. Swarms that aren't strict don't ask.
* policy: strict only where its values is a stringtv2 days2-34/+35
| | | | | | | | | | | | | | | The policy was read in typed JSON, so that an Automerge text spelling "signed" at its `values`, which no operation `rules::turns_strict` asks of writes, turns no swarm strict. But that read every policy anew: a setting that wasn't a string, or a text at `signatures`, made a policy no node knows in swarms that aren't strict, which read it as before. The policy is read in plain JSON again, as it was, and only its strictness asks more (`policy::of`): it reads strict only where its `values` is a string in typed JSON, an envelope read as its payload. A policy that would read strict only through a text, at `values` or holding the policy, is one no node knows. Every policy that doesn't read strict reads as it did.
* remakes: a group named for the change it goes astv2 days1-12/+3
| | | | | | | | Under a strict policy a group of other writes goes as the last change by history that touched its path, above or below it, but was named for the last that wrote at it or below: where the last replaced a map above the path, the group went as one change and was judged as another's user's. It is named for the change it goes as now.
* config: a strict bootstrap policy found as the document reads ittv2 days2-8/+14
| | | | | | | | A strict `--bootstrap-policy` is refused with `--remake`, but whether it was strict went by its JSON as given, where the node reads the policy as written into the document: a strict policy given as an envelope passed, and its genesis change was refused only once the node had started. Both now read it as written (`policy::as_written`).
* store: the policy's reading unmarked however it endstv2 days1-3/+9
| | | | | | | `signs_values` marks, for its thread, that the policy is being read, so that the reading doesn't ask itself again; a panic within it left the mark, and that thread read every strict place by Automerge's order from then on. The mark is now taken off when the reading returns or unwinds.
* policy: read only as continuum writes ittv2 days3-16/+72
| | | | | | | | | | | | | | | | | | | A swarm turns strict only at its start or through a strict remake, and a change writing a strict policy where the policy isn't strict is refused, found by its operations: `"signed"` put at the policy's `values`, or an envelope asking for it put at its place. But the policy was read in plain JSON, where an Automerge text reads as a string, and writing a text is no such operation: `{"$text": "signed"}` at `values`, through the typed API, turned a swarm strict that nothing refused, with a time before it nothing closes. The policy is read in typed JSON now (`store::read_plain_as`): what continuum writes there reads as it is, plain JSON or an envelope, and a text, a counter or bytes as itself, tagged; a setting that isn't a string makes a policy no node knows (`policy::read`), as a version it doesn't know does. So no text turns a swarm strict, and the operations `rules::turns_strict` asks of are the only ways to. A policy holding none of these reads as before.
* remakes: of one change, its other writes replayed before its linkstv2 days2-5/+23
| | | | | | | | | | | | Under a strict policy, links and other writes go by where their change is among those replayed, and of one change the links went first. Both were judged at that change's history, without the other; a link can only take away there what the other writes relied on (a capability revoked), never give what they needed, so they go first now. A group of other writes was placed by its last change by history but named the user of its newest by clock; it names the user of the last by history now, as it goes.
* rules: a swarm turns strict only at its start or through a strict remaketv2 days5-278/+91
| | | | | | | | | | | | | | | | | | | | | | A strict policy written into a running swarm left a time before it: changes written there, beside the turn, were refused by the nodes that took the turn first and taken by the others where they came first (a signed policy that isn't strict, among them, unseated the turn there); and a remake whose base preceded the turn had every switching node replay the turn as one of its own, each refusing the others'. A change writing a strict policy where the policy at its history isn't strict (`"signed"` at its `values`, or an envelope there asking for signed values) is now refused, in every swarm. A swarm turns strict at its start (`--bootstrap-policy`) or through a strict remake, each its epoch's first change: no change of a strict epoch is from before its policy, and the rule for the time before goes, with the walk that found the changes that turned a swarm strict and what kept them (`before_strict`, `turned_strict`, `Reads::strict_now`, `Reads::turned_now`, `store::writers`, `store::made`, `changes::in_history`). The strict swarm's simulation starts strict. access.md says so, and that a strict swarm can't move to a policy its nodes don't know by writing it.
* config: a strict swarm starts emptytv2 days2-7/+16
| | | | | | | | | | | | `--genesis --remake` writes the content as a change of its own before the one recording the first users and `--bootstrap-policy`. With a strict policy, that content change was a time before the policy, on which any member could build a change judged by none. A strict `--bootstrap-policy` with `--remake` is now refused: a swarm strict from its start starts empty, and one started from content turns strict through a strict remake, which keeps only what an operator looked over. A policy that isn't strict starts from content as before.
* continuum-signed: its reading of an envelope is best efforttv2 days1-1/+3
| | | | | | | The reference client's check of an envelope takes some strings the server doesn't (padded base64, a meta field twice, a number written as a float). Only a string crafted so, from before a strict policy, gets there, and the server answers `409`; the comment says so.
* store: one reading of the policy's placetv2 days1-48/+75
| | | | | | | | | | | | | | | | Whether values are ordered by `seq` (`signs_values`) read the policy's place itself, the first value alone and a map by Automerge's choice of each field, while the policy as judged (`policy::of`) read it through the store, which orders by `seq` only where `signs_values` says so, and merges every map there. They parted: a signed policy that isn't strict beside a newer plain one that is read as not strict for the one and strict for the other, and two maps, the newer without the field asking for signed values, the other way round. `signs_values` now asks `policy::of`, and the store orders the policy's own place by `seq` wherever any value there asks for signed values, and what is within the policy as written, so the two are one reading. Asked from within that reading, it answers false rather than ask again.
* remakes: other writes replayed with the links by historytv2 days2-24/+113
| | | | | | | | | | | | | | | Under a strict policy, the links of the chains to signed values went in the order their changes were made, but the other writes were grouped by time, and a link went before a group only where its time wasn't later. A write built on what a link grants (a capability in an entry its manager signed, a ban lifted, a declaration) went first wherever its clock was behind the link's, was judged where it wasn't granted yet, and was quarantined, though every node had taken it. Under a strict policy the other writes now go by where the last change that wrote them is among those replayed (`between`), with the links, and keep their times for later replays. Without a strict policy there are no links, and the groups go by time as before.
* rules: the changes that turned a swarm strict found once for its headstv2 days2-20/+58
| | | | | | | | | | | | Every change judged under a policy that isn't strict, in a strict document, walked back to the changes that turned it strict, each step reading every change the document holds. Only changes from the time before reach it in an honest swarm, but a member can send crafted ones at an old history, each costing every node a walk. The changes are now read once per walk (`store::made`), and what the walk finds is kept for the document's heads (`Reads::turned_now`), as whether its policy is strict is.
* rules: a strict swarm stays stricttv2 days2-25/+57
| | | | | | | | | | | | | | | | | A strict policy could be written over with one that isn't, or deleted, by a user who may manage the policy. While the swarm was relaxed so, nothing was asked of the time before it turned strict: a change written beside that turn was taken, and once the swarm turned strict again, built on, a node judging that change while strict from the first turn (one back from away, a joiner) refused it, and every node it told dropped it with the second turn and everything after. Under a strict policy, the policy is now written again only as strict: an envelope there whose value isn't a strict policy, a signed `null` among them, is refused. So a strict swarm has one change that turned it, and the time before it stays closed; to leave it, start a new swarm from its content. A swarm that isn't strict writes its policy as it did.
* access: a new swarm's policy where it starts from contenttv2 days1-1/+3
| | | | | | | | `--bootstrap-policy` records the policy in the genesis change, "no change of it from before the policy". With `--genesis --remake`, the content is a change of its own before the one recording the users and the policy. access.md says so, and that a change built on the content beside that one is refused as from the time before a strict policy.
* continuum-signed: an envelope read as the server reads onetv2 days1-15/+36
| | | | | | | | | | The reference client took any stored string beginning `cv2.` for an envelope: it named it as replaced and numbered after it, where the server reads a string that isn't an envelope in every respect as a plain value, replaced by an envelope naming nothing (`prev` empty, `seq` 0), and answered `409`. It now asks what the server asks: four parts, each in base64url, the value one line of JSON, the meta one line with its six fields and no more.
* rules: the document's own policy read once for its headstv2 days1-4/+19
| | | | | | | | | Every change judged under a policy that isn't strict, in every swarm, read the document's own policy to ask whether the time before a strict policy applies: in a swarm without a policy, where a change was judged for nearly nothing, a read of the policy for each. It is now read once for the document's heads and kept while the batch is judged at others (`Reads::strict_now`), read again once the document takes more.
* store: values ordered by seq as the policy a read shows saystv2 days2-25/+86
| | | | | | | | | | | | | | | Whether values are read by `seq` went by whether any value at the policy's place asks for signed values, not by what the policy reads as. Where the place holds two, they part: a signed policy that isn't strict read before a plain one that is, or two maps, the newer not strict. Such a swarm judged as not strict and read by `seq`. Now the policy's own place is read by `seq` where any value there asks for signed values, so an older policy put back beside a strict one can't undo it; every other place is read by `seq` only where the policy that read shows is strict (`policy::read`, which `policy::of` reads with). A swarm whose policy doesn't read as strict reads every place as Automerge has it.
* remakes: a signed place already held is kept like any write that losestv2 days2-11/+20
| | | | | | | 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 madetv2 days2-33/+149
| | | | | | | | | | | | | | | | | Under a strict policy, the links of the chains to signed values were ordered across places by their changes' timestamps. How a link is judged in the new epoch depends on what was replayed before it: a key added to a user's entry, a capability granted. A write signed with a key added a moment before, through a node whose clock is behind, went first, was refused and quarantined, though every node had taken it. The changes replayed (`between`) now come each after those it builds on, clocks deciding only between changes neither of which saw the other, then the lower hash; the links follow that order, and an envelope takes its time from the first change that wrote it there. remakes.md says so, and what becomes of a place where a link is refused. Without a strict policy there are no links, and nothing changes.
* remakes: a chain replayed to what its part of the replay ends attv2 days1-4/+51
| | | | | | | | | | | | | A rejoin replays in two parts: what was written before it began, then what was written during it. A chain to a signed value was read to what the old document reads now, from the envelopes written within the part: a value written again during the rejoin made the first part's chain lead to an envelope that part doesn't hold, and the second part's start from one it doesn't either. Both were quarantined, and the new epoch kept the base's value. Each part's chain now leads to what the old document reads where that part ends.
* rules: the time before strict is the change that turned it, written again or nottv2 days4-42/+146
| | | | | | | | | | | | | | | | | | | | | | | | | | A change written under a policy that isn't strict was refused, in a strict document, unless it was in the history of the change that wrote the policy value the document read now. So the policy written again by a node that held a change from before, taken beside the strict policy, put that change in the new writer's history: that node kept it, every other node refused it, and the new policy with it, and the node was cut off. Now the reference is the change that turned the swarm strict: one that wrote a strict policy where the policy at its history wasn't, found by following back the writes of what the policy holds (`store::writers`). A change written under a policy that isn't strict is refused where such a change is beside it, neither in its history nor built on it. A policy written again, strict over strict, names the same change. One turning the swarm strict beside it is refused like any other. Of two at once neither is preferred: any rule choosing one, the lower hash say, would let a change made later to look as old take the place of the one every node took, and every node would drop it with all that was built on it. So two members turning a swarm strict at once split the nodes that took one from those that took the other; access.md says to turn it from one.
* access: what revoking doesn't stop under a strict policytv3 days1-3/+10
| | | | | | | | | | A change is judged as its writer saw the document, and its writer chooses what it saw. So a capability revoked, a user disabled or a key removed holds against members that weren't members before it, but a member that was can still commit, at a history from before, an envelope the user signed then, and the next, as far as it likes; the highest `seq` is the place's value. A remake ends it. access.md says so where it says what signed values keep out.