| Commit message (Collapse) | Author | Age | Files | Lines |
| ... | |
| |
|
|
|
|
|
|
|
|
|
|
|
| |
A node taken off its party's list is a member at a history from before:
a remake's record, proposal and decision it writes there are taken, and
every node listed at its base follows, the snapshot listing the node
again until the list that took it off is replayed. "The next remake's
base" could be its own.
A node follows a remake only where the coordinator's party lists the
coordinator, as the node reads it when it switches; and what a node
taken off its list commits from a history before ends with a remake
whose base holds that list.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
Continuum lets a member ack another remake of its epoch only once the
first is aborted, and in a federated swarm only the coordinator aborts:
a coordinator gone after proposing stalled every remake of its epoch.
Read the other way, as a remake left undecided binds nobody, members
moved on, and a coordinator back late decided beside the remake they
moved to: two decisions, from honest nodes alone.
Acks bind nobody: a member may ack another remake without the first
aborted, and an honest coordinator decides only while the acks it counts
are still for its remake.
|
| |
|
|
|
|
|
|
|
|
| |
A place's value is read among the envelopes a key their party holds
signed, but a remake's snapshot, a fork's genesis and the replay held
what the old document "read as", which continuum's merged view has as
the first of all the envelopes there, by `seq`: a builder reusing it
would keep a dropped key's envelope ahead of the party's, and nothing at
the place would count in the new epoch. Each holds, and replays to, the
place's value as the federation reads it.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
An operator may have its node drop what it took, and nothing said the
node refuses it afterwards: a peer that still holds it sends it again,
and the node, holding the votes that passed a dropped version, writes
it again itself, as a node writes any version it holds passed. So the
version a node left behind by a remake dropped came back before it
switched, and either side of keys that voted twice took again what it
dropped until it held the other side.
In that epoch a node refuses the changes its operator had it drop, from
whoever brings them, and writes no version among them again, until its
operator says otherwise.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A party's `true` on two proposals of one version was voting twice where
both passed, or neither was dead by all the votes. But a party's `true`
and `false` on one proposal both count, so one proposal can be passed
and dead at once: another party's late `true` beside its `false` made
every party that went on to the second proposal, once the first was
dead, look as if it had voted twice.
Two `true`s are voting twice only where neither proposal is dead by all
the votes. A death is never taken back, so an honest party's first
proposal is always dead by all of them; and where two versions changing
one were written, the party whose `true` and `false` made a proposal
passed and dead is named. "Why it holds" says the same.
|
| |
|
|
|
|
|
| |
Acks stay continuum's, by node, but in a federated swarm a node follows a
decision it can build without counting them, so what they decided was
nobody's to say. They tell an honest coordinator when to commit, so that
fewer nodes are away; they are no safeguard.
|
| |
|
|
|
|
|
|
| |
A remake that races a version leaves the nodes that took it in the old
epoch. Its operator moves such a node without a fork or an empty
document: it has the node drop the version it took, the base then holds
the version it reads, it switches, and the new epoch writes the version
again from the votes replayed, as any node writes one it holds passed.
|
| |
|
|
|
|
|
|
|
| |
Forks are what any group carries on by, and promise 3 rests on them;
remakes are there only for Automerge's sake. Forks come at stage 4 and
remakes at stage 5: until then a federated swarm that grows too large
starts afresh by a fork whose version names the same parties, keys and
rules. And a writer forked splits the nodes for good only until stage
2, where an operator may have its node drop what it took.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A version setting a party's keys or node list had the change writing it
write an envelope without a signature at the party's place, `prev`
empty and `seq` 0, and only that change, so that it was ahead of every
set before it: a kind of envelope of its own, a rule on who writes it,
the same written again with the version, and a genesis and a fork
writing them too.
Each version gives, for each party's keys and node list, the number of
the version that named them anew (`since`): its own where it does, else
that of the version it changes. A party's keys are those of its set
where the set names a version numbered at least that; otherwise those
the version names; its node list the same. Nothing is written for it,
the document holds no envelope without a signature, and what a key an
earlier version named writes at a history from before still counts no
more.
|
| |
|
|
|
|
|
|
|
|
|
| |
Where keys voted twice, or a writer forked, each node kept what it took,
and the sides came together only by a fork, a node with an empty
document, or its peers' word. An operator may have its node drop a
version, or any change, with everything built on it, as continuum drops
a change its node took and the rules refuse (`drop_taken`), and take
what the others hold: no peer's word moves a node, its operator's does.
So either side may join the other without what parts them, as the
design request asked, without a fork.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
Which federation a swarm follows is in each version, not in its policy's
place; a fork's first version changes the one current at its heads, not
`null`; a place given back shows what its party signed before only where
nothing replaced it since; a remake's snapshot is a function of its base
and its record, so two remakes at one base are two epochs; honest nodes
agree once they sync but where keys voted twice, a coordinator decided
two remakes, or a writer forked; and what a node taken off its list
commits from a history before ends with the next remake's base, as no
later version orders it.
|
| |
|
|
|
|
|
|
|
| |
Every writer costs every node memory for as long as the epoch lasts, and
nothing bounded the writers a node starts: one listed node starting one
with every change runs every other out of memory before a remake could
be built, which the design called slow, not wrong. A federated swarm
bounds the writers a node starts in an epoch, judged at a change's
history as any rule is: a rule, and stage 1's.
|
| |
|
|
|
|
|
|
|
|
|
| |
A node reported a party that voted twice, judging each copy of its votes
by the history it was taken at, so that a vote committed again elsewhere
framed nobody; and the next remake left those histories out. The votes
alone tell it: a `true` and a `false` on one proposal, or a `true` on two
proposals of one version where both passed or neither is dead by all the
votes cast, as an honest party backs another only once the first is
dead. A tool over the votes the parties' clients keep reports it, later
too; a node reports the versions it refused.
|
| |
|
|
|
|
|
|
|
|
|
| |
A node took tokens from the nodes its party lists, and without a user
registry every user it lets in may do everything. A party's list is
written by a key its version names, or set by a version: so two thirds
of the parties, or a thief of that key, could list a node of their own
as the party's, issue a token under any name there, and have the party's
own nodes take it, against "the design rules nothing about what happens
on a party's own nodes". A node takes only its own tokens; a party logs
in to each of its nodes.
|
| |
|
|
|
|
|
|
| |
A node holding two versions that change the one it reads, having taken
neither, took neither until its operator named one. But where one comes
first it is taken anyway, and two come together only by how a sync
message was cut: the state, and the endpoint naming one, guarded
nothing. A node takes the first it judges.
|
| |
|
|
|
|
|
|
|
|
|
| |
A replay puts changes neither of which saw the other by their clocks.
A party's `true` committed again at a history before the nays that freed
it, its clock set between, came before those nays in the replay and was
refused, though the old epoch took it: a proposal that passed there might
not pass in the new one, and a party not finding its vote might vote
again. What the new epoch refuses is tried again once the rest is
replayed, and a party's client keeps what its party voted and votes by
that, never by what a node shows.
|
| |
|
|
|
|
|
|
|
|
| |
A proposal is taken whatever its text, and asked whether it is a version
only where it is written as one. One that isn't is voted on, never
passes, and dies only by nays: two thirds backing it bind the federation
to its version for good, and a client reading JSON otherwise than the
nodes backs what no node writes. A node shows whether a proposal is a
version by the federation it knows, and a party's client backs none
that isn't.
|
| |
|
|
|
|
|
|
| |
Without a user registry, every user a node lets in may do everything,
and `--protocol-writers` say who writes protocol data; what of that held
in a federated swarm the design didn't say. Whoever a node lets in may
have it commit what the rules take, envelopes and the node's own
protocol data; `--protocol-writers` names nobody.
|
| |
|
|
|
|
|
|
|
| |
Nothing bounded a version, a key set, a node list, a path or a value: a
version larger than a sync message carries would be written where it
passed and reach nobody, and nodes built with different bounds would
take different changes. The sizes each may have are the federation's
number's, each within what a sync message carries, and stage 1 sets
them.
|
| |
|
|
|
|
| |
A node follows a remake only where it is a member at the base: listed
there, or listed and registered, the design didn't say. Listed: a node
its party listed registers in the new epoch as it would have in the old.
|
| |
|
|
|
|
|
|
| |
Any member wrote a passed version; when, and which, the design didn't
say: every node that sees it passed, the one that took the last vote, or
one after a wait. A node writes it as soon as it holds it passed; the
same version written by several is one, as a node takes a version it
took written again.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A federation's genesis change, judged by none, was its founding node's:
what else it held (values at places, votes) nobody checked, and the
swarm's name was the one its node drew or remembered, so two federations
started under one name took each other's envelopes. It is built byte for
byte from the first version alone, as a fork's genesis is from its
version and heads, and holds the policy, the swarm's name, the version
and what it sets, nothing else; the swarm is named by the version's
hash, and a node joining builds the genesis and checks it. The genesis
writes no topology: a federated swarm runs continuum's own.
|
| |
|
|
|
|
|
|
|
|
| |
A fork's genesis left out what a snapshot does, the federation's versions,
member entries and the swarm's name. It didn't say what of continuum's
other data it holds (remake records, acks, earlier epochs' metadata), nor
whether what counts no more is read by the fork's first version or the one
current at its heads: two founders deciding apart build two swarms where
one is meant. It holds none of continuum's own data, and reads what
counts no more by the version current at its heads.
|
| |
|
|
|
|
|
|
| |
A party writing first where another's envelope is (a place given to it,
an envelope a dropped key wrote) could name that one as replaced, `seq`
one more, as judging at a change's history needs, or start anew; two
builders deciding apart would refuse each other's envelopes. It names
that one.
|
| |
|
|
|
|
|
|
|
|
|
| |
A change wrote nothing where rules say who writes but `@` keys and the
maps on the way to them, never deleting or replacing one. It didn't say
that a map is made only on the way to an `@` key the same change writes:
one builder would take any member's maps in any party's namespace, left
empty for good, another wouldn't. Nor that a map is made only where none
is: a map made where one is, naming it as replaced, hides what it held,
votes under `_continuum/federation` among them. Both are said, for the
federation's own paths too.
|
| |
|
|
|
|
|
|
| |
Where a rule's `{party}` segment met a segment naming no party, one
builder would match it with a writer that is nobody, another wouldn't
match and let a later rule decide, and the two would judge a write at
`names/r/foo` apart where a `names/r/*` rule follows. It doesn't match,
which is the reading the wiki example needs.
|
| |
|
|
|
|
|
|
|
| |
Where a party's `true` and `false` on one proposal are both in one
history, the design didn't say whether it voted yes, no, both, or what
the place read as; one builder's node would take a version, or another
party's next `true`, where another builder's refused it. Both count:
then a history that holds more votes never takes back a pass or a
death.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A remake's decision was its coordinator's alone, but a member could abort
a remake that expired, as each node's clock said: the one place the
design waited on time. And a coordinator writing two decisions for one
epoch, showing each to some nodes, left honest nodes in two epochs for
good, as continuum's following of most peers, and rejoining sideways,
are gone.
The abort is the coordinator's too, and a remake left undecided binds
nobody. A node holding two decisions for its epoch follows neither, says
so, and leaves it to its operator; on its operator's word it builds the
remake named of the epoch before its own, from the old document it
keeps, and switches, what it wrote since replayed. Not promised and
Attacks say so.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A place's value was the first of all the envelopes it held, by version,
then `seq`, and it counted only while its key was its party's. So a key
the party had dropped, by a member committing at a history from before
the drop, wrote ahead of the party's envelope, replacing it, with a
higher `seq` each time the party wrote again: nothing at the place
counted until a version named the party's keys anew.
A place's value is the first of the envelopes there that a key their
party holds signed; judging, and the envelope a `prev` names, go by all
of them as before. And a party signs again what should stay after the
set that drops a key, not only before: what the dropped key writes at a
history from before can't name that as replaced, and counts no more, so
it takes nothing out.
|
| |
|
|
|
|
|
|
| |
Screening judges a batch at a frontier that every change touching what
the rules read moves, or a later change of the batch is judged at heads
it doesn't hold: stage 1 moves it for what the federation reads too. And
a node syncs with members only, but is one only once its own entry names
its party: stage 3 shows the party in the handshake before that.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
A node switches only where the version it reads is written at the base.
So a node that switches took no version written after it, and what it
replays names the version current at the base, or one before: the
replay of versions, each in one change with what it sets, after the
votes that passed it and whatever names the version before it, was
there for no node. It goes, and with it two `true`s cast at once,
replayed one after the other, undoing a version that passed.
The version a node reads is asked as it reads it when it switches: one
it takes while it builds the snapshot leaves it where it is, as one
taken before.
|
| |
|
|
|
|
|
|
|
|
|
| |
A node leaves its epoch only for one it built itself from a base it
holds; but continuum stops syncing the old epoch once it switched, so a
node away across a switch lacked some of the base and stayed until its
operator moved it, on most remakes where nodes come and go.
A node syncs the old document with nodes still on that epoch for as long
as its own setting keeps it, and a node that lacks some of the base
syncs it from them, each change judged there, and builds then.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
A node holding the old document left an epoch only for one it built
itself, but took a fork's heads' history, where it lacked some, on its
peers' word: a founder could name heads holding a change it sent nobody,
a version written without votes say, and the genesis would carry what
that change set. A node holding the old document takes a fork only where
it holds the heads' history, syncing what it lacks from the old swarm,
each change judged there; otherwise it says it can't check and leaves it
to its operator. Only a node with an empty document takes a fork on its
peers' word, as it takes an epoch.
|
| |
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
| |
"Would" read as a promise someone might rely on; whether a key added
again brings anything back is nothing the design says.
|
| |
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
- 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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
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.
|