@optimystic/db-p2p 0.13.5 → 0.14.0

package/dist/src/reactivity/rotation-rereg-scheduler.js

@@ -0,0 +1,223 @@
+/**
+ * Reactivity — tail-rotation re-registration timer host seam (`docs/reactivity.md` §Tail rotation step 3).
+ *
+ * The {@link import("./subscription-manager.js").ReactivitySubscriptionManager} surfaces a
+ * {@link import("./subscription-manager.js").RotationNotice} **once per successor tail** (both the
+ * notify-driven pre-announce and the recover-driven `RotationRedirectError` converge on the same
+ * `surfaceRotation` seam), but it neither schedules the timer nor performs the move. This host component
+ * does: it consumes a notice, schedules a one-shot timer for `max(0, plan.fireAt - now())`, and on fire
+ * invokes an injected `reRegister(plan)` seam that re-subscribes the watcher at the rotated tree. The node
+ * composition that constructs the manager + binds this scheduler to its `onRotation` observer lives in
+ * `reactivity-rotation-host-wiring-e2e`; this module is the standalone, unit-testable piece.
+ *
+ * **Where the stagger lives.** The spread that keeps the new tail from being flooded is entirely in
+ * `plan.fireAt`, drawn by the **manager's** `rejoinJitter`. This scheduler only *consumes* `plan.fireAt`; it
+ * never sees the jitter. The manager uses the *single*-subscriber planner `planReRegistration` →
+ * `RejoinJitter.scheduleRejoin`, which draws a **uniform** offset `now + ⌊U[0, T_rejoin_jitter)⌋` — so the
+ * load-bearing knob for this path is the **window** `T_rejoin_jitter` (default 30 s), not a `capPromote`. Each
+ * subscriber jitters independently, giving the new tail an inbound rate of ≈ `subscribers / T_rejoin_jitter`
+ * in expectation; the burst is absorbed on the *receiving* side by the new tail cohort's `cap_promote_fast`
+ * fast-promotion (a cohort-topic promotion mechanism — see `docs/reactivity.md` §Tail rotation rotation-cost
+ * and the Worked scenario), which is independent of the jitter's `capPromote`.
+ *
+ * Note that `RejoinJitter`'s `capPromote` is consulted **only** by the *wave* planner
+ * `scheduleWave` / `planReRegistrationWave` (a single host staggering a whole wave with a hard per-window
+ * ceiling — used by the mesh harness, not by the production manager). If the composing site
+ * (`reactivity-rotation-host-wiring-e2e`) ever switches the manager onto the wave planner, *then* it must
+ * build the jitter as `createRejoinJitter({ capPromote: DEFAULT_CAP_PROMOTE_FAST })` (= 32), since the default
+ * `createRejoinJitter()` cap is the cohort-failure `cap_promote = 64`. For the current single-planner path,
+ * setting `capPromote` has **no effect** on `fireAt`.
+ *
+ * **Determinism.** An injected `setTimer(fn, delayMs) => cancel` and `now()` clock make the scheduler
+ * testable with a fake clock (no wall clock). They default to a production binding: an **unref'd**
+ * `setTimeout`/`clearTimeout` and `Date.now`. The unref is load-bearing — an idle re-registration timer must
+ * not pin an otherwise-idle process, mirroring the push-state-gossip driver's unref'd timer
+ * ({@link import("./push-state-gossip.js").ReactivityPushStateGossipDriver}).
+ *
+ * **Idempotence.** De-duped by successor `newTopicId` (base64url): a second notice for a successor already
+ * scheduled or fired is ignored. The manager already fires once per successor (its `rotationHandledFor`
+ * guard), but a redirect and a pre-announce can surface the **same** successor near-simultaneously, so the
+ * scheduler is independently idempotent. The de-dupe ledger (`seen`) survives the timer fire (so a late
+ * re-surface of an already-fired successor stays a no-op), which on the normal schedule→fire path would let it
+ * grow without bound across a long-lived, fast-rotating subscription. It is therefore **bounded**: capped at
+ * `SEEN_LEDGER_CAP` entries with oldest-first eviction (insertion order), and eviction **never** drops a key
+ * still in `pending` — that would break the "every pending key ∈ `seen`" invariant and could let a duplicate
+ * notice for a pending successor arm a second timer over the live one. A re-surface older than the cap (≥ cap
+ * distinct successors later) degrades to at most one harmless, idempotent re-register.
+ *
+ * **Chained rotation OLD→A→B** before A's timer fires → A and B are distinct successors → two independent
+ * timers; **both may fire**. Re-registering at A and then immediately rotating A→B is self-correcting via the
+ * manager's `rotationHandledFor` guard, so a superseded timer is intentionally **not** cancelled (a
+ * superseded re-register is harmless and rare).
+ */
+import { bytesToB64url } from "@optimystic/db-core";
+import { createLogger } from "../logger.js";
+const log = createLogger("reactivity-rotation-rereg");
+/**
+ * Upper bound on the idempotence ledger (`seen`). Far above any realistic count of *concurrently-pending*
+ * successors (single digits: 1 in the normal case, a handful across a chained rotation), so it never evicts a
+ * still-live entry in practice while keeping the ledger's memory to tens of KB of short base64url strings at the
+ * ceiling. Tunable — raising it widens the late-re-surface de-dupe window at a proportional memory cost.
+ * Exported for the regression test that asserts the bound; production callers don't read it.
+ */
+export const SEEN_LEDGER_CAP = 1024;
+/**
+ * Production timer binding: a one-shot `setTimeout` whose handle is **unref'd** so a pending re-registration
+ * never keeps an otherwise-idle process alive. The returned handle clears the timeout (idempotent — clearing
+ * an already-fired/cleared timeout is a no-op).
+ */
+function defaultSetTimer(fn, delayMs) {
+    const handle = setTimeout(fn, delayMs);
+    // Node timers keep the event loop alive; an idle rotation timer must not pin a process (mirror push-state gossip).
+    handle.unref?.();
+    return () => clearTimeout(handle);
+}
+/**
+ * Hosts the per-successor one-shot timers that move a subscriber to the rotated tree. Construct one per
+ * subscription manager and bind {@link schedule} to the manager's
+ * {@link import("./subscription-manager.js").ReactivitySubscriptionManagerOptions.onRotation} observer.
+ *
+ * See the module doc for where the re-registration stagger actually lives (the manager's `rejoinJitter`; this
+ * scheduler only consumes `plan.fireAt`, it does not draw it).
+ */
+export class RotationReRegistrationScheduler {
+    reRegister;
+    setTimer;
+    now;
+    /** Successors with a still-pending timer, keyed by base64url `newTopicId` → its cancel handle. */
+    pending = new Map();
+    /**
+     * Successors recently scheduled (pending **or** already fired) — the idempotence ledger that survives fire.
+     * Insertion-ordered and **bounded** at {@link SEEN_LEDGER_CAP}: {@link evictSeenOverCap} drops the oldest
+     * non-pending entries once over cap (never a still-pending key — see that method's doc).
+     */
+    seen = new Set();
+    stopped = false;
+    constructor(options) {
+        this.reRegister = options.reRegister;
+        this.setTimer = options.setTimer ?? defaultSetTimer;
+        this.now = options.now ?? (() => Date.now());
+    }
+    /** Successors with a timer still pending (not yet fired/cancelled). Diagnostic / test seam. */
+    get pendingCount() {
+        return this.pending.size;
+    }
+    /**
+     * Size of the idempotence ledger (pending + recently-fired-and-retained). Diagnostic / test seam; the
+     * regression test asserts this stays ≤ {@link SEEN_LEDGER_CAP} under unbounded sequential rotations.
+     */
+    get seenCount() {
+        return this.seen.size;
+    }
+    /**
+     * Schedule the re-registration timer for a rotation notice. De-duped by successor `newTopicId`: a second
+     * notice for an already-scheduled-or-fired successor is a no-op (a redirect and a pre-announce can surface
+     * the same successor). The delay is `max(0, plan.fireAt - now())`, so a `fireAt` already in the past fires
+     * on the next tick (clamped to 0, never negative). A no-op once {@link stop} has run.
+     */
+    schedule(notice) {
+        if (this.stopped) {
+            return;
+        }
+        const key = bytesToB64url(notice.plan.newTopicId);
+        if (this.seen.has(key)) {
+            log("rotation re-registration already scheduled/fired for successor topic=%s — ignoring duplicate notice (preAnnounced=%s)", key, notice.preAnnounced);
+            return;
+        }
+        this.seen.add(key);
+        const delayMs = Math.max(0, notice.plan.fireAt - this.now());
+        const plan = notice.plan;
+        const cancel = this.setTimer(() => {
+            this.fire(key, plan);
+        }, delayMs);
+        this.pending.set(key, cancel);
+        // Bound `seen` only AFTER the new key is in `pending`, so eviction sees it as live and never drops it (the
+        // "every pending key ∈ seen" invariant). Were this run before `pending.set`, the just-added key would be the
+        // one non-pending candidate whenever `pending` is at the cap, and would be wrongly evicted then immediately
+        // re-added to `pending` — a pending key absent from `seen`, which a duplicate notice could then re-arm over.
+        this.evictSeenOverCap();
+        log("scheduled rotation re-registration for successor topic=%s in %dms (preAnnounced=%s)", key, delayMs, notice.preAnnounced);
+    }
+    /**
+     * Cancel a single pending timer (by successor `newTopicId`) or, when called with no argument, **all**
+     * pending timers (teardown). Cancelling an already-fired or unknown successor is a safe no-op. A cancelled
+     * successor is forgotten (dropped from the idempotence ledger), so a later notice for it would reschedule;
+     * use {@link stop} for permanent teardown.
+     */
+    cancel(newTopicId) {
+        if (newTopicId === undefined) {
+            for (const cancelTimer of this.pending.values()) {
+                cancelTimer();
+            }
+            this.pending.clear();
+            this.seen.clear();
+            return;
+        }
+        const key = bytesToB64url(newTopicId);
+        const cancelTimer = this.pending.get(key);
+        if (cancelTimer !== undefined) {
+            cancelTimer();
+            this.pending.delete(key);
+        }
+        this.seen.delete(key);
+    }
+    /**
+     * Stop the scheduler permanently (teardown): cancel every pending timer and refuse all further scheduling
+     * and firing. A timer that races `stop` (its callback already queued) finds the `stopped` gate and never
+     * invokes `reRegister`. Idempotent.
+     */
+    stop() {
+        this.stopped = true;
+        for (const cancelTimer of this.pending.values()) {
+            cancelTimer();
+        }
+        this.pending.clear();
+        this.seen.clear();
+    }
+    /**
+     * Bound the idempotence ledger: evict the oldest entries (insertion order) that are **not** still pending,
+     * until back within {@link SEEN_LEDGER_CAP}. Never evicts a pending key — that would break the "every pending
+     * key ∈ `seen`" invariant and could double-fire a successor whose later duplicate notice then re-armed a timer
+     * over the live one. If every over-cap entry is somehow still pending (`pending.size > cap` — not reachable in
+     * practice, since pending successors are the most recently scheduled), the loop bails and the ledger is left to
+     * grow with `pending` this round; it returns within cap as soon as those timers fire and a later schedule runs.
+     */
+    evictSeenOverCap() {
+        while (this.seen.size > SEEN_LEDGER_CAP) {
+            let evicted = false;
+            for (const key of this.seen) { // insertion order: oldest first
+                if (!this.pending.has(key)) {
+                    this.seen.delete(key);
+                    log("rotation re-registration ledger at cap (%d) — evicted oldest fired successor topic=%s", SEEN_LEDGER_CAP, key);
+                    evicted = true;
+                    break;
+                }
+            }
+            if (!evicted) {
+                break;
+            }
+        }
+    }
+    /** Timer callback: drop the pending entry, then invoke the isolated re-registration (unless stopped). */
+    fire(key, plan) {
+        this.pending.delete(key);
+        if (this.stopped) {
+            return; // stop() raced the timer callback — no move after teardown.
+        }
+        // A failed move must never throw out of the timer callback — an escaping throw / unhandled rejection
+        // would surface on the host event loop. Guard BOTH a rejected promise and a (mis-implemented) seam that
+        // throws synchronously. `seen` retains the key so a duplicate notice still no-ops. No retry this pass —
+        // and because `seen` keeps the key, a re-notice for this *same* successor is deduped (the manager's
+        // `rotationHandledFor` already holds it too), so the recovery backstop for a failed move is the
+        // subscriber's normal recover/re-walk path, not a re-detected rotation to the same tail.
+        try {
+            void this.reRegister(plan).catch((err) => {
+                log("rotation re-registration rejected for successor topic=%s (isolated, not retried): %o", key, err);
+            });
+        }
+        catch (err) {
+            log("rotation re-registration threw synchronously for successor topic=%s (isolated): %o", key, err);
+        }
+    }
+}
+//# sourceMappingURL=rotation-rereg-scheduler.js.map

package/dist/src/reactivity/rotation-rereg-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation-rereg-scheduler.js","sourceRoot":"","sources":["../../../src/reactivity/rotation-rereg-scheduler.ts"],"names":[],"mappings":"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"}

package/dist/src/reactivity/subscriber-registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Reactivity — node-level subscriber registry (the socket-delivery → subscription-manager seam).
+ *
+ * A {@link import("./subscription-manager.js").ReactivitySubscriptionManager} owns the verify/dedupe/deliver
+ * path for one subscription but is transport-agnostic: it exposes `onNotification(n)` and never touches a
+ * socket. This registry is the routing table that connects a socket-delivered {@link NotificationV1} to the
+ * right manager(s): the forwarder host's `deliverLocal(topicId, n)` looks topic up here and invokes every
+ * manager registered for it, and a constructed manager registers its `onNotification` keyed by the reactivity
+ * `topicId` it subscribed under.
+ *
+ * Keyed by topicId-base64url. A manager subscribes under `topicId = reactivityTopicId(reactivityTailBytes(
+ * tailId))` (the same anchor origination derives), so a notification's topic — derived by the forwarder host
+ * from the notification's tail anchor — routes to exactly the managers watching that tail's collection.
+ *
+ * **Scope.** This delivers socket-routed notifications into a manager that was *already constructed* and
+ * registered. Constructing the manager from a Quereus `Database.watch` (the application bridge) stays the
+ * backlog item `optimystic-network-reactive-watch-integration-test`; this registry is the plug it will use.
+ */
+import { type NotificationV1 } from "@optimystic/db-core";
+/** A subscriber's inbound seam — a manager's `onNotification` (which returns a delivery outcome promise). */
+export type ReactivityNotificationHandler = (n: NotificationV1) => void | Promise<unknown>;
+/**
+ * The node's `topicId → subscriber handlers` table. Exposed on the node as `reactivitySubscribers` so a
+ * subscribe factory can register a {@link import("./subscription-manager.js").ReactivitySubscriptionManager}
+ * and have socket-delivered notifications routed to it.
+ */
+export declare class ReactivitySubscriberRegistry {
+    private readonly byTopic;
+    /**
+     * Register `onNotification` to receive every notification the node delivers for `topicId`. Multiple
+     * managers may register for one topic (each gets every notification). Returns an idempotent unregister.
+     */
+    register(topicId: Uint8Array, onNotification: ReactivityNotificationHandler): () => void;
+    /** Drop a previously-registered handler; idempotent (a no-op if it was never registered / already gone). */
+    unregister(topicId: Uint8Array, onNotification: ReactivityNotificationHandler): void;
+    /**
+     * Deliver `n` to every handler registered for `topicId` (the forwarder host's `deliverLocal` seam). Each
+     * handler is isolated: a synchronous throw or a rejected delivery promise is logged, never propagated —
+     * one faulty subscriber must not break delivery to the rest or the fan-out loop that called this.
+     */
+    deliver(topicId: Uint8Array, n: NotificationV1): void;
+    /** Number of topics with at least one registered subscriber (diagnostic / test). */
+    get topicCount(): number;
+    /** Whether any subscriber is registered for `topicId` (diagnostic / test). */
+    has(topicId: Uint8Array): boolean;
+}
+//# sourceMappingURL=subscriber-registry.d.ts.map

package/dist/src/reactivity/subscriber-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber-registry.d.ts","sourceRoot":"","sources":["../../../src/reactivity/subscriber-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAKzE,6GAA6G;AAC7G,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE3F;;;;GAIG;AACH,qBAAa,4BAA4B;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyD;IAEjF;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,6BAA6B,GAAG,MAAM,IAAI;IAWxF,4GAA4G;IAC5G,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,6BAA6B,GAAG,IAAI;IAYpF;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,cAAc,GAAG,IAAI;IAkBrD,oFAAoF;IACpF,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,8EAA8E;IAC9E,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO;CAGjC"}

package/dist/src/reactivity/subscriber-registry.js

@@ -0,0 +1,87 @@
+/**
+ * Reactivity — node-level subscriber registry (the socket-delivery → subscription-manager seam).
+ *
+ * A {@link import("./subscription-manager.js").ReactivitySubscriptionManager} owns the verify/dedupe/deliver
+ * path for one subscription but is transport-agnostic: it exposes `onNotification(n)` and never touches a
+ * socket. This registry is the routing table that connects a socket-delivered {@link NotificationV1} to the
+ * right manager(s): the forwarder host's `deliverLocal(topicId, n)` looks topic up here and invokes every
+ * manager registered for it, and a constructed manager registers its `onNotification` keyed by the reactivity
+ * `topicId` it subscribed under.
+ *
+ * Keyed by topicId-base64url. A manager subscribes under `topicId = reactivityTopicId(reactivityTailBytes(
+ * tailId))` (the same anchor origination derives), so a notification's topic — derived by the forwarder host
+ * from the notification's tail anchor — routes to exactly the managers watching that tail's collection.
+ *
+ * **Scope.** This delivers socket-routed notifications into a manager that was *already constructed* and
+ * registered. Constructing the manager from a Quereus `Database.watch` (the application bridge) stays the
+ * backlog item `optimystic-network-reactive-watch-integration-test`; this registry is the plug it will use.
+ */
+import { bytesToB64url } from "@optimystic/db-core";
+import { createLogger } from "../logger.js";
+const log = createLogger("reactivity-subscribers");
+/**
+ * The node's `topicId → subscriber handlers` table. Exposed on the node as `reactivitySubscribers` so a
+ * subscribe factory can register a {@link import("./subscription-manager.js").ReactivitySubscriptionManager}
+ * and have socket-delivered notifications routed to it.
+ */
+export class ReactivitySubscriberRegistry {
+    byTopic = new Map();
+    /**
+     * Register `onNotification` to receive every notification the node delivers for `topicId`. Multiple
+     * managers may register for one topic (each gets every notification). Returns an idempotent unregister.
+     */
+    register(topicId, onNotification) {
+        const key = bytesToB64url(topicId);
+        let handlers = this.byTopic.get(key);
+        if (handlers === undefined) {
+            handlers = new Set();
+            this.byTopic.set(key, handlers);
+        }
+        handlers.add(onNotification);
+        return () => this.unregister(topicId, onNotification);
+    }
+    /** Drop a previously-registered handler; idempotent (a no-op if it was never registered / already gone). */
+    unregister(topicId, onNotification) {
+        const key = bytesToB64url(topicId);
+        const handlers = this.byTopic.get(key);
+        if (handlers === undefined) {
+            return;
+        }
+        handlers.delete(onNotification);
+        if (handlers.size === 0) {
+            this.byTopic.delete(key);
+        }
+    }
+    /**
+     * Deliver `n` to every handler registered for `topicId` (the forwarder host's `deliverLocal` seam). Each
+     * handler is isolated: a synchronous throw or a rejected delivery promise is logged, never propagated —
+     * one faulty subscriber must not break delivery to the rest or the fan-out loop that called this.
+     */
+    deliver(topicId, n) {
+        const handlers = this.byTopic.get(bytesToB64url(topicId));
+        if (handlers === undefined) {
+            return;
+        }
+        // Snapshot: a handler that unregisters itself on delivery would otherwise mutate the live set.
+        for (const handler of [...handlers]) {
+            try {
+                const result = handler(n);
+                if (result instanceof Promise) {
+                    result.catch((err) => log("subscriber delivery rejected (isolated) for rev=%d: %o", n.revision, err));
+                }
+            }
+            catch (err) {
+                log("subscriber handler threw (isolated) for rev=%d: %o", n.revision, err);
+            }
+        }
+    }
+    /** Number of topics with at least one registered subscriber (diagnostic / test). */
+    get topicCount() {
+        return this.byTopic.size;
+    }
+    /** Whether any subscriber is registered for `topicId` (diagnostic / test). */
+    has(topicId) {
+        return this.byTopic.has(bytesToB64url(topicId));
+    }
+}
+//# sourceMappingURL=subscriber-registry.js.map

package/dist/src/reactivity/subscriber-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber-registry.js","sourceRoot":"","sources":["../../../src/reactivity/subscriber-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,aAAa,EAAuB,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,GAAG,GAAG,YAAY,CAAC,wBAAwB,CAAC,CAAC;AAKnD;;;;GAIG;AACH,MAAM,OAAO,4BAA4B;IACvB,OAAO,GAAG,IAAI,GAAG,EAA8C,CAAC;IAEjF;;;OAGG;IACH,QAAQ,CAAC,OAAmB,EAAE,cAA6C;QAC1E,MAAM,GAAG,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC5B,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAC;YACrB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACjC,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC7B,OAAO,GAAS,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAC7D,CAAC;IAED,4GAA4G;IAC5G,UAAU,CAAC,OAAmB,EAAE,cAA6C;QAC5E,MAAM,GAAG,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO;QACR,CAAC;QACD,QAAQ,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QAChC,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,CAAC;IACF,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,OAAmB,EAAE,CAAiB;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO;QACR,CAAC;QACD,+FAA+F;QAC/F,KAAK,MAAM,OAAO,IAAI,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC;gBACJ,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC1B,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;oBAC/B,MAAM,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE,CAAC,GAAG,CAAC,wDAAwD,EAAE,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;gBAChH,CAAC;YACF,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACd,GAAG,CAAC,oDAAoD,EAAE,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC5E,CAAC;QACF,CAAC;IACF,CAAC;IAED,oFAAoF;IACpF,IAAI,UAAU;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,8EAA8E;IAC9E,GAAG,CAAC,OAAmB;QACtB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,CAAC;CACD"}

package/dist/src/reactivity/subscription-manager.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Reactivity — subscription manager (db-p2p, wires to the cohort-topic substrate).
+ *
+ * Drives a subscriber's lifecycle against the participant-facing {@link CohortTopicService}: register at
+ * cohort-topic tier **T3 (luxury)** with the reactivity `appPayload`, renew to keep the registration
+ * alive within its TTL (Edge 60 s / Core 90 s), and withdraw by ceasing renewal — all the cohort-topic
+ * standard (`docs/reactivity.md` §Subscription). The reactivity-specific shape lives in db-core: the
+ * tail-anchored `topicId = H(tailId ‖ "reactivity")`, the {@link SubscribeAppPayloadV1}, and the
+ * subscriber-side verify/deliver path ({@link ReactivitySubscriber}).
+ *
+ * Inbound notifications are handed to {@link ReactivitySubscriptionManager.onNotification}, which runs
+ * the db-core delivery path (verify against the cached tail-cohort `MembershipCertV1` with one
+ * fetch-and-retry, revision-contiguity, gap → backfill seam, `(collectionId, revision)` dedupe, surface).
+ * The notification transport (the reactivity application protocol that delivers `NotificationV1` frames
+ * to a subscriber's primary) is the sibling tickets' concern; this manager owns attach + delivery logic.
+ */
+import { type CohortTopicService, type NodeProfile, type NotificationV1, type DeliveryOutcome, type RegistrationHandle, type BackfillV1, type BackfillTransport, type ResumeV1, type ResumeReplyV1, type ResumeApplyOutcome, type StickyCohortHintCache, type CheckpointSummary, type RejoinJitter, type ReRegistrationPlan } from "@optimystic/db-core";
+/** Sends a {@link ResumeV1} to the serving cohort and awaits its classified {@link ResumeReplyV1}. */
+export type ResumeTransport = (req: ResumeV1) => Promise<ResumeReplyV1>;
+/**
+ * A detected tail rotation surfaced to the host so it can schedule the jittered re-registration timer
+ * (`docs/reactivity.md` §Tail rotation). The manager has already invalidated the sticky cohort-hint cache
+ * (the cached primary is under the old tree).
+ */
+export interface RotationNotice {
+    /** The new tail block id the topic rotated to, base64url. */
+    readonly newTailId: string;
+    /** True iff this was a pre-announce (`rotationHint` on a still-current-tail notification). */
+    readonly preAnnounced: boolean;
+    /** The jittered re-registration plan (new topicId + `fireAt` + carried `lastRevision`) for the host to schedule. */
+    readonly plan: ReRegistrationPlan;
+}
+/** Construction inputs for a {@link ReactivitySubscriptionManager}. */
+export interface ReactivitySubscriptionManagerOptions {
+    /** Participant-facing cohort-topic substrate API. */
+    readonly service: CohortTopicService;
+    /** Stable collection identity (the collection's id block id, raw bytes). */
+    readonly collectionId: Uint8Array;
+    /**
+     * Tail block id at attach time (raw bytes); anchors the rotating topic (`reactivityTopicId` is applied to
+     * it) and detects rotation.
+     *
+     * **Load-bearing encoding contract.** When a production subscribe factory converts a `BlockId` tail to
+     * these bytes it MUST use `reactivityTailBytes(tailId)` (`reactivity/topic-bytes.ts`) — the SAME function
+     * origination's membership gate uses — NOT db-core's `blockIdToBytes` (which `sha256`s first → a double
+     * hash). Origination derives the topic's `coord_0` cohort from `reactivityTopicId(reactivityTailBytes(
+     * tailId))`; if this side feeds differently-encoded bytes it subscribes to a *different* coord and
+     * origination silently never reaches it (the `topic-bytes-encoding` spec pins the coord-equality).
+     */
+    readonly tailIdAtAttach: Uint8Array;
+    /** Surface a verified, contiguous notification to the application. */
+    readonly deliver: (n: NotificationV1) => void;
+    /**
+     * Explicit backfill seam — used only when {@link backfillTransport} is **not** supplied. When a
+     * transport is given, the manager builds the db-core {@link createBackfillRequester} driver instead and
+     * this is ignored.
+     */
+    readonly requestBackfill?: (from: number, to: number) => void;
+    /**
+     * Backfill RPC transport (the reactivity application protocol dialing the serving cohort). When
+     * supplied, the manager wires the subscriber's gap-detection seam to the {@link BackfillV1} RPC,
+     * replaying the reply through the delivery path. Requires {@link signBackfill}.
+     */
+    readonly backfillTransport?: BackfillTransport;
+    /** Sign a {@link BackfillV1} over its unsigned image (subscriber peer key); base64url. */
+    readonly signBackfill?: (req: Omit<BackfillV1, "signature">) => string;
+    /** Resume RPC transport (mobile wake). When supplied, {@link resume} is available. Requires {@link signResume}. */
+    readonly resumeTransport?: ResumeTransport;
+    /** Sign a {@link ResumeV1} over its unsigned image (subscriber peer key); base64url. */
+    readonly signResume?: (req: Omit<ResumeV1, "signature">) => string;
+    /**
+     * The subscriber's **real ring coordinate**, base64url (the `participantCoord` it registers under at the
+     * cohort-topic tier), carried in the signed {@link ResumeV1}. The recover transport replies on the same
+     * stream, so this is not used for reply routing today; still, the production factory should source it
+     * correctly so the signed field is meaningful and a future out-of-band reply path is unblocked. Absent ⇒
+     * the manager falls back to the collection id as a placeholder and logs (the signed field is then merely
+     * a stable per-collection token, not the ring coord).
+     */
+    readonly subscriberCoord?: string;
+    /**
+     * Application-level re-attempts the backfill escalation makes after a **transport failure** before giving
+     * up to a resume/chain-read (the sticky-hint dial + one cohort-walk fallback already live in the
+     * transport, so this is a small outer retry). Default `1`. Distinct from the `available`-window underflow
+     * path ({@link onBackfillUnderflow}), which escalates immediately without retrying.
+     */
+    readonly backfillMaxRetries?: number;
+    /** Apply a verified checkpoint's merged digest on a `checkpoint_window` resume. */
+    readonly onCheckpointDigest?: (summary: CheckpointSummary) => void;
+    /** Chain-read + fresh subscribe fallback (out_of_window, or an untrusted checkpoint). */
+    readonly onChainRead?: (currentTailId: string | undefined, currentRevision: number | undefined) => void;
+    /** Re-register under the rotated tail (tail_rotated); also invalidates the sticky cohort-hint cache. */
+    readonly onTailRotated?: (newTailId: string, newRevisionAtRotation: number) => void;
+    /** Escalation when a backfill's `available` window fell past the gap's low edge (escalate to resume/chain). */
+    readonly onBackfillUnderflow?: (requested: {
+        from: number;
+        to: number;
+    }, available: {
+        fromRevision: number;
+        toRevision: number;
+    }) => void;
+    /** Sticky cohort-hint cache for one-RT resume after a flap; defaults to a fresh per-manager cache (Edge). */
+    readonly cohortHintCache?: StickyCohortHintCache;
+    /**
+     * Tail-rotation observer (`docs/reactivity.md` §Tail rotation). Fired once per successor tail when an
+     * inbound notification reveals a rotation (delivered `tailId` differs, or a `rotationHint` pre-announce):
+     * the manager invalidates the sticky cohort-hint cache and hands the host a jittered re-registration plan
+     * to schedule. Absent ⇒ rotation is detected and the cache invalidated, but no plan is surfaced.
+     */
+    readonly onRotation?: (notice: RotationNotice) => void;
+    /** Re-registration jitter for the rotation plan's `fireAt`; defaults to the `T_rejoin_jitter` curve. */
+    readonly rejoinJitter?: RejoinJitter;
+    /** Unix-ms clock for resume timestamps (injected for deterministic tests). Default `Date.now`. */
+    readonly clock?: () => number;
+    /** Last revision already held; `0` (default) for a fresh subscribe. */
+    readonly lastKnownRev?: number;
+    /** Max delta bytes accepted; defaults to `0` on Edge, `delta_max` on Core via {@link profile}. */
+    readonly deltaMaxBytes?: number;
+    /** Subscription TTL (ms). Default: derived from {@link profile} (Core 90 s / Edge 60 s). */
+    readonly ttlMs?: number;
+    /** Node profile used to derive the TTL / delta budget when not given explicitly. */
+    readonly profile?: NodeProfile;
+}
+/** Wires one reactivity subscription to the cohort-topic substrate at tier T3. */
+export declare class ReactivitySubscriptionManager {
+    private readonly service;
+    private readonly collectionId;
+    private readonly collectionIdB64;
+    private readonly tailIdAtAttach;
+    private readonly topicId;
+    private readonly ttlMs;
+    private readonly deltaMaxBytes;
+    private readonly lastKnownRev;
+    private readonly subscriber;
+    private readonly verifier;
+    private readonly options;
+    private readonly cohortHintCache;
+    private readonly clock;
+    private readonly tailIdAtAttachB64;
+    private readonly rejoinJitter;
+    /** Resolved ring coordinate signed into a {@link ResumeV1} (real coord, or the collectionId placeholder). */
+    private readonly subscriberCoord;
+    /** True iff {@link subscriberCoord} fell back to the collectionId placeholder (no real coord supplied). */
+    private readonly subscriberCoordIsFallback;
+    /** The successor tail a rotation has already been surfaced for, so the notice fires once per rotation. */
+    private rotationHandledFor?;
+    /** Memoized db-core backfill driver (built on first gap, once `this.subscriber` is assigned). */
+    private backfillRequester?;
+    private handle?;
+    constructor(options: ReactivitySubscriptionManagerOptions);
+    /**
+     * The subscriber detected a revision gap. When a {@link ReactivitySubscriptionManagerOptions.backfillTransport}
+     * + signer are configured, drive the db-core {@link createBackfillRequester} (build → sign → send →
+     * replay reply through delivery → underflow escalation, built lazily once); otherwise fall back to the
+     * explicit {@link ReactivitySubscriptionManagerOptions.requestBackfill} callback (or no-op).
+     */
+    private onBackfillGap;
+    /**
+     * A backfill RPC failed at the transport (the sticky-hint dial + cohort-walk fallback inside the
+     * transport were already exhausted). Re-attempt up to {@link ReactivitySubscriptionManagerOptions.backfillMaxRetries}
+     * times, then escalate to {@link resume} (when a resume transport is configured) and finally to
+     * {@link ReactivitySubscriptionManagerOptions.onChainRead}. Never rejects (it runs detached off the gap
+     * seam) and never touches the commit/delivery path.
+     */
+    private escalateBackfill;
+    /** The live registration handle, or `undefined` before the first {@link register}. */
+    get registration(): RegistrationHandle | undefined;
+    /** Last contiguously-delivered revision. */
+    get lastRevision(): number;
+    /** Register the subscriber at tier T3 with the reactivity `appPayload`. */
+    register(): Promise<RegistrationHandle>;
+    /** Run one renewal cycle (keep-alive touch). No-op before the first {@link register}. */
+    renew(): Promise<void>;
+    /** Withdraw: stop renewing and send a best-effort signed tombstone so the cohort frees the
+     * registration immediately (TTL expiry remains the fallback if the primary is unreachable). */
+    withdraw(): Promise<void>;
+    /**
+     * Resume after a sleep/flap (`docs/reactivity.md` §Resume). Sends one {@link ResumeV1} from
+     * `lastRevision + 1` to the serving cohort over the injected {@link ResumeTransport} and applies the
+     * classified reply via the db-core {@link applyResumeReply}: a `backfill` / `checkpoint_window` reply
+     * replays its entries through the delivery path (verified, deduped); `out_of_window` and an untrusted
+     * checkpoint escalate to {@link ReactivitySubscriptionManagerOptions.onChainRead}; `tail_rotated`
+     * escalates to {@link ReactivitySubscriptionManagerOptions.onTailRotated} and invalidates the sticky
+     * cohort-hint cache (the cached primary is under the old tree). Throws if no resume transport/signer
+     * was configured.
+     *
+     * The sticky cohort-hint cache (Edge) lets a resume after a brief flap dial the cached primary directly
+     * for a one-RT recovery instead of re-walking from `d_max`; it is the transport's to consult via
+     * {@link cohortHint}.
+     */
+    resume(): Promise<ResumeApplyOutcome>;
+    /** The sticky cohort-hint cache backing one-RT resume after a flap (Edge). */
+    get cohortHint(): StickyCohortHintCache;
+    /**
+     * Run the db-core delivery path for one inbound notification, then check for tail rotation
+     * (`docs/reactivity.md` §Tail rotation): a delivered `tailId` that differs from `tailIdAtAttach`, or a
+     * `rotationHint` pre-announce, invalidates the sticky cohort-hint cache (the cached primary is under the
+     * old tree) and surfaces a jittered re-registration plan via {@link ReactivitySubscriptionManagerOptions.onRotation}.
+     * Fired at most once per successor tail.
+     */
+    onNotification(n: NotificationV1): Promise<DeliveryOutcome>;
+    /** Detect a tail rotation from an inbound notification and surface it once per successor tail. */
+    private checkRotation;
+    /**
+     * Surface a rotation to the host **once per successor tail** (`docs/reactivity.md` §Tail rotation):
+     * invalidate the sticky cohort-hint cache (the cached primary is under the now-stale tree, so a later
+     * resume re-walks) and — when an {@link ReactivitySubscriptionManagerOptions.onRotation} observer is
+     * configured — hand it a jittered re-registration plan carrying `lastRevision` (continuous across the
+     * rotation). The single seam both the notification-driven detection ({@link checkRotation}) and the
+     * recover-driven {@link RotationRedirectError} ({@link honorRotationRedirect}) end in; the
+     * {@link rotationHandledFor} guard self-corrects across a chained OLD→A→B rotation.
+     */
+    private surfaceRotation;
+    /**
+     * Honor a recover-surfaced {@link RotationRedirectError}: the serving cohort's outgoing tail rotated and
+     * bounced this request to the new tree. Route it through the **same** {@link surfaceRotation} seam a
+     * delivered pre-announce uses (`preAnnounced: false`), so both the notify-driven and recover-driven
+     * rotation paths converge on one `RotationNotice` for the host's re-registration scheduler to consume.
+     */
+    private honorRotationRedirect;
+}
+//# sourceMappingURL=subscription-manager.d.ts.map

package/dist/src/reactivity/subscription-manager.d.ts.map

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