aboutsummaryrefslogtreecommitdiffstats
path: root/docs/access.md
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-15 18:43:13 +0000
committertv <tv@krebsco.de>2026-11-15 18:43:13 +0000
commitf3bfea8ebda0fa7efe1fd9ed6fe670ddb544d38e (patch)
treea5e8a6049dafd001fb52b0da5b7698e8a4f9dc70 /docs/access.md
parent5866291a3752342ff954c39d728384dfe7ff02f8 (diff)
rules: the time before strict is the change that turned it, written again or not
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.
Diffstat (limited to 'docs/access.md')
-rw-r--r--docs/access.md15
1 files changed, 10 insertions, 5 deletions
diff --git a/docs/access.md b/docs/access.md
index b64bd21..c4ce295 100644
--- a/docs/access.md
+++ b/docs/access.md
@@ -472,12 +472,17 @@ through a remake (Turning a swarm strict, below), which keeps only what an opera
looked over. Writing the strict policy into it directly trusts it as it is: look it
over first (`continuum-signed verify` on each entry). From then on nothing is added to
the time before: a change written under a policy that isn't strict is refused, received
-or held, unless it is in the history of the change that wrote the strict policy, so a
-member can't plant at that time what nobody could follow; a node that took one beside
-that change drops it once a peer tells it so (Changes judged on every node, below). A
+or held, where the change that turned the swarm strict (that wrote the strict policy
+under one that wasn't) is neither in its history nor built on it, so a member can't
+plant at that time what nobody could follow; a node that took one beside that change
+drops it once a peer tells it so (Changes judged on every node, below). The policy
+written again later doesn't change which change that is. One written beside it is
+refused like any other, even one turning the swarm strict too, so a change made later
+to look as old can't take its place: two members turning a swarm strict at once split
+the nodes that took one from those that took the other, so it is turned from one. A
value there that isn't an envelope starts its chain anew: any envelope its user once
-signed for that path replacing nothing (`prev` empty) can be put there again. Without the policy, signed values may
-be written all the same, and plain ones too.
+signed for that path replacing nothing (`prev` empty) can be put there again. Without
+the policy, signed values may be written all the same, and plain ones too.
Keep two users who may manage users, or two keys each: under a strict policy, a
registry whose only manager lost its keys changes no more (the protocol writers do