@optimystic/db-p2p 1.0.0-beta.3 → 1.1.0

package/dist/src/storage/i-block-storage.d.ts

@@ -1,6 +1,7 @@
-import type { BlockId, IBlock, Transform, ActionId, ActionRev } from "@optimystic/db-core";
+import type { BlockId, IBlock, Transform, ActionId, ActionRev, BlockLineage } from "@optimystic/db-core";
 import type { BlockCommitProof } from "../cluster/commit-proof.js";
 import type { BlockWriteLatch } from "./block-latch.js";
+import type { PendingClaim } from "./pending-claim.js";
 /**
  * Thrown by {@link IBlockStorage.getBlock} when the block has metadata here but the target revision
  * lies outside the locally held revision ranges — this node holds no local records that can serve
@@ -101,10 +102,40 @@ export interface IBlockStorage {
      * under one multi-block write-latch hold, so every block it saves was observed under that same
      * hold to satisfy `latest === undefined || latest.rev < rev`, and no writer can advance a block
      * without its latch. A throw here means a caller reintroduced check-then-act.
+     *
+     * The revision is also KEPT, in the block's metadata (`BlockMetadata.pendingRevs`), so the record
+     * can later be read as a claim on a specific slot — see {@link listPendingClaims}.
+     *
+     * `baseRev` is the committed revision the record's update operations were computed against — the
+     * pend's `baseRevs[blockId]` — or `undefined` when the pend named none for this block (an
+     * inserted or deleted block, or a base the author did not know). Kept beside the revision
+     * (`BlockMetadata.pendingBases`), in the same metadata write, so that every later step that
+     * applies the record can refuse to apply it to a different version of the block — see
+     * {@link pendingClaimOf}. Stored as told: whether it matches this node's `latest` is decided
+     * where the record is APPLIED (`StorageRepo.internalCommit`, and the read-driven promotion in
+     * `StorageRepo.get`), never here.
      */
-    savePendingTransaction(actionId: ActionId, transform: Transform, rev: number | undefined, latch: BlockWriteLatch): Promise<void>;
-    /** Deletes a pending action */
+    savePendingTransaction(actionId: ActionId, transform: Transform, rev: number | undefined, baseRev: number | undefined, latch: BlockWriteLatch): Promise<void>;
+    /** Deletes a pending action, and the revision and base it was recorded as claiming. */
     deletePendingTransaction(actionId: ActionId, latch: BlockWriteLatch): Promise<void>;
+    /**
+     * Every pending record on this block, each with the revision it was pended at and the base it
+     * was computed against when those are known — the pending namespace joined against
+     * `BlockMetadata.pendingRevs` and `pendingBases`. This is the view the rival-pend checks read
+     * (`StorageRepo.pend`'s apply-time scan and `ClusterMember.validatePendOperations`' promise
+     * vote), because whether a record reserves the block against a given pend depends on the slot
+     * it claims measured against the pend's revision — and, at the vote of a cohort that can leave a
+     * member out, its base (`isReservationAgainst`) — not on its mere presence. Read-only; no latch.
+     */
+    listPendingClaims(): Promise<PendingClaim[]>;
+    /**
+     * The claim of ONE pending record — `actionId`'s entry of {@link listPendingClaims} — or
+     * `undefined` when this block holds no pending record for the action. For the two apply sites
+     * (`StorageRepo.internalCommit` and the read-driven promotion in `StorageRepo.get`), which need
+     * one record's base on the hot commit path and must not enumerate every record to get it.
+     * Read-only; no latch of its own: both callers already hold the block's write latch.
+     */
+    pendingClaimOf(actionId: ActionId): Promise<PendingClaim | undefined>;
     /** Lists revisions in ascending or descending order between startRev and endRev (inclusive) */
     listRevisions(startRev: number, endRev: number): AsyncIterable<ActionRev>;
     /** Saves a materialized block */
@@ -135,8 +166,29 @@ export interface IBlockStorage {
      * record for a revision the block has already reached.
      */
     promotePendingTransaction(actionId: ActionId, latch: BlockWriteLatch): Promise<void>;
-    /** Sets the latest revision information */
-    setLatest(latest: ActionRev, latch: BlockWriteLatch): Promise<void>;
+    /**
+     * Sets the latest revision information, as the last step of committing `latest` here.
+     *
+     * Call it only after {@link promotePendingTransaction} has moved `latest.actionId`'s record: it
+     * drops that action's claim without deleting a record, so a caller that skipped promotion would
+     * leave a claim-less pending record behind (see `BlockMetadata.pendingRevs`).
+     *
+     * `builtOnPrior` says how the revision's content was produced, which is what the block's known
+     * lineage depends on (see `BlockMetadata.lineageFloor`): `true` when this node applied the
+     * revision's transform to the content of its previous revision (an update-only or delete
+     * transform); `false` when the content stands on its own because the transform carried an
+     * `insert`. Required rather than defaulted: a caller that guessed `true` for an insert would let
+     * {@link lineageOf} vouch for history the content never came from.
+     */
+    setLatest(latest: ActionRev, builtOnPrior: boolean, latch: BlockWriteLatch): Promise<void>;
+    /**
+     * What THIS node's records say about whether the block's content at `latest` was built from the
+     * committed `target` — see `BlockLineage` in db-core for the four answers. Local and read-only:
+     * no latch, no peer fetch, no promotion. `unknown` is the honest answer whenever this node is
+     * past `target.rev` but took later content it did not derive itself (a replica, a restore);
+     * another cohort member that applied those revisions locally can still answer.
+     */
+    lineageOf(target: ActionRev): Promise<BlockLineage>;
     /**
      * Persist a replica of a block received out-of-band (churn re-replication).
      *

package/dist/src/storage/i-block-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i-block-storage.d.ts","sourceRoot":"","sources":["../../../src/storage/i-block-storage.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"i-block-storage.d.ts","sourceRoot":"","sources":["../../../src/storage/i-block-storage.ts"],"names":[],"mappings":"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"}

package/dist/src/storage/i-block-storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"i-block-storage.js","sourceRoot":"","sources":["../../../src/storage/i-block-storage.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IAC5B;IAA2B;IAAhD,YAAqB,OAAgB,EAAW,GAAW;QAC1D,KAAK,CAAC,SAAS,OAAO,aAAa,GAAG,kCAAkC,CAAC,CAAC;QADtD,YAAO,GAAP,OAAO,CAAS;QAAW,QAAG,GAAH,GAAG,CAAQ;QAE1D,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACvC,CAAC;CACD;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC3B;IAA2B;IAA6B;IAAsB;IAAnG,YAAqB,OAAgB,EAAW,QAAkB,EAAW,GAAW,EAAW,MAAiB;QACnH,KAAK,CAAC,SAAS,OAAO,wBAAwB,QAAQ,gBAAgB,GAAG,iBAAiB;cACvF,iCAAiC,MAAM,CAAC,GAAG,YAAY,MAAM,CAAC,QAAQ,YAAY;cAClF,wCAAwC,CAAC,CAAC;QAHzB,YAAO,GAAP,OAAO,CAAS;QAAW,aAAQ,GAAR,QAAQ,CAAU;QAAW,QAAG,GAAH,GAAG,CAAQ;QAAW,WAAM,GAAN,MAAM,CAAW;QAInH,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACtC,CAAC;CACD"}
+{"version":3,"file":"i-block-storage.js","sourceRoot":"","sources":["../../../src/storage/i-block-storage.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IAC5B;IAA2B;IAAhD,YAAqB,OAAgB,EAAW,GAAW;QAC1D,KAAK,CAAC,SAAS,OAAO,aAAa,GAAG,kCAAkC,CAAC,CAAC;QADtD,YAAO,GAAP,OAAO,CAAS;QAAW,QAAG,GAAH,GAAG,CAAQ;QAE1D,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACvC,CAAC;CACD;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC3B;IAA2B;IAA6B;IAAsB;IAAnG,YAAqB,OAAgB,EAAW,QAAkB,EAAW,GAAW,EAAW,MAAiB;QACnH,KAAK,CAAC,SAAS,OAAO,wBAAwB,QAAQ,gBAAgB,GAAG,iBAAiB;cACvF,iCAAiC,MAAM,CAAC,GAAG,YAAY,MAAM,CAAC,QAAQ,YAAY;cAClF,wCAAwC,CAAC,CAAC;QAHzB,YAAO,GAAP,OAAO,CAAS;QAAW,aAAQ,GAAR,QAAQ,CAAU;QAAW,QAAG,GAAH,GAAG,CAAQ;QAAW,WAAM,GAAN,MAAM,CAAW;QAInH,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACtC,CAAC;CACD"}

package/dist/src/storage/pending-claim.d.ts

@@ -0,0 +1,167 @@
+import type { ActionId, BlockId, PendRequest, Transform } from "@optimystic/db-core";
+/**
+ * One pending record on a block, with the revision its pend asked for.
+ *
+ * `rev` is the `PendRequest.rev` the record was written under (see
+ * `IBlockStorage.savePendingTransaction`), kept in the block's metadata beside `latest`
+ * (`BlockMetadata.pendingRevs`). Absent for a record that named no revision — an insert-only pend,
+ * which no production caller sends — and for a record written before the revision was kept at all.
+ * Both read as "unknown", and an unknown claim is treated as the strongest one (see
+ * {@link isReservationAgainst}), so an old record can only refuse more than it should, never less.
+ */
+export interface PendingClaim {
+    actionId: ActionId;
+    rev?: number;
+    /**
+     * The committed revision the record's update operations were computed against — the pend's
+     * `baseRevs[blockId]`, kept in `BlockMetadata.pendingBases`. Absent for a record whose pend
+     * carried no base for this block (inserted, deleted, or unknown to the author) and for a record
+     * written before the field existed; both read as "base unknown". Unlike an unknown `rev`, an
+     * unknown base is NOT the strongest kind of anything: it is simply nothing to compare, and each
+     * apply site decides what that means for it (`StorageRepo.internalCommit` falls back to the
+     * commit's own declaration; the read-driven promotion in `StorageRepo.get` declines; the rival
+     * rule, {@link isReservationAgainst}, keeps the revision rule for it).
+     */
+    baseRev?: number;
+}
+/**
+ * What {@link isReservationAgainst} reads of an incoming pend, for one block: the revision it
+ * requests, and the committed base the block's update operations were computed against — built from
+ * the pend by {@link reservationRequestFor}, so the rule reads exactly the base storage would keep.
+ */
+export interface ReservationRequest {
+    rev?: number;
+    baseRev?: number;
+}
+/**
+ * Whether a rival's pending record is a RESERVATION against an incoming pend for the same block —
+ * the one question both rival scans ask (`StorageRepo.pend` at apply,
+ * `ClusterMember.validatePendOperations` at the promise vote).
+ *
+ * A pending record reserves the block for the revision it claims: it says "I am about to commit
+ * this block at revision `rev`", and it holds that slot from pend-apply until its commit or cancel.
+ * It stops reserving once the incoming writer has BUILT ON it — read the block with that change in
+ * it — because then admitting the newcomer cannot lose the change, whatever became of the record's
+ * action. The rule, first match wins:
+ *
+ *  - Either side's revision unknown → reserves. A record predating revision recording keeps the
+ *    old behaviour rather than silently admitting a rival, and a rev-less request cannot be placed
+ *    past anything.
+ *  - The record carries a base AND the request carries a usable one ({@link usableBase}: a number
+ *    below the requested revision) → reserves iff `claim.rev > baseRev`. A base at or past the
+ *    claimed slot means the newcomer's operations were computed against a version of the block that
+ *    already holds the record's change (it committed there, and this member merely missed the
+ *    commit — the newcomer's own commit brings it current), or against a version past a slot the
+ *    record lost. A base below it means the newcomer read the block without that change, and
+ *    admitting it would let its commit apply over the stale base and sweep the record — the rival's
+ *    change lost while the log names it.
+ *  - Otherwise → reserves iff `claim.rev >= rev` (the revision rule). Revisions are allocated per
+ *    COLLECTION and a writer pends at one past the collection revision it read, so a claim below the
+ *    requested revision is one the collection has moved past, which is taken as having been built
+ *    on. That is sound when the newcomer read the block from a member that held the record
+ *    (`StorageRepo.get` promotes a record for any action the reader's context names, with the block
+ *    floor, `BlockGets.floors`, as the second line), and false in exactly one shape: a member that
+ *    never received the rival's pend — possible only where the promise quorum can leave a member
+ *    out, see {@link cohortCanMissAPend} — serving a floor-less handle while the rival's data-block
+ *    commit is still in flight. It stays the rule for a request with no usable base (an inserted or
+ *    deleted block, a sender that names none, or a malformed base), and for a record with no stored
+ *    base (an inserted or deleted block, or a record written by a release that did not keep bases).
+ *    A base-less record keeps clearing the moment the collection moves past its slot, as it always
+ *    did: judged by the newcomer's base, one whose commit ran nowhere could never clear, since no
+ *    member can promote it (the read-driven promotion declines a record with no base), and a node
+ *    upgraded over its own leftovers would wedge on them. The price: a rival that DELETES the block
+ *    keeps no base either, so the missed-pend shape below stays open for a rival delete, exactly as
+ *    it was before the base arm existed.
+ *
+ * The base arm is never more permissive than the revision arm: an honest base is at most `rev - 1`,
+ * so a claim at or below the base is also below the requested revision. It can only hold more,
+ * which is why the safety argument of Theorem 1 does not weaken. It closes the missed-pend shape
+ * wherever the members still holding the rival's record are enough to deny the newcomer a
+ * super-majority — one member missing the pend leaves every other one holding it — and a member
+ * that has meanwhile taken the rival's change refuses the newcomer's commit at the fork guard
+ * (`StorageRepo.internalCommit`) instead. Liveness for the missed-commit
+ * shape (`a-member-that-missed-a-commit-refuses-every-later-write`) is preserved: a writer that read
+ * the block from a member that applied the rival's change declares at least that revision as its
+ * base, and one served by the missed-commit member itself is served after that member promotes the
+ * record, which it does whenever the record's stored base equals its latest.
+ *
+ * WHERE the base is read is the callers' decision, and deliberately narrow: only the promise vote
+ * reads it, and only for a cohort whose quorum can leave a member out ({@link cohortCanMissAPend});
+ * the apply-time scan in `StorageRepo.pend`, and the vote in every smaller cohort, pass no base. So
+ * the apply never refuses what the vote approved. Holding more costs liveness in two shapes, and the
+ * narrowing keeps both off cohorts that need unanimity (two and three members at the default
+ * threshold), where one member's hold sinks the pend: (1) a newcomer that read the block one change
+ * short is held until the rival commits, and its retries do not re-read the block today, so it then
+ * re-pends on the stale base and the fork guard refuses its commit — refused, never acknowledged over
+ * the rival (backlog `bug-a-writer-held-by-a-change-it-never-saw-retries-on-its-stale-copy`); (2) a
+ * record whose change no member will ever take — an abandoned action whose data-block pend landed,
+ * whose log-tail pend did not, and whose cancel never arrived — used to be superseded as soon as the
+ * collection moved past its slot, and under the base arm holds every newcomer instead.
+ *
+ * NOTE: from four members up, residual (2) wedges the block when the stray record stands on enough
+ * members to deny a super-majority (a writer that crashed after its data-block pend, before any
+ * cancel); a stray record on one member alone is outvoted, and that member's own apply (revision
+ * rule) then admits the newcomer, whose commit sweeps the record. Locally the member cannot tell the
+ * crashed writer's record from the missed-pend shape: both are a record claiming a slot past the
+ * block's latest, met by a newcomer whose base is that latest. Backlog
+ * `debt-unpromotable-pending-records-need-a-sweep` owns abandoned records, and both stuck-reservation
+ * lines name the block; if it shows up in the field, the cure is that sweep, not a looser rule here.
+ */
+export declare function isReservationAgainst(claim: PendingClaim, request: ReservationRequest): boolean;
+/**
+ * Whether a cohort of `peerCount` members, promising at `superMajorityThreshold`, can reach its
+ * promise super-majority without one of its members — so a member can miss a pend the rest of the
+ * cohort stored, and later serve the block one change short. That is the only shape the base arm of
+ * {@link isReservationAgainst} closes, and it is also exactly where one member's hold cannot sink a
+ * pend by itself. Below it (two and three members at the default 0.75) every member's approval is
+ * needed, so the base arm could only add holds that no lost update justifies. The promise vote
+ * reads the incoming base only when this is true.
+ */
+export declare function cohortCanMissAPend(peerCount: number, superMajorityThreshold: number): boolean;
+/**
+ * `request.baseRev` when {@link isReservationAgainst} can read it: a number strictly below the
+ * requested revision. Anything else — absent, not a number (untrusted wire data), or at or past
+ * `rev`, which no honest writer sends since its base is a revision it read and it pends past what it
+ * read — is `undefined`, and the rule falls back to the requested revision alone.
+ */
+export declare function usableBase(request: ReservationRequest): number | undefined;
+/**
+ * The {@link ReservationRequest} `pend` makes of `blockId`, whose transform within the pend is
+ * `transform`: the pend's revision, and the base {@link declaredBaseFor} keeps for the block — so a
+ * base on an inserted or deleted block, or a malformed one, is read by the rule exactly as storage
+ * keeps it: not at all. `ignoredBase` carries a base the pend named for the block that the rule does
+ * not read (malformed, not below the revision, or on a base-independent transform), for the caller's
+ * log line; no producer sends one.
+ */
+export declare function reservationRequestFor(pend: Pick<PendRequest, 'rev' | 'baseRevs'>, blockId: BlockId, transform: Transform): {
+    request: ReservationRequest;
+    ignoredBase?: unknown;
+};
+/**
+ * Whether `transform`'s result does not depend on the block's prior content: an insert replaces the
+ * block wholesale and a delete materializes to nothing (delete-last-wins in `applyTransform`), so
+ * neither can fork on a different base, and no base is ever named for them (`Tracker.stagedBaseRevs`
+ * names update-only blocks alone). Every base check keys on this, on the member's OWN pended
+ * transform (or the incoming pend's own transform, at the rival scans), never on what a request
+ * declares.
+ */
+export declare function isBaseIndependent(transform: Transform): boolean;
+/**
+ * The base a pend declares for `blockId`, as storage will keep it: `baseRevs[blockId]` when it is a
+ * number and the block's transform is update-only, else nothing. Untrusted wire data with no ingress
+ * schema (the posture `validateCommitOperations` takes toward `blockDigests`): a malformed or surplus
+ * entry is ignored for that id, never thrown on; an entry for an inserted or deleted block — which no
+ * producer sends — is dropped, so a base-independent record can never read as base-dependent later.
+ *
+ * NOTE: the base is stored AS TOLD, and the pend never refuses on it — not when it is behind this
+ * member's latest, and not when it is ahead. A member has no grounds to second-guess the author's
+ * claim about the author's own computation (the client is what makes an honest claim correct:
+ * `Tracker` pins the base at the first staged update and re-stages over a moved one). Refusing here
+ * would also be the wrong tier: a member holding a torn or abandoned HIGHER revision would cast a
+ * reject that, at three members, fails every honest retry — the writer re-reads the majority's
+ * revision and declares it again — whereas the same mismatch at commit time is one member's refusal
+ * (`StorageRepo.internalCommit`), heals by reconcile, and the cohort still commits on majority
+ * durability.
+ */
+export declare function declaredBaseFor(baseRevs: PendRequest['baseRevs'], blockId: BlockId, transform: Transform): number | undefined;
+//# sourceMappingURL=pending-claim.d.ts.map

package/dist/src/storage/pending-claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-claim.d.ts","sourceRoot":"","sources":["../../../src/storage/pending-claim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErF;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAM9F;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,GAAG,OAAO,CAE7F;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAG1E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,UAAU,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GACjF;IAAE,OAAO,EAAE,kBAAkB,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,CAQxD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAM7H"}

package/dist/src/storage/pending-claim.js

@@ -0,0 +1,156 @@
+/**
+ * Whether a rival's pending record is a RESERVATION against an incoming pend for the same block —
+ * the one question both rival scans ask (`StorageRepo.pend` at apply,
+ * `ClusterMember.validatePendOperations` at the promise vote).
+ *
+ * A pending record reserves the block for the revision it claims: it says "I am about to commit
+ * this block at revision `rev`", and it holds that slot from pend-apply until its commit or cancel.
+ * It stops reserving once the incoming writer has BUILT ON it — read the block with that change in
+ * it — because then admitting the newcomer cannot lose the change, whatever became of the record's
+ * action. The rule, first match wins:
+ *
+ *  - Either side's revision unknown → reserves. A record predating revision recording keeps the
+ *    old behaviour rather than silently admitting a rival, and a rev-less request cannot be placed
+ *    past anything.
+ *  - The record carries a base AND the request carries a usable one ({@link usableBase}: a number
+ *    below the requested revision) → reserves iff `claim.rev > baseRev`. A base at or past the
+ *    claimed slot means the newcomer's operations were computed against a version of the block that
+ *    already holds the record's change (it committed there, and this member merely missed the
+ *    commit — the newcomer's own commit brings it current), or against a version past a slot the
+ *    record lost. A base below it means the newcomer read the block without that change, and
+ *    admitting it would let its commit apply over the stale base and sweep the record — the rival's
+ *    change lost while the log names it.
+ *  - Otherwise → reserves iff `claim.rev >= rev` (the revision rule). Revisions are allocated per
+ *    COLLECTION and a writer pends at one past the collection revision it read, so a claim below the
+ *    requested revision is one the collection has moved past, which is taken as having been built
+ *    on. That is sound when the newcomer read the block from a member that held the record
+ *    (`StorageRepo.get` promotes a record for any action the reader's context names, with the block
+ *    floor, `BlockGets.floors`, as the second line), and false in exactly one shape: a member that
+ *    never received the rival's pend — possible only where the promise quorum can leave a member
+ *    out, see {@link cohortCanMissAPend} — serving a floor-less handle while the rival's data-block
+ *    commit is still in flight. It stays the rule for a request with no usable base (an inserted or
+ *    deleted block, a sender that names none, or a malformed base), and for a record with no stored
+ *    base (an inserted or deleted block, or a record written by a release that did not keep bases).
+ *    A base-less record keeps clearing the moment the collection moves past its slot, as it always
+ *    did: judged by the newcomer's base, one whose commit ran nowhere could never clear, since no
+ *    member can promote it (the read-driven promotion declines a record with no base), and a node
+ *    upgraded over its own leftovers would wedge on them. The price: a rival that DELETES the block
+ *    keeps no base either, so the missed-pend shape below stays open for a rival delete, exactly as
+ *    it was before the base arm existed.
+ *
+ * The base arm is never more permissive than the revision arm: an honest base is at most `rev - 1`,
+ * so a claim at or below the base is also below the requested revision. It can only hold more,
+ * which is why the safety argument of Theorem 1 does not weaken. It closes the missed-pend shape
+ * wherever the members still holding the rival's record are enough to deny the newcomer a
+ * super-majority — one member missing the pend leaves every other one holding it — and a member
+ * that has meanwhile taken the rival's change refuses the newcomer's commit at the fork guard
+ * (`StorageRepo.internalCommit`) instead. Liveness for the missed-commit
+ * shape (`a-member-that-missed-a-commit-refuses-every-later-write`) is preserved: a writer that read
+ * the block from a member that applied the rival's change declares at least that revision as its
+ * base, and one served by the missed-commit member itself is served after that member promotes the
+ * record, which it does whenever the record's stored base equals its latest.
+ *
+ * WHERE the base is read is the callers' decision, and deliberately narrow: only the promise vote
+ * reads it, and only for a cohort whose quorum can leave a member out ({@link cohortCanMissAPend});
+ * the apply-time scan in `StorageRepo.pend`, and the vote in every smaller cohort, pass no base. So
+ * the apply never refuses what the vote approved. Holding more costs liveness in two shapes, and the
+ * narrowing keeps both off cohorts that need unanimity (two and three members at the default
+ * threshold), where one member's hold sinks the pend: (1) a newcomer that read the block one change
+ * short is held until the rival commits, and its retries do not re-read the block today, so it then
+ * re-pends on the stale base and the fork guard refuses its commit — refused, never acknowledged over
+ * the rival (backlog `bug-a-writer-held-by-a-change-it-never-saw-retries-on-its-stale-copy`); (2) a
+ * record whose change no member will ever take — an abandoned action whose data-block pend landed,
+ * whose log-tail pend did not, and whose cancel never arrived — used to be superseded as soon as the
+ * collection moved past its slot, and under the base arm holds every newcomer instead.
+ *
+ * NOTE: from four members up, residual (2) wedges the block when the stray record stands on enough
+ * members to deny a super-majority (a writer that crashed after its data-block pend, before any
+ * cancel); a stray record on one member alone is outvoted, and that member's own apply (revision
+ * rule) then admits the newcomer, whose commit sweeps the record. Locally the member cannot tell the
+ * crashed writer's record from the missed-pend shape: both are a record claiming a slot past the
+ * block's latest, met by a newcomer whose base is that latest. Backlog
+ * `debt-unpromotable-pending-records-need-a-sweep` owns abandoned records, and both stuck-reservation
+ * lines name the block; if it shows up in the field, the cure is that sweep, not a looser rule here.
+ */
+export function isReservationAgainst(claim, request) {
+    if (claim.rev === undefined || request.rev === undefined) {
+        return true;
+    }
+    const base = claim.baseRev === undefined ? undefined : usableBase(request);
+    return base === undefined ? claim.rev >= request.rev : claim.rev > base;
+}
+/**
+ * Whether a cohort of `peerCount` members, promising at `superMajorityThreshold`, can reach its
+ * promise super-majority without one of its members — so a member can miss a pend the rest of the
+ * cohort stored, and later serve the block one change short. That is the only shape the base arm of
+ * {@link isReservationAgainst} closes, and it is also exactly where one member's hold cannot sink a
+ * pend by itself. Below it (two and three members at the default 0.75) every member's approval is
+ * needed, so the base arm could only add holds that no lost update justifies. The promise vote
+ * reads the incoming base only when this is true.
+ */
+export function cohortCanMissAPend(peerCount, superMajorityThreshold) {
+    return Math.ceil(peerCount * superMajorityThreshold) < peerCount;
+}
+/**
+ * `request.baseRev` when {@link isReservationAgainst} can read it: a number strictly below the
+ * requested revision. Anything else — absent, not a number (untrusted wire data), or at or past
+ * `rev`, which no honest writer sends since its base is a revision it read and it pends past what it
+ * read — is `undefined`, and the rule falls back to the requested revision alone.
+ */
+export function usableBase(request) {
+    const { rev, baseRev } = request;
+    return typeof baseRev === 'number' && rev !== undefined && baseRev < rev ? baseRev : undefined;
+}
+/**
+ * The {@link ReservationRequest} `pend` makes of `blockId`, whose transform within the pend is
+ * `transform`: the pend's revision, and the base {@link declaredBaseFor} keeps for the block — so a
+ * base on an inserted or deleted block, or a malformed one, is read by the rule exactly as storage
+ * keeps it: not at all. `ignoredBase` carries a base the pend named for the block that the rule does
+ * not read (malformed, not below the revision, or on a base-independent transform), for the caller's
+ * log line; no producer sends one.
+ */
+export function reservationRequestFor(pend, blockId, transform) {
+    const request = { rev: pend.rev };
+    const baseRev = declaredBaseFor(pend.baseRevs, blockId, transform);
+    if (baseRev !== undefined) {
+        request.baseRev = baseRev;
+    }
+    const named = pend.baseRevs?.[blockId];
+    return named !== undefined && usableBase(request) === undefined ? { request, ignoredBase: named } : { request };
+}
+/**
+ * Whether `transform`'s result does not depend on the block's prior content: an insert replaces the
+ * block wholesale and a delete materializes to nothing (delete-last-wins in `applyTransform`), so
+ * neither can fork on a different base, and no base is ever named for them (`Tracker.stagedBaseRevs`
+ * names update-only blocks alone). Every base check keys on this, on the member's OWN pended
+ * transform (or the incoming pend's own transform, at the rival scans), never on what a request
+ * declares.
+ */
+export function isBaseIndependent(transform) {
+    return Boolean(transform.insert) || Boolean(transform.delete);
+}
+/**
+ * The base a pend declares for `blockId`, as storage will keep it: `baseRevs[blockId]` when it is a
+ * number and the block's transform is update-only, else nothing. Untrusted wire data with no ingress
+ * schema (the posture `validateCommitOperations` takes toward `blockDigests`): a malformed or surplus
+ * entry is ignored for that id, never thrown on; an entry for an inserted or deleted block — which no
+ * producer sends — is dropped, so a base-independent record can never read as base-dependent later.
+ *
+ * NOTE: the base is stored AS TOLD, and the pend never refuses on it — not when it is behind this
+ * member's latest, and not when it is ahead. A member has no grounds to second-guess the author's
+ * claim about the author's own computation (the client is what makes an honest claim correct:
+ * `Tracker` pins the base at the first staged update and re-stages over a moved one). Refusing here
+ * would also be the wrong tier: a member holding a torn or abandoned HIGHER revision would cast a
+ * reject that, at three members, fails every honest retry — the writer re-reads the majority's
+ * revision and declares it again — whereas the same mismatch at commit time is one member's refusal
+ * (`StorageRepo.internalCommit`), heals by reconcile, and the cohort still commits on majority
+ * durability.
+ */
+export function declaredBaseFor(baseRevs, blockId, transform) {
+    if (isBaseIndependent(transform)) {
+        return undefined;
+    }
+    const declared = baseRevs?.[blockId];
+    return typeof declared === 'number' ? declared : undefined;
+}
+//# sourceMappingURL=pending-claim.js.map

package/dist/src/storage/pending-claim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-claim.js","sourceRoot":"","sources":["../../../src/storage/pending-claim.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAmB,EAAE,OAA2B;IACpF,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;QAC1D,OAAO,IAAI,CAAC;IACb,CAAC;IACD,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC3E,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC;AACzE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAAiB,EAAE,sBAA8B;IACnF,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,sBAAsB,CAAC,GAAG,SAAS,CAAC;AAClE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,OAA2B;IACrD,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IACjC,OAAO,OAAO,OAAO,KAAK,QAAQ,IAAI,GAAG,KAAK,SAAS,IAAI,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;AAChG,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACpC,IAA2C,EAAE,OAAgB,EAAE,SAAoB;IAEnF,MAAM,OAAO,GAAuB,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;IACtD,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IACnE,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC;IAC3B,CAAC;IACD,MAAM,KAAK,GAAY,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;IAChD,OAAO,KAAK,KAAK,SAAS,IAAI,UAAU,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;AACjH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAoB;IACrD,OAAO,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAAC,QAAiC,EAAE,OAAgB,EAAE,SAAoB;IACxG,IAAI,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC;QAClC,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,MAAM,QAAQ,GAAG,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;IACrC,OAAO,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AAC5D,CAAC"}

package/dist/src/storage/raw-store-codec.d.ts

@@ -7,4 +7,17 @@ export declare function decodeJson<T>(bytes: Uint8Array): T;
 export declare function encodeActionId(actionId: ActionId): Uint8Array;
 /** Decode UTF-8 bytes back into an `ActionId` string. */
 export declare function decodeActionId(bytes: Uint8Array): ActionId;
+/**
+ * Deep-copy a value this codec decoded (`IBlock` / `Transform`), by the same JSON round-trip the
+ * store applies. Used where a caller must mutate a stored value without touching the original, in
+ * place of `structuredClone` — which Hermes (React Native) does not provide.
+ *
+ * Lossless for exactly the values this module hands out: anything `decodeJson` returned is already
+ * JSON-shaped, so it carries none of what a JSON round-trip drops or rewrites (an `undefined` array
+ * slot, an `undefined`-valued property, a `Date`, a `Uint8Array`) — those were already rewritten when
+ * the value was stored. It is NOT a general-purpose `structuredClone` replacement: a live object
+ * that never crossed this codec can come back different. `undefined` passes through, since
+ * `JSON.parse(JSON.stringify(undefined))` throws.
+ */
+export declare function cloneDecoded<T>(value: T): T;
 //# sourceMappingURL=raw-store-codec.d.ts.map

package/dist/src/storage/raw-store-codec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw-store-codec.d.ts","sourceRoot":"","sources":["../../../src/storage/raw-store-codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAuBpD,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAElD;AAED,6FAA6F;AAC7F,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,GAAG,CAAC,CAElD;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,UAAU,CAE7D;AAED,yDAAyD;AACzD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAE1D"}
+{"version":3,"file":"raw-store-codec.d.ts","sourceRoot":"","sources":["../../../src/storage/raw-store-codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AA8BpD,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAElD;AAED,6FAA6F;AAC7F,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,GAAG,CAAC,CAElD;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,UAAU,CAE7D;AAED,yDAAyD;AACzD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAE1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAE3C"}

package/dist/src/storage/raw-store-codec.js

@@ -15,15 +15,21 @@
  * → `"[5]"` → `JSON.parse` → `[5]`, so the open-ended encoding survives byte-exact.
  * Do NOT normalize ranges here.
  */
+// The encoder stays module-scope: Hermes provides `TextEncoder` natively (React Native 0.74+).
 const encoder = new TextEncoder();
-const decoder = new TextDecoder();
+// The decoder is built on first use, NOT at module load. Hermes has no native `TextDecoder`, and
+// this module is loaded by the React Native entry (`rn.ts`, via `kv-raw-storage.ts`), so a
+// module-scope `new TextDecoder()` made the import itself throw whenever it ran ahead of the host's
+// polyfill (readme.md § React Native). Memoized, so every call shares one instance as before.
+let decoderInstance;
+const decoder = () => decoderInstance ??= new TextDecoder();
 /** JSON-encode a value (`BlockMetadata` / `Transform` / `IBlock`) to UTF-8 bytes. */
 export function encodeJson(value) {
     return encoder.encode(JSON.stringify(value));
 }
 /** Decode UTF-8 JSON bytes back into a value. Callers guard the miss (`undefined`) first. */
 export function decodeJson(bytes) {
-    return JSON.parse(decoder.decode(bytes));
+    return JSON.parse(decoder().decode(bytes));
 }
 /** Encode an `ActionId` string to UTF-8 bytes (stored as the revisions-store value). */
 export function encodeActionId(actionId) {
@@ -31,6 +37,21 @@ export function encodeActionId(actionId) {
 }
 /** Decode UTF-8 bytes back into an `ActionId` string. */
 export function decodeActionId(bytes) {
-    return decoder.decode(bytes);
+    return decoder().decode(bytes);
+}
+/**
+ * Deep-copy a value this codec decoded (`IBlock` / `Transform`), by the same JSON round-trip the
+ * store applies. Used where a caller must mutate a stored value without touching the original, in
+ * place of `structuredClone` — which Hermes (React Native) does not provide.
+ *
+ * Lossless for exactly the values this module hands out: anything `decodeJson` returned is already
+ * JSON-shaped, so it carries none of what a JSON round-trip drops or rewrites (an `undefined` array
+ * slot, an `undefined`-valued property, a `Date`, a `Uint8Array`) — those were already rewritten when
+ * the value was stored. It is NOT a general-purpose `structuredClone` replacement: a live object
+ * that never crossed this codec can come back different. `undefined` passes through, since
+ * `JSON.parse(JSON.stringify(undefined))` throws.
+ */
+export function cloneDecoded(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
 }
 //# sourceMappingURL=raw-store-codec.js.map

package/dist/src/storage/raw-store-codec.js.map

@@ -1 +1 @@
-{"version":3,"file":"raw-store-codec.js","sourceRoot":"","sources":["../../../src/storage/raw-store-codec.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;AAClC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;AAElC,qFAAqF;AACrF,MAAM,UAAU,UAAU,CAAI,KAAQ;IACrC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9C,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,UAAU,CAAI,KAAiB;IAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAM,CAAC;AAC/C,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,cAAc,CAAC,QAAkB;IAChD,OAAO,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACjC,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,cAAc,CAAC,KAAiB;IAC/C,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAa,CAAC;AAC1C,CAAC"}
+{"version":3,"file":"raw-store-codec.js","sourceRoot":"","sources":["../../../src/storage/raw-store-codec.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,+FAA+F;AAC/F,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;AAElC,iGAAiG;AACjG,2FAA2F;AAC3F,oGAAoG;AACpG,8FAA8F;AAC9F,IAAI,eAAwC,CAAC;AAC7C,MAAM,OAAO,GAAG,GAAgB,EAAE,CAAC,eAAe,KAAK,IAAI,WAAW,EAAE,CAAC;AAEzE,qFAAqF;AACrF,MAAM,UAAU,UAAU,CAAI,KAAQ;IACrC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9C,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,UAAU,CAAI,KAAiB;IAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAM,CAAC;AACjD,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,cAAc,CAAC,QAAkB;IAChD,OAAO,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACjC,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,cAAc,CAAC,KAAiB;IAC/C,OAAO,OAAO,EAAE,CAAC,MAAM,CAAC,KAAK,CAAa,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAI,KAAQ;IACvC,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAM,CAAC;AAC7E,CAAC"}

package/dist/src/storage/restoration-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restoration-coordinator.d.ts","sourceRoot":"","sources":["../../../src/storage/restoration-coordinator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAIxE;;;;;;;;GAQG;AACH,qBAAa,sBAAsB;IASjC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IAZ7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAKtB;gBAGgB,WAAW,EAAE,oBAAoB,EACjC,WAAW,EAAE,YAAY,EACzB,cAAc,EAAE,MAAM;IACvC,iFAAiF;IAChE,UAAU,CAAC,EAAE,MAAM,YAAA;IAGrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsC;IAE1D;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IA4DhF;;OAEG;IACH,qBAAqB,IAAI,eAAe;IAMxC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;IAKtB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;YACW,SAAS;IAiBvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAKrB;;OAEG;IACH,UAAU,IAAI;QACb,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,iBAAiB,EAAE,MAAM,CAAC;KAC1B;CAWD"}
+{"version":3,"file":"restoration-coordinator.d.ts","sourceRoot":"","sources":["../../../src/storage/restoration-coordinator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAInD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAIxE;;;;;;;;GAQG;AACH,qBAAa,sBAAsB;IASjC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IAZ7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAKtB;gBAGgB,WAAW,EAAE,oBAAoB,EACjC,WAAW,EAAE,YAAY,EACzB,cAAc,EAAE,MAAM;IACvC,iFAAiF;IAChE,UAAU,CAAC,EAAE,MAAM,YAAA;IAGrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsC;IAE1D;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IA4DhF;;OAEG;IACH,qBAAqB,IAAI,eAAe;IAMxC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;IAKtB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;YACW,SAAS;IAiBvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAKrB;;OAEG;IACH,UAAU,IAAI;QACb,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,iBAAiB,EAAE,MAAM,CAAC;KAC1B;CAWD"}

package/dist/src/storage/restoration-coordinator.js

@@ -1,3 +1,4 @@
+import { routingKeyForBlock } from '@optimystic/db-core';
 import { hashKey } from 'p2p-fret';
 import { peerIdFromString } from '@libp2p/peer-id';
 import { SyncClient } from '../sync/client.js';
@@ -42,7 +43,7 @@ export class RestorationCoordinator {
         // (RingSelector.calculatePartition) and cohort assembly both operate on hashed
         // coords, so restoration must filter in the same space — see getMyRingPeers and
         // filterByPartition below, which reuse this value.
-        const blockCoord = await hashKey(new TextEncoder().encode(blockId));
+        const blockCoord = await hashKey(routingKeyForBlock(blockId));
         // 1. Try my transaction ring peers first
         const myPeers = this.getMyRingPeers(blockCoord);
         const myRingDepth = this.getMyRingDepth();

package/dist/src/storage/restoration-coordinator.js.map

@@ -1 +1 @@
-{"version":3,"file":"restoration-coordinator.js","sourceRoot":"","sources":["../../../src/storage/restoration-coordinator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"restoration-coordinator.js","sourceRoot":"","sources":["../../../src/storage/restoration-coordinator.ts"],"names":[],"mappings":"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"}

package/dist/src/storage/ring-shift-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ring-shift-coordinator.d.ts","sourceRoot":"","sources":["../../../src/storage/ring-shift-coordinator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,6BAA6B,CAAC;AACvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAOvD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,iBAAiB,CAChB,QAAQ,EAAE,MAAM,EAAE,EAClB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC7B,KAAK,EAAE,MAAM,GACX,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,aAAa;IAC7B,WAAW,EAAE,oBAAoB,CAAC;IAClC,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,4EAA4E;IAC5E,SAAS,EAAE,oBAAoB,CAAC;IAChC,8FAA8F;IAC9F,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;IACnB,+FAA+F;IAC/F,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB;;;;OAIG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,eAAe;IAC/B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wFAAwF;AACxF,MAAM,MAAM,YAAY,GACrB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GACrE;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAoB;IAM/B,OAAO,CAAC,QAAQ,CAAC,IAAI;IALtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAS;gBAGP,IAAI,EAAE,aAAa,EACpC,MAAM,GAAE,eAAoB;IAK7B;;;;OAIG;IACG,YAAY,CAAC,UAAU,EAAE;QAAE,SAAS,EAAE,IAAI,GAAG,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,CAAC;IAmBxG;;;;;;OAMG;IACH,gBAAgB,IAAI;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE;YAiB7B,OAAO;IAgCrB;;;OAGG;YACW,gBAAgB;IAiB9B;;;OAGG;YACW,iBAAiB;IAc/B;;;;;OAKG;YACW,cAAc;YAkBd,MAAM;IAapB,wFAAwF;IACxF,OAAO,CAAC,QAAQ;IAkBhB,kGAAkG;IAClG,OAAO,CAAC,SAAS;CAIjB"}
+{"version":3,"file":"ring-shift-coordinator.d.ts","sourceRoot":"","sources":["../../../src/storage/ring-shift-coordinator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,6BAA6B,CAAC;AACvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAMvD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,iBAAiB,CAChB,QAAQ,EAAE,MAAM,EAAE,EAClB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC7B,KAAK,EAAE,MAAM,GACX,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,aAAa;IAC7B,WAAW,EAAE,oBAAoB,CAAC;IAClC,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,4EAA4E;IAC5E,SAAS,EAAE,oBAAoB,CAAC;IAChC,8FAA8F;IAC9F,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;IACnB,+FAA+F;IAC/F,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB;;;;OAIG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,eAAe;IAC/B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wFAAwF;AACxF,MAAM,MAAM,YAAY,GACrB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GACrE;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAoB;IAM/B,OAAO,CAAC,QAAQ,CAAC,IAAI;IALtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAS;gBAGP,IAAI,EAAE,aAAa,EACpC,MAAM,GAAE,eAAoB;IAK7B;;;;OAIG;IACG,YAAY,CAAC,UAAU,EAAE;QAAE,SAAS,EAAE,IAAI,GAAG,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,CAAC;IAmBxG;;;;;;OAMG;IACH,gBAAgB,IAAI;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE;YAiB7B,OAAO;IAgCrB;;;OAGG;YACW,gBAAgB;IAiB9B;;;OAGG;YACW,iBAAiB;IAc/B;;;;;OAKG;YACW,cAAc;YAkBd,MAAM;IAapB,wFAAwF;IACxF,OAAO,CAAC,QAAQ;IAkBhB,kGAAkG;IAClG,OAAO,CAAC,SAAS;CAIjB"}

package/dist/src/storage/ring-shift-coordinator.js

@@ -1,8 +1,8 @@
 import { hashKey } from 'p2p-fret';
+import { routingKeyForBlock } from '@optimystic/db-core';
 import { partitionCovers, qualifiesForFloor } from './arachnode-partition.js';
 import { createLogger } from '../logger.js';
 const log = createLogger('ring-shift');
-const textEncoder = new TextEncoder();
 /**
  * Drives a single damped ring transition through the **advertise → confirm-replication → release**
  * handoff (`docs/arachnode-ring-handoff.md` § Part 2), so a ring shift never drops a key below its
@@ -127,7 +127,7 @@ export class RingShiftCoordinator {
     async computeShedBlocks(oldPartition, newPartition) {
         const shed = [];
         for (const blockId of this.deps.ownedBlocks) {
-            const coord = await hashKey(textEncoder.encode(blockId));
+            const coord = await hashKey(routingKeyForBlock(blockId));
             if (partitionCovers(oldPartition, coord) && !partitionCovers(newPartition, coord)) {
                 shed.push(blockId);
             }
@@ -144,7 +144,7 @@ export class RingShiftCoordinator {
         const owners = new Map();
         const want = floor + 1 + this.candidateMargin; // headroom for self + excluded movers
         for (const blockId of shed) {
-            const coord = await hashKey(textEncoder.encode(blockId));
+            const coord = await hashKey(routingKeyForBlock(blockId));
             const cohort = this.deps.fret.assembleCohort(coord, want);
             const qualifying = cohort.filter(peerId => {
                 if (peerId === this.deps.selfPeerId)