aboutsummaryrefslogtreecommitdiffstats
path: root/docs
Commit message (Collapse)AuthorAgeFilesLines
* docs/store: an epoch ID ground below the honest onetv24 hours1-0/+1
| | | | | | | As any member may decide a compaction, and the lower of two epochs for one is followed, a member can grind a remake's ID until its epoch's is lower, and have every node on the honest epoch rejoin, once a generation. No event is lost, as a node that rejoins puts again what it held; the attack table says so.
* docs/store: the changes every node buildstv24 hours1-11/+19
| | | | | | | | | | | An epoch's first change, and a fork's changes after it, carry no node's signature, so the rule that a change carries one now sets them aside. Their writer, derived from the root or from the remake, is one anyone can compute, so it writes exactly the changes every node builds, and any other change under it is refused: nobody commits a change of that writer and number before the one every node builds, and parts the nodes. The genesis change writes the policy (a map, keys sorted), the swarm's ID (a string) and the root, in that order; a fork's kept events fill its later changes in the order of their IDs, each up to 1 MiB of events.
* docs/federation-tests: one document for honest nodestv24 hours1-1/+2
| | | | | As the document judges structure alone, the store on Automerge is also checked for honest nodes holding one document, whatever each takes from it.
* docs/federation: what a party's client keeps, and checkpoints held backtv24 hours1-11/+22
| | | | | | | | | | With each `true` it casts, a party's client keeps the votes that made its party's earlier proposal dead, so that once a checkpoint left them out, nothing names its party as voting twice; and a party votes from one client, as two backing two proposals at once is voting twice. A node proposing a checkpoint by itself waits only for proposals that can still pass, and one that nobody but its party backs is ended by the nays of the party a node follows and its followers. Stage 3 builds the client: signing events, keeping its votes and the nays that freed it, and signing again what a move refused.
* docs/federation: what a fork's root can be checked for, and merges by IDtv24 hours1-14/+16
| | | | | | | | | | Nothing in a fork's root says who started it, so its version is no longer held to naming anew the node lists of the parties that start it; its founders name theirs, so that their nodes are members. A merge's kept events are in none of each other's histories, so a place its party wrote on two sides counts the lower ID, whatever either side's history held, alike for nodes that check the root and nodes that take it on their operator's word. What the federation asks of the store says forks of one store or several, as the store does.
* docs/federation: what a checkpoint keeps, its heads, and joining from onetv24 hours1-33/+53
| | | | | | | | | | | | A checkpoint keeps the events that count at its heads but version events, as it holds the version itself, and a version event of it that comes later is one a node took. Its heads are events after the current checkpoint, none in another's history, ascending, one at least, and a proposer names heads it has held for a while. Once a checkpoint passed, a node joins from a pinned one: from the root, keys long replaced could grow another chain, and node lists naming only their own nodes would seal a joining node in it; a node still joining that is shown two versions changing one takes neither. A node drops only what it took after its checkpoint, and undoes a move only by a pin; a version named again where it isn't above its checkpoint's heads isn't taken.
* docs/federation: an event's bytes, and the sizes federation 1 allowstv24 hours1-11/+24
| | | | | | | | | | | | `key` is `ssh-ed25519`, one space and the key's padded, canonical base64; `sig` the SSHSIG blob of version 1, hashed with `sha512`, whose key is `key`, in padded, canonical base64, checked strictly as continuum checks a user's signature. An event whose `key` or `sig` doesn't read back to itself is none, so nobody but its signer makes another event, under another ID, of what a party signed. Federation 1 allows events of up to 256 KiB with up to 64 dependencies, 16 keys a party, node lists of up to 64 nodes, paths of up to 32 segments of up to 255 bytes, and in values integers within 2^53 and whole Unicode characters. A party's name is a user name, `@` among its characters.
* docs/store: forks in the fold, and the bytes of genesis changestv24 hours1-12/+26
| | | | | | | | | | The fold makes a fork's root, from the states at heads of one store or several and what makes the fork; a node checks a fork's root by it. The state carries what judging needs of history, as the federation's carries the graph of its events, and the state is the same for the set a node takes, which its own refusals may make depend on order. The root is taken before the fold sees any event. A genesis change's writer is the first 16 bytes of the root's ID, and a fork's kept events follow its genesis change in changes of up to 1 MiB, in the order of their IDs.
* docs/store: checkpoint heads, drops around them, and joiningtv24 hours1-25/+36
| | | | | | | | | | | | A checkpoint's heads are events after the store's checkpoint, none in another's history, and are held by their IDs after the move, so that what builds on them is taken; "above" says so more plainly, and that no head is above its own heads. A node drops only events after its checkpoint, as every later event builds on what the checkpoint keeps, and undoes a move only by a pin. Until the next remake the document holds what a node forgot, and a node away syncs it; after it, a node that can't build the checkpoint pins it. A node joins from a pinned checkpoint, and from the root only a store that never moved: from the root, what came before a checkpoint can be grown anew by what the fold refuses since.
* docs/store: remakes a store needs nothing fromtv24 hours1-32/+36
| | | | | | | | | | | A remake changes no event, so of two epochs decided for one a node follows the lower ID, and a node on the other rejoins it: no operator has to name one. A node follows a decision whichever node coordinated it, as a decision reaches it only through a member. Old epochs are no longer synced: a node that lacks the base rejoins, keeping its own checkpoint and reading what is above its heads, and a later checkpoint it can't build it takes where its operator pins it. After a switch a node puts again only what the new document lacks, after a random wait. An epoch's first change writes the policy too, and the snapshot leaves out events nobody takes.
* docs/store: the document judges structure, the store judges eventstv24 hours1-41/+45
| | | | | | | | | | | | | | A change of a swarm holding a store is judged by what it is alone: it puts new keys under `_continuum/events` whose bytes hash to them, writes its node's own protocol data, carries its node's signature and is one Automerge writes. The store reads the events the document holds and takes them as it would from anywhere, each once it holds its dependencies, judged at its history; the rest stays in the document until the next remake. So a fold's verdict, a node's own refusal or a checkpoint refuses no change, nodes no longer drop and rebuild their documents at a move, and honest nodes hold one document whatever each reads from it. Membership is no longer judged at a change's history; a node keeps its own refusals and drops in a file of its own. Events are put again only where continuum refuses a change on its own, as of a writer's two changes of one number.
* docs/federation-tests: how the store and the federation are testedtv24 hours3-2/+152
| | | | | | | | | | | A plan, the contract the code is built to: the fold and the store tested as pure code, events in and verdicts and states out; a model written plainly from the design, which the store is checked against; every rule by its smallest scenarios; every attack row a test named by its table and number, and a test that every row has one; the promises as properties over generated histories, every order for small ones and seeded ones beyond, cut down before they are printed; the store on Automerge checked against the store in memory; simulations with an adversary node; fixed vectors for every encoding; fuzzing and mutants in longer runs. All of it behind the `federation` feature, by stage.
* docs/store: a remake whose base comes before a checkpointtv24 hours1-7/+11
| | | | | | | | | A node that moved to a checkpoint after a remake's base, and switches to it, would have refused the snapshot for the events it forgot, and stayed apart from the nodes that switched. It keeps its own checkpoint instead, and reads none of what the snapshot holds that its checkpoint forgot, as it reads none of it in the old document; only its own refusals and its operator's drops keep it where it is. A snapshot's checkpoint before its own is one it takes.
* docs/federation: mergestv25 hours1-9/+45
| | | | | | | | | | | | | Groups that parted come together by a fork at heads of several stores, which merges them. Its version's `changes` lists the versions current at those heads and is numbered one past the highest; it names every party's keys and node list anew, so that no key set or list of any side counts; and its root keeps, of each side, the values that count there at places the merge's version gives their party. A value counts in the merge once the key that signed it is among its party's keys there, so a key one side dropped brings back nothing unless the party lists it again. A party's place written on two sides leaves the lower ID until it writes again; an identifier given to different parties goes by the merge's rules. Merging in place, both stores voting to move to one checkpoint, is a road not taken.
* docs/store: merges, forks at heads of several storestv25 hours1-9/+11
| | | | | | | A fork's root may be a checkpoint at heads of several stores, which merges them: it keeps what its fold takes of each. A node holding the history up to all those heads builds it and checks it, and one that doesn't takes it on its operator's word, as with any fork; neither the fork nor the stores it came from take each other's events.
* docs/federation: votes a node casts by itselftv25 hours1-8/+44
| | | | | | | | | | A party may have one of its nodes vote and propose for it, by rules its operator sets and nowhere written in the swarm: following a party it names, backing what that party proposed or backed and voting `false` where it did, by default on versions that only move to a checkpoint; and proposing such a version once conditions its operator sets are met, where nothing else is proposed. The node keeps to what a party's client keeps to, one node a party votes by itself, and it holds a key the party's version names, which a thief takes with it.
* docs/federation: checkpoints the parties passtv25 hours1-85/+143
| | | | | | | | | | | | | | | A version may name heads for a checkpoint: what counts there written down, as those heads, a version and the IDs of the events that count there. Once a node takes the version, it moves to the checkpoint, forgets what came before but what it keeps, and refuses every event not above the heads. The proposal, its votes and the version events writing it must be above them, so that moving refuses nothing that decided it. Judging after a checkpoint reads only what counts, which it keeps; what it loses is what counted no more before it, and what isn't above its heads, which its party signs again. A federation's root is its first checkpoint, and a fork's root a checkpoint at the heads it forks at, which nodes holding that history check and others take on their operator's word. A node checks everything back to its checkpoint, which it built itself or its operator pinned. Checkpoints any member makes are a road not taken.
* docs/store: checkpointstv25 hours1-76/+147
| | | | | | | | | | | | | | | A store holds a checkpoint, the state at some heads written down (those heads, the events before them its fold keeps, and what the fold says of the rest), and the events after it. The fold says when a node moves to a later checkpoint: the node builds it itself, forgets what it doesn't keep and every event whose history lacks its heads, and refuses such events from then on, so that it holds what is relevant and nothing else. A checkpoint a node can't build, as it was away too long or joins, it takes only where its operator pins it. A store's root is its first checkpoint, and a fork's root a checkpoint at the heads it forks at, which nodes holding the history up to them check, and others take on their operator's word. On Automerge, a remake's snapshot holds the store as it is at the base, so what a checkpoint forgot leaves the document there.
* docs/federation: the design on the storetv26 hours1-635/+409
| | | | | | | | | | | | | | | | | | | | The federation is the store's fold. What a party signs is an event: a JCS object naming its dependencies, signed with an SSH signature by one of its party's keys, or by nobody for a federation's root, a fork's and a version. An event names no swarm, no version and no place in the document: its history says which store it is in and which version it is written under. A place is a path a rule matches, its value the latest write its party signed there that counts: one that no other counting write there has in its history, and of several the one with the lowest ID. Key sets and node lists are read the same way. A vote, proposal, key set and node list is an event of its own kind, a passed proposal takes effect by a version event, and a node takes a version only where it changes the one it reads, as before. A fork is a store whose root builds on the heads it forks at, carrying their history, so that any node checks it from its events alone. What carries the store, its document and its remakes, the federation leaves to `docs/store.md`, with the promises and attacks about them; the attacks left are numbered anew.
* docs/store: a store of events, generic over its foldtv26 hours1-0/+306
| | | | | | | | | | | | | | | | | | | A set of events that only grows, each named by the SHA-256 of its bytes and naming those it builds on, judged at that history so that every node judges it alike, and read together as one state. What the events are, how one is judged and what they read as is a fold's, a trait the federation is the first to implement. Its first home is a swarm's Automerge document: each event is bytes at `_continuum/events/<ID>`, a change writes events and continuum's protocol data only, and a node puts again every event it doesn't refuse of a change it refuses or drops, so that which change carries an event changes nothing. A compaction's snapshot holds the events at its base, and every event beyond it is put again: remakes, rejoins and a writer's two changes of one number change no event a node holds, and the fold never sees them. It says what is promised, a node's own refusals and drops, forks carrying their root's history, members by the fold, where Automerge sets limits, its attacks, and what its tests check. Nothing of it is built; all of it is to be behind the `federation` feature.
* federation: "Why it holds" on a version written againfederation-2tv28 hours1-10/+10
| | | | | | "Why it holds" said a node takes a version only where it changes the one the node reads, where the design has it take one it took, written again, too.
* federation: what a snapshot leaves out, said as it now istv28 hours1-4/+6
| | | | | | | | What counts no more stayed, the text said, until a snapshot or a fork's genesis left it out where it is or names a version before the current one. But each holds a place's value alone: an envelope that isn't it, behind another or a dropped key's, goes whatever version it names, and a key added back brings back what it signed within the epoch only.
* federation: every party a node list in every version, the example tootv28 hours1-6/+7
| | | | | | | | Since a party new in a version has its list named anew there, every party has a list in every version from the one that let it in; the field said lists were for the parties a version named one for. The example gave makefu, its keys named anew at 7, none, and was no version. The field says every party's, and the example gives makefu an empty list since 7.
* federation: a decision nobody follows is none of twotv28 hours1-5/+7
| | | | | | | | | A node follows no remake whose coordinator its party doesn't list, but a node holding two decisions for its epoch followed neither, whatever they were: a node taken off its list, by deciding a remake nobody follows, still kept every node holding its decision from following an honest remake of that epoch, until operators named one. A decision whose coordinator isn't listed is none of the two.
* federation: a dropped version refused however it is writtentv28 hours1-5/+5
| | | | | | | | | A node refused the changes its operator had it drop. But any member writes a version once it passed, and a change writing the dropped version anew, by a lagging node by chance or a listed adversary at will, was none of those: the node took it, as it changes the version the node reads, and a node its operator was moving across a remake stayed. The node refuses any change writing a version among those it dropped.
* federation: no bound on the writers a party's nodes starttv28 hours1-25/+22
| | | | | | | | | | | | | | The bound was judged at a change's history, as any rule is, so it counted only the writers in that history: writers started side by side, each at a history holding none of the others, were each within it, and a party flooding on purpose passed it as often as it liked. Counted for a party, it let one node gone wrong use up the room of all its party's nodes for the rest of the epoch. It goes. A party whose nodes start writers without end runs the others out of memory: denial of service, which breaks no promise. Its writers name its node, and the node's entry its party; a remake leaves an epoch's writers behind, and the others fork without the party.
* federation: what an end-to-end read found at oddstv28 hours1-26/+28
| | | | | | | | | | | | | | | | | | | | | Read whole after the last series of changes, the design said a few things that no longer fit what it says elsewhere: * the example's version 7 named lass's keys anew at 4 but gave lass no node list, where a party new in a version has its list named anew; * a remake reaches no node that can't build it, nor one that isn't to follow it (not a member at the base, its coordinator unlisted); * the clause on whose word follows a decision sat after a colon meant for the abort; * what a node taken off its list could commit before a base ends with the remake only where the base holds that list; * a remake racing a listing leaves behind the nodes listed since the base, not "the nodes that took it"; * "Why it holds" now names the coordinator's listing; * attack 29: a node that lacks the base syncs it where a peer keeps it; * forks come at stage 4, so before it no swarm starts afresh by one; * a party drops a stolen key of its set itself; only one its version names takes a version.
* federation: wordings left from the last changestv29 hours1-20/+21
| | | | | | | | | | A version's `since`, where it doesn't name a party's keys or list anew, is the `since` the version it changes gives the party, not that version's number. A version written again is one a node took, and every node takes it however often it is written. A forked writer's nodes are apart until operators have one side drop what it took, or a fork. And a fork's genesis leaves out continuum's own data, earlier epochs' metadata among it, which a second clause said again.
* federation: a party new in a version, its node list named anewtv29 hours1-1/+4
| | | | | | | | | A list had a `since` only for a party a version named one for. A party taken out and let in again within an epoch had none unless the version named it a list, so the list it left, signed with the keys it had then, counted again at once, while its key set, its keys named anew, didn't. A party new in a version has its list named anew there, empty where the version gives it no nodes.
* federation: the writers a party's nodes start, boundedtv29 hours1-6/+8
| | | | | | | | | The bound on writers was a node's, and a party lists the nodes it likes, a new list one envelope: the flood the bound was for cost a party a list now and then. The bound is a party's: the writers its nodes start in an epoch together, by the party each node's entry names, judged at a change's history. Its figure leaves room for the writer an honest node starts each time it starts, rejoins or drops, until a remake.
* federation: no remake followed whose coordinator its party no longer liststv29 hours1-6/+9
| | | | | | | | | | | | | 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.
* federation: acks bind nobody in a federated swarmtv29 hours1-4/+6
| | | | | | | | | | | | | 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.
* federation: a snapshot keeps each place's value as the federation reads ittv29 hours1-34/+36
| | | | | | | | | | 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.
* federation: what an operator had its node drop stays droppedtv29 hours1-4/+7
| | | | | | | | | | | | | | 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.
* federation: two `true`s voting twice only where neither proposal is deadtv29 hours1-11/+14
| | | | | | | | | | | | | | | 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.
* federation: what acks are for in a federated swarmtv35 hours1-3/+5
| | | | | | | Acks stay continuum's, by node, but in a federated swarm a node follows a decision it can build without counting them, so what they decided was nobody's to say. They tell an honest coordinator when to commit, so that fewer nodes are away; they are no safeguard.
* federation: a node a remake left behind for a version, moved by its operatortv35 hours1-4/+7
| | | | | | | | A remake that races a version leaves the nodes that took it in the old epoch. Its operator moves such a node without a fork or an empty document: it has the node drop the version it took, the base then holds the version it reads, it switches, and the new epoch writes the version again from the votes replayed, as any node writes one it holds passed.
* federation: forks before remakestv35 hours1-7/+8
| | | | | | | | | Forks are what any group carries on by, and promise 3 rests on them; remakes are there only for Automerge's sake. Forks come at stage 4 and remakes at stage 5: until then a federated swarm that grows too large starts afresh by a fork whose version names the same parties, keys and rules. And a writer forked splits the nodes for good only until stage 2, where an operator may have its node drop what it took.
* federation: what a version names anew, by a number, nothing unsignedtv35 hours1-99/+99
| | | | | | | | | | | | | | | | | | A version setting a party's keys or node list had the change writing it write an envelope without a signature at the party's place, `prev` empty and `seq` 0, and only that change, so that it was ahead of every set before it: a kind of envelope of its own, a rule on who writes it, the same written again with the version, and a genesis and a fork writing them too. Each version gives, for each party's keys and node list, the number of the version that named them anew (`since`): its own where it does, else that of the version it changes. A party's keys are those of its set where the set names a version numbered at least that; otherwise those the version names; its node list the same. Nothing is written for it, the document holds no envelope without a signature, and what a key an earlier version named writes at a history from before still counts no more.
* federation: an operator may have its node drop what it tooktv35 hours1-6/+18
| | | | | | | | | | | Where keys voted twice, or a writer forked, each node kept what it took, and the sides came together only by a fork, a node with an empty document, or its peers' word. An operator may have its node drop a version, or any change, with everything built on it, as continuum drops a change its node took and the rules refuse (`drop_taken`), and take what the others hold: no peer's word moves a node, its operator's does. So either side may join the other without what parts them, as the design request asked, without a fork.
* federation: wordings that said more than the design doestv35 hours1-15/+17
| | | | | | | | | | | | Which federation a swarm follows is in each version, not in its policy's place; a fork's first version changes the one current at its heads, not `null`; a place given back shows what its party signed before only where nothing replaced it since; a remake's snapshot is a function of its base and its record, so two remakes at one base are two epochs; honest nodes agree once they sync but where keys voted twice, a coordinator decided two remakes, or a writer forked; and what a node taken off its list commits from a history before ends with the next remake's base, as no later version orders it.
* federation: the writers a node starts, boundedtv35 hours1-4/+10
| | | | | | | | | Every writer costs every node memory for as long as the epoch lasts, and nothing bounded the writers a node starts: one listed node starting one with every change runs every other out of memory before a remake could be built, which the design called slow, not wrong. A federated swarm bounds the writers a node starts in an epoch, judged at a change's history as any rule is: a rule, and stage 1's.
* federation: a party that voted twice read from its votes, by a tooltv35 hours1-9/+11
| | | | | | | | | | | A node reported a party that voted twice, judging each copy of its votes by the history it was taken at, so that a vote committed again elsewhere framed nobody; and the next remake left those histories out. The votes alone tell it: a `true` and a `false` on one proposal, or a `true` on two proposals of one version where both passed or neither is dead by all the votes cast, as an honest party backs another only once the first is dead. A tool over the votes the parties' clients keep reports it, later too; a node reports the versions it refused.
* federation: a node takes no token another node issuedtv35 hours1-23/+22
| | | | | | | | | | | A node took tokens from the nodes its party lists, and without a user registry every user it lets in may do everything. A party's list is written by a key its version names, or set by a version: so two thirds of the parties, or a thief of that key, could list a node of their own as the party's, issue a token under any name there, and have the party's own nodes take it, against "the design rules nothing about what happens on a party's own nodes". A node takes only its own tokens; a party logs in to each of its nodes.
* federation: of two versions that come together, the first judgedtv35 hours1-4/+4
| | | | | | | | A node holding two versions that change the one it reads, having taken neither, took neither until its operator named one. But where one comes first it is taken anyway, and two come together only by how a sync message was cut: the state, and the endpoint naming one, guarded nothing. A node takes the first it judges.
* federation: what a replay refused, tried again; a client votes by its owntv35 hours1-4/+8
| | | | | | | | | | | A replay puts changes neither of which saw the other by their clocks. A party's `true` committed again at a history before the nays that freed it, its clock set between, came before those nays in the replay and was refused, though the old epoch took it: a proposal that passed there might not pass in the new one, and a party not finding its vote might vote again. What the new epoch refuses is tried again once the rest is replayed, and a party's client keeps what its party voted and votes by that, never by what a node shows.
* federation: a node shows whether a proposal is a versiontv35 hours1-1/+4
| | | | | | | | | | A proposal is taken whatever its text, and asked whether it is a version only where it is written as one. One that isn't is voted on, never passes, and dies only by nays: two thirds backing it bind the federation to its version for good, and a client reading JSON otherwise than the nodes backs what no node writes. A node shows whether a proposal is a version by the federation it knows, and a party's client backs none that isn't.
* federation: what a node's API users may have it committv35 hours1-0/+3
| | | | | | | | Without a user registry, every user a node lets in may do everything, and `--protocol-writers` say who writes protocol data; what of that held in a federated swarm the design didn't say. Whoever a node lets in may have it commit what the rules take, envelopes and the node's own protocol data; `--protocol-writers` names nobody.
* federation: sizes among what the federation's number namestv35 hours1-8/+11
| | | | | | | | | Nothing bounded a version, a key set, a node list, a path or a value: a version larger than a sync message carries would be written where it passed and reach nobody, and nodes built with different bounds would take different changes. The sizes each may have are the federation's number's, each within what a sync message carries, and stage 1 sets them.
* federation: a member at a remake's base is a node its party lists theretv35 hours1-9/+10
| | | | | | A node follows a remake only where it is a member at the base: listed there, or listed and registered, the design didn't say. Listed: a node its party listed registers in the new epoch as it would have in the old.