@optimystic/db-p2p 0.13.4 → 0.14.0

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

@@ -0,0 +1,110 @@
+/**
+ * Reactivity — notification origination manager (db-p2p, wires to the cohort-topic substrate).
+ *
+ * Installs the substrate's {@link CohortTopicService.onLocalCommit} origination hook so a commit landing
+ * on a node that is a tail-cohort member for the collection's reactivity topic emits a signed
+ * {@link NotificationV1} (`docs/reactivity.md` §Notification origination). The local-change-notifier
+ * bridge ([local-change-notifier-bridge]) supplies the {@link CollectionChangeEvent} + pass-through
+ * {@link CommitCert}; this manager calls db-core's {@link buildNotificationV1} (which reuses the commit
+ * cert's threshold signature **unchanged** — reactivity never re-signs) and hands the result to the
+ * injected {@link emit} transport, which fans it out to direct subscribers and child cohorts.
+ *
+ * The cluster keys its commit votes by **peer-id string**; the cohort-topic membership verifier compares
+ * signers as the member-id **bytes** (UTF-8 of the peer-id string, base64url on the wire). So this
+ * manager supplies `encodeSigner = s ⇒ bytesToB64url(peerIdToBytes(s))`, the inverse the subscriber's
+ * {@link createNotificationVerifier} default (`b64urlToBytes`) consumes — closing the encoding loop end
+ * to end.
+ */
+import { type BlockFillTrackerInit, type CohortTopicService, type CollectionChangeEvent, type NotificationV1, type RotationHintV1 } from "@optimystic/db-core";
+/** Per-collection origination context the manager resolves at emit time. */
+export interface OriginationCollectionContext {
+    /** Current tail block id the reactivity topic is anchored on (raw bytes). */
+    readonly tailId: Uint8Array;
+    /** Per-collection delta budget (bytes); `0` ⇒ omit `delta` (Edge / collection declines deltas). */
+    readonly deltaMaxBytes: number;
+    /** Optional bounded delta to attach (raw bytes). */
+    readonly delta?: Uint8Array;
+    /** Optional tail-rotation pre-announce (rotation ticket supplies it). */
+    readonly rotationHint?: RotationHintV1;
+}
+/** Construction inputs for a {@link ReactivityOriginationManager}. */
+export interface ReactivityOriginationManagerOptions {
+    /** The cohort-topic substrate whose `onLocalCommit` hook this manager installs. */
+    readonly service: CohortTopicService;
+    /**
+     * Resolve the per-collection origination context (tail id, delta budget) for a change event. Returns
+     * `undefined` to skip origination for this collection (e.g. this node is not the tail primary for it).
+     */
+    readonly resolveContext: (event: CollectionChangeEvent) => OriginationCollectionContext | undefined;
+    /** Fan the built notification out to direct subscribers and child cohorts (the reactivity transport). */
+    readonly emit: (notification: NotificationV1) => void;
+    /**
+     * Start the **outgoing** tail's drain when this manager observes a collection's tail id **change**
+     * between commits (the authoritative, observable live-node rotation signal — the pre-announce
+     * `rotationHint{ newTailId }` cannot be built on a live node because the successor tail id is not knowable
+     * at the filling commit; see `docs/reactivity.md` §Tail rotation and the `6.5-block-id-derivation` gate).
+     * The node binds this to {@link import("./forwarder-host.js").ReactivityForwarderHost.markRotated} so the
+     * old cohort's recover serve begins redirecting. `oldTopicId` is the **previous** tail's reactivity topic
+     * id (`reactivityTopicId` over the resolved tail bytes — the SAME encoding a subscriber subscribes under).
+     * Absent ⇒ origination is unchanged (rotation observation is inert), preserving existing callers/tests.
+     */
+    readonly markRotated?: (oldTopicId: Uint8Array, redirect: {
+        newTailId: string;
+        effectiveAtRevision: number;
+    }, now: number) => void;
+    /**
+     * Per-collection {@link BlockFillTracker} tuning for the anticipatory **warm-up** signal. The warm-up is
+     * best-effort and **signal-only** on a live node (the next `tailId` is not knowable, so no successor coord
+     * is fabricated — the bias is logged, never acted on; `docs/reactivity.md` §Anticipatory warm-up). Defaults
+     * to the db-core block-fill defaults.
+     */
+    readonly blockFill?: BlockFillTrackerInit;
+    /** Wall clock (unix ms) stamped on each notification. Default `Date.now`. */
+    readonly clock?: () => number;
+}
+/** Installs and drives the reactivity origination hook on a {@link CohortTopicService}. */
+export declare class ReactivityOriginationManager {
+    private readonly service;
+    private readonly resolveContext;
+    private readonly emit;
+    private readonly markRotated?;
+    private readonly blockFill?;
+    private readonly clock;
+    /** Last-seen reactivity tail anchor (base64url of the resolved tail bytes) per collection — the rotation signal. */
+    private readonly lastSeenTail;
+    /** Per-collection block-fill tracker driving the anticipatory warm-up signal (signal-only on a live node). */
+    private readonly fillTrackers;
+    constructor(options: ReactivityOriginationManagerOptions);
+    /** Install the origination hook (overwrites any prior `onLocalCommit`). */
+    install(): void;
+    /** Build + emit the notification for one committed change; isolates throws so commit is never broken. */
+    private originate;
+    /**
+     * Track the collection's reactivity tail and drive the rotation + warm-up signals. Isolated so a fault
+     * here never blocks the notification emit. Only reached for commits this node originates (a defined `ctx`),
+     * so a tail-less (read-driven) commit never records or clears the last-seen tail (the early-return holds).
+     */
+    private observeTail;
+    /**
+     * Feed the per-collection {@link BlockFillTracker} one commit. The `warmup` signal is **best-effort and
+     * signal-only** on a live node: the next `tailId` is not knowable (block ids are random until
+     * `6.5-block-id-derivation`), so the anticipatory pre-dial bias is logged, never fabricated into a
+     * successor coord (`docs/reactivity.md` §Anticipatory warm-up). The `filling` signal cannot pre-announce a
+     * hint on a live node for the same reason — it is logged only.
+     */
+    private trackBlockFill;
+    /**
+     * Detect a tail rotation by comparing the resolved tail anchor against the last-seen one for the
+     * collection. The first commit records the baseline (no rotation). On a **change**, the previous tail's
+     * reactivity topic has rotated to this one: fire {@link markRotated} for the OLD topic so the old cohort's
+     * recover serve begins redirecting to the new tree.
+     *
+     * **Encoding contract.** `ctx.tailId` is the reactivity tail anchor bytes the node resolved
+     * (`reactivityTailBytes(event.tailId)` in production — the SAME utf8 encoding origination's membership gate
+     * and a subscriber's `reactivityTopicId(reactivityTailBytes(tail))` use, NOT the double-hashing
+     * `blockIdToBytes`). So `oldTopicId = reactivityTopicId(oldAnchorBytes)` is byte-identical to the topic a
+     * subscriber subscribed under — a mismatch would silently never redirect.
+     */
+    private detectTailRotation;
+}
+//# sourceMappingURL=origination-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"origination-manager.d.ts","sourceRoot":"","sources":["../../../src/reactivity/origination-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAMN,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAE1B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,MAAM,qBAAqB,CAAC;AAM7B,4EAA4E;AAC5E,MAAM,WAAW,4BAA4B;IAC5C,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,mGAAmG;IACnG,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC;CACvC;AAED,sEAAsE;AACtE,MAAM,WAAW,mCAAmC;IACnD,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,4BAA4B,GAAG,SAAS,CAAC;IACpG,yGAAyG;IACzG,QAAQ,CAAC,IAAI,EAAE,CAAC,YAAY,EAAE,cAAc,KAAK,IAAI,CAAC;IACtD;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACnI;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,oBAAoB,CAAC;IAC1C,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC9B;AAED,2FAA2F;AAC3F,qBAAa,4BAA4B;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6E;IAC5G,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyC;IAC9D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAA8G;IAC3I,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAuB;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IAErC,oHAAoH;IACpH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAC1D,8GAA8G;IAC9G,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuC;gBAExD,OAAO,EAAE,mCAAmC;IASxD,2EAA2E;IAC3E,OAAO,IAAI,IAAI;IAIf,yGAAyG;IACzG,OAAO,CAAC,SAAS;IAuBjB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IASnB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,kBAAkB;CAU1B"}

package/dist/src/reactivity/origination-manager.js

@@ -0,0 +1,129 @@
+/**
+ * Reactivity — notification origination manager (db-p2p, wires to the cohort-topic substrate).
+ *
+ * Installs the substrate's {@link CohortTopicService.onLocalCommit} origination hook so a commit landing
+ * on a node that is a tail-cohort member for the collection's reactivity topic emits a signed
+ * {@link NotificationV1} (`docs/reactivity.md` §Notification origination). The local-change-notifier
+ * bridge ([local-change-notifier-bridge]) supplies the {@link CollectionChangeEvent} + pass-through
+ * {@link CommitCert}; this manager calls db-core's {@link buildNotificationV1} (which reuses the commit
+ * cert's threshold signature **unchanged** — reactivity never re-signs) and hands the result to the
+ * injected {@link emit} transport, which fans it out to direct subscribers and child cohorts.
+ *
+ * The cluster keys its commit votes by **peer-id string**; the cohort-topic membership verifier compares
+ * signers as the member-id **bytes** (UTF-8 of the peer-id string, base64url on the wire). So this
+ * manager supplies `encodeSigner = s ⇒ bytesToB64url(peerIdToBytes(s))`, the inverse the subscriber's
+ * {@link createNotificationVerifier} default (`b64urlToBytes`) consumes — closing the encoding loop end
+ * to end.
+ */
+import { buildNotificationV1, bytesToB64url, b64urlToBytes, reactivityTopicId, BlockFillTracker, } from "@optimystic/db-core";
+import { peerIdToBytes } from "../cohort-topic/peer-codec.js";
+import { createLogger } from "../logger.js";
+const log = createLogger("reactivity-origination");
+/** Installs and drives the reactivity origination hook on a {@link CohortTopicService}. */
+export class ReactivityOriginationManager {
+    service;
+    resolveContext;
+    emit;
+    markRotated;
+    blockFill;
+    clock;
+    /** Last-seen reactivity tail anchor (base64url of the resolved tail bytes) per collection — the rotation signal. */
+    lastSeenTail = new Map();
+    /** Per-collection block-fill tracker driving the anticipatory warm-up signal (signal-only on a live node). */
+    fillTrackers = new Map();
+    constructor(options) {
+        this.service = options.service;
+        this.resolveContext = options.resolveContext;
+        this.emit = options.emit;
+        this.markRotated = options.markRotated;
+        this.blockFill = options.blockFill;
+        this.clock = options.clock ?? (() => Date.now());
+    }
+    /** Install the origination hook (overwrites any prior `onLocalCommit`). */
+    install() {
+        this.service.onLocalCommit = (event, commitCert) => this.originate(event, commitCert);
+    }
+    /** Build + emit the notification for one committed change; isolates throws so commit is never broken. */
+    originate(event, commitCert) {
+        try {
+            const ctx = this.resolveContext(event);
+            if (ctx === undefined) {
+                return; // not the origination point for this collection (tail-less / non-member)
+            }
+            // Observe the tail (rotation detection + block-fill warm-up) BEFORE emit, fully isolated so neither
+            // ever blocks the notification — the delivery-critical path.
+            this.observeTail(event, ctx);
+            const notification = buildNotificationV1(event, commitCert, {
+                tailId: bytesToB64url(ctx.tailId),
+                timestamp: this.clock(),
+                deltaMaxBytes: ctx.deltaMaxBytes,
+                delta: ctx.delta,
+                rotationHint: ctx.rotationHint,
+                encodeSigner: (s) => bytesToB64url(peerIdToBytes(s)),
+            });
+            this.emit(notification);
+        }
+        catch (err) {
+            log("origination failed for collection=%s rev=%d: %o", event.collectionId, event.rev, err);
+        }
+    }
+    /**
+     * Track the collection's reactivity tail and drive the rotation + warm-up signals. Isolated so a fault
+     * here never blocks the notification emit. Only reached for commits this node originates (a defined `ctx`),
+     * so a tail-less (read-driven) commit never records or clears the last-seen tail (the early-return holds).
+     */
+    observeTail(event, ctx) {
+        try {
+            this.trackBlockFill(event);
+            this.detectTailRotation(event, ctx);
+        }
+        catch (err) {
+            log("rotation/warm-up observation failed for collection=%s rev=%d (isolated): %o", event.collectionId, event.rev, err);
+        }
+    }
+    /**
+     * Feed the per-collection {@link BlockFillTracker} one commit. The `warmup` signal is **best-effort and
+     * signal-only** on a live node: the next `tailId` is not knowable (block ids are random until
+     * `6.5-block-id-derivation`), so the anticipatory pre-dial bias is logged, never fabricated into a
+     * successor coord (`docs/reactivity.md` §Anticipatory warm-up). The `filling` signal cannot pre-announce a
+     * hint on a live node for the same reason — it is logged only.
+     */
+    trackBlockFill(event) {
+        const key = event.collectionId;
+        let tracker = this.fillTrackers.get(key);
+        if (tracker === undefined) {
+            tracker = new BlockFillTracker(this.blockFill);
+            this.fillTrackers.set(key, tracker);
+        }
+        const signal = tracker.onCommit();
+        if (signal.kind === "warmup") {
+            log("block-fill warm-up for collection=%s (%d committed, %d remaining) — anticipatory pre-dial is signal-only on a live node (successor tail not knowable; gated on 6.5-block-id-derivation)", key, signal.count, signal.remaining);
+        }
+        else if (signal.kind === "filling") {
+            log("block-fill filling commit for collection=%s (%d committed) — no live pre-announce (successor tail id not knowable; rotation observed on the next commit's tail-id change)", key, signal.count);
+        }
+    }
+    /**
+     * Detect a tail rotation by comparing the resolved tail anchor against the last-seen one for the
+     * collection. The first commit records the baseline (no rotation). On a **change**, the previous tail's
+     * reactivity topic has rotated to this one: fire {@link markRotated} for the OLD topic so the old cohort's
+     * recover serve begins redirecting to the new tree.
+     *
+     * **Encoding contract.** `ctx.tailId` is the reactivity tail anchor bytes the node resolved
+     * (`reactivityTailBytes(event.tailId)` in production — the SAME utf8 encoding origination's membership gate
+     * and a subscriber's `reactivityTopicId(reactivityTailBytes(tail))` use, NOT the double-hashing
+     * `blockIdToBytes`). So `oldTopicId = reactivityTopicId(oldAnchorBytes)` is byte-identical to the topic a
+     * subscriber subscribed under — a mismatch would silently never redirect.
+     */
+    detectTailRotation(event, ctx) {
+        const key = event.collectionId;
+        const newTailB64 = bytesToB64url(ctx.tailId);
+        const lastTailB64 = this.lastSeenTail.get(key);
+        if (lastTailB64 !== undefined && lastTailB64 !== newTailB64) {
+            const oldTopicId = reactivityTopicId(b64urlToBytes(lastTailB64));
+            this.markRotated?.(oldTopicId, { newTailId: newTailB64, effectiveAtRevision: event.rev }, this.clock());
+        }
+        this.lastSeenTail.set(key, newTailB64);
+    }
+}
+//# sourceMappingURL=origination-manager.js.map

package/dist/src/reactivity/origination-manager.js.map

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

package/dist/src/reactivity/protocols.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Reactivity libp2p protocol IDs (`docs/reactivity.md` §Propagation / §Notification origination).
+ *
+ * The reactivity family rides the same FRET/libp2p node as the cohort-topic substrate it is layered on:
+ *
+ * - `notify`            — `NotificationV1` fan-out down the reactivity tree (one-way, fire-and-forget).
+ * - `push-state-gossip` — `PushStateGossipV1` intra-cohort push-state convergence (one-way). Declared
+ *                         here so one place owns the family; the `reactivity-pushstate-gossip` ticket
+ *                         consumes it.
+ * - `recover`           — `RecoverRequestV1`/`RecoverReplyV1` backfill/resume recovery RPC
+ *                         (request-reply, one frame each way). Consumed by `reactivity-recover-rpc-transport`.
+ *
+ * The default (network-agnostic) IDs omit the network segment; {@link makeReactivityProtocols} mirrors
+ * FRET's `makeProtocols(networkName)` so a named network namespaces its reactivity protocols the same way
+ * FRET namespaces its routing protocols (and the cohort-topic family namespaces via
+ * {@link import("../cohort-topic/protocols.js").makeCohortTopicProtocols}).
+ */
+/** Base path for the reactivity protocol family. */
+export declare const REACTIVITY_BASE: "/optimystic/reactivity/1.0.0";
+/** `NotificationV1` — change-notification fan-out down the reactivity tree (one-way). */
+export declare const PROTOCOL_REACTIVITY_NOTIFY: "/optimystic/reactivity/1.0.0/notify";
+/** `PushStateGossipV1` — intra-cohort push-state convergence (one-way) [used by reactivity-pushstate-gossip]. */
+export declare const PROTOCOL_REACTIVITY_PUSH_STATE_GOSSIP: "/optimystic/reactivity/1.0.0/push-state-gossip";
+/** `RecoverRequestV1`/`RecoverReplyV1` — backfill/resume recovery RPC (request-reply) [used by reactivity-recover-rpc-transport]. */
+export declare const PROTOCOL_REACTIVITY_RECOVER: "/optimystic/reactivity/1.0.0/recover";
+/** The reactivity protocol IDs in registration order. */
+export interface ReactivityProtocols {
+    readonly notify: string;
+    readonly pushStateGossip: string;
+    readonly recover: string;
+}
+/** Default (network-agnostic) protocol IDs, matching `docs/reactivity.md`. */
+export declare const DEFAULT_REACTIVITY_PROTOCOLS: ReactivityProtocols;
+/**
+ * Namespaced reactivity protocol IDs for `networkName` (mirrors FRET's `makeProtocols`, which inserts the
+ * network segment even for `"default"` → `/optimystic/default/...`). Note this does NOT equal
+ * {@link DEFAULT_REACTIVITY_PROTOCOLS}: the canonical, network-agnostic IDs omit the segment entirely
+ * (`/optimystic/reactivity/1.0.0/...`); use those unless you need per-network namespacing.
+ */
+export declare function makeReactivityProtocols(networkName?: string): ReactivityProtocols;
+/** All reactivity protocol IDs as an array (for `node.handle` / `unhandle` over the set). */
+export declare function reactivityProtocolList(p: ReactivityProtocols): string[];
+//# sourceMappingURL=protocols.d.ts.map

package/dist/src/reactivity/protocols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocols.d.ts","sourceRoot":"","sources":["../../../src/reactivity/protocols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,oDAAoD;AACpD,eAAO,MAAM,eAAe,EAAG,8BAAuC,CAAC;AAEvE,yFAAyF;AACzF,eAAO,MAAM,0BAA0B,uCAAuC,CAAC;AAC/E,iHAAiH;AACjH,eAAO,MAAM,qCAAqC,kDAAkD,CAAC;AACrG,qIAAqI;AACrI,eAAO,MAAM,2BAA2B,wCAAwC,CAAC;AAEjF,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,8EAA8E;AAC9E,eAAO,MAAM,4BAA4B,EAAE,mBAI1C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,SAAY,GAAG,mBAAmB,CAOpF;AAED,6FAA6F;AAC7F,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAEvE"}

package/dist/src/reactivity/protocols.js

@@ -0,0 +1,50 @@
+/**
+ * Reactivity libp2p protocol IDs (`docs/reactivity.md` §Propagation / §Notification origination).
+ *
+ * The reactivity family rides the same FRET/libp2p node as the cohort-topic substrate it is layered on:
+ *
+ * - `notify`            — `NotificationV1` fan-out down the reactivity tree (one-way, fire-and-forget).
+ * - `push-state-gossip` — `PushStateGossipV1` intra-cohort push-state convergence (one-way). Declared
+ *                         here so one place owns the family; the `reactivity-pushstate-gossip` ticket
+ *                         consumes it.
+ * - `recover`           — `RecoverRequestV1`/`RecoverReplyV1` backfill/resume recovery RPC
+ *                         (request-reply, one frame each way). Consumed by `reactivity-recover-rpc-transport`.
+ *
+ * The default (network-agnostic) IDs omit the network segment; {@link makeReactivityProtocols} mirrors
+ * FRET's `makeProtocols(networkName)` so a named network namespaces its reactivity protocols the same way
+ * FRET namespaces its routing protocols (and the cohort-topic family namespaces via
+ * {@link import("../cohort-topic/protocols.js").makeCohortTopicProtocols}).
+ */
+/** Base path for the reactivity protocol family. */
+export const REACTIVITY_BASE = "/optimystic/reactivity/1.0.0";
+/** `NotificationV1` — change-notification fan-out down the reactivity tree (one-way). */
+export const PROTOCOL_REACTIVITY_NOTIFY = `${REACTIVITY_BASE}/notify`;
+/** `PushStateGossipV1` — intra-cohort push-state convergence (one-way) [used by reactivity-pushstate-gossip]. */
+export const PROTOCOL_REACTIVITY_PUSH_STATE_GOSSIP = `${REACTIVITY_BASE}/push-state-gossip`;
+/** `RecoverRequestV1`/`RecoverReplyV1` — backfill/resume recovery RPC (request-reply) [used by reactivity-recover-rpc-transport]. */
+export const PROTOCOL_REACTIVITY_RECOVER = `${REACTIVITY_BASE}/recover`;
+/** Default (network-agnostic) protocol IDs, matching `docs/reactivity.md`. */
+export const DEFAULT_REACTIVITY_PROTOCOLS = {
+    notify: PROTOCOL_REACTIVITY_NOTIFY,
+    pushStateGossip: PROTOCOL_REACTIVITY_PUSH_STATE_GOSSIP,
+    recover: PROTOCOL_REACTIVITY_RECOVER,
+};
+/**
+ * Namespaced reactivity protocol IDs for `networkName` (mirrors FRET's `makeProtocols`, which inserts the
+ * network segment even for `"default"` → `/optimystic/default/...`). Note this does NOT equal
+ * {@link DEFAULT_REACTIVITY_PROTOCOLS}: the canonical, network-agnostic IDs omit the segment entirely
+ * (`/optimystic/reactivity/1.0.0/...`); use those unless you need per-network namespacing.
+ */
+export function makeReactivityProtocols(networkName = "default") {
+    const base = `/optimystic/${networkName}/reactivity/1.0.0`;
+    return {
+        notify: `${base}/notify`,
+        pushStateGossip: `${base}/push-state-gossip`,
+        recover: `${base}/recover`,
+    };
+}
+/** All reactivity protocol IDs as an array (for `node.handle` / `unhandle` over the set). */
+export function reactivityProtocolList(p) {
+    return [p.notify, p.pushStateGossip, p.recover];
+}
+//# sourceMappingURL=protocols.js.map

package/dist/src/reactivity/protocols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocols.js","sourceRoot":"","sources":["../../../src/reactivity/protocols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,oDAAoD;AACpD,MAAM,CAAC,MAAM,eAAe,GAAG,8BAAuC,CAAC;AAEvE,yFAAyF;AACzF,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,eAAe,SAAkB,CAAC;AAC/E,iHAAiH;AACjH,MAAM,CAAC,MAAM,qCAAqC,GAAG,GAAG,eAAe,oBAA6B,CAAC;AACrG,qIAAqI;AACrI,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAG,eAAe,UAAmB,CAAC;AASjF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,4BAA4B,GAAwB;IAChE,MAAM,EAAE,0BAA0B;IAClC,eAAe,EAAE,qCAAqC;IACtD,OAAO,EAAE,2BAA2B;CACpC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAW,GAAG,SAAS;IAC9D,MAAM,IAAI,GAAG,eAAe,WAAW,mBAAmB,CAAC;IAC3D,OAAO;QACN,MAAM,EAAE,GAAG,IAAI,SAAS;QACxB,eAAe,EAAE,GAAG,IAAI,oBAAoB;QAC5C,OAAO,EAAE,GAAG,IAAI,UAAU;KAC1B,CAAC;AACH,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,sBAAsB,CAAC,CAAsB;IAC5D,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC"}

package/dist/src/reactivity/push-state-gossip.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Reactivity — `PushState` intra-cohort gossip driver (`docs/reactivity.md` §Replay window,
+ * §Forwarder-cohort state).
+ *
+ * The forwarder-cohort replay ring + dedupe window are the substrate that makes the doc's "**any** cohort
+ * member — not just the primary — can serve a replay/backfill" property real: a member that missed an
+ * origin dial still ends up holding the entry, so a backfill (12.4) survives a primary failover. The
+ * db-core {@link PushState} already owns the codec ({@link encodePushStateGossipV1} /
+ * {@link decodePushStateGossipV1}, {@link PushState.serializeGossip} / {@link PushState.mergeGossip}); this
+ * driver is the **replication** layer that actually broadcasts and merges that state over libp2p on a
+ * periodic cadence — the backstop to the live fan-out ({@link import("./forwarder-host.js")}).
+ *
+ * **Transport reuse.** Rather than stand up a new transport, this rides the cohort gossip transport's
+ * {@link import("../cohort-topic/cohort-gossip-transport.js").FretCohortGossipTransport.broadcastOver}
+ * seam — the same one the promote-notice broadcast reuses — so the cohort peer resolution, self-exclusion,
+ * and per-peer failure swallowing are shared. Frames ride the dedicated
+ * {@link PROTOCOL_REACTIVITY_PUSH_STATE_GOSSIP} (one-way), fanned to the FRET-assembled cohort around each
+ * served collection's cohort coord. Inbound frames arrive on this node's `push-state-gossip` protocol
+ * handler (registered by the node-wiring ticket) and route to {@link ReactivityPushStateGossipDriver.deliver}.
+ *
+ * **Cadence.** Its own unref'd timer (parallel to the cohort host's single `setInterval`), reusing
+ * {@link DEFAULT_GOSSIP_INTERVAL_MS} and the host's re-entrancy / `stopped` / `unref` discipline verbatim.
+ * Reactivity collections are not 1:1 with the host's per-`CoordEngine` tick and the forwarder host owns the
+ * live {@link PushState} set, so a separate timer is the clean seam now; a future consolidation could fold
+ * this into the host tick via a hook, but a separate unref'd timer cannot pin an idle process.
+ *
+ * The **driver** touches neither the libp2p node assembly nor FRET cohort assembly — it depends only on the
+ * `broadcastOver` seam + db-core codec, so it is unit-testable with a fake transport and real `PushState`s.
+ * The co-located {@link registerPushStateGossipHandler} (the inbound protocol-handler registration) does
+ * bind libp2p, mirroring {@link import("./notify-transport.js").registerNotifyHandler} — the driver class
+ * stays pure; only that one helper reaches the node.
+ */
+import { type PushState, type PushStateGossipV1, type RingCoord } from "@optimystic/db-core";
+import type { Libp2p } from "libp2p";
+import type { FretCohortGossipTransport } from "../cohort-topic/cohort-gossip-transport.js";
+/** A live forwarder collection to gossip: its {@link PushState} and the cohort coord to broadcast to. */
+export interface ReactivityGossipCollection {
+    readonly pushState: PushState;
+    readonly cohortCoord: RingCoord;
+}
+/** A truncation event: a collection's serialized replay ring exceeded the frame bound and was clipped. */
+export interface PushStateGossipTruncation {
+    readonly collectionId: string;
+    readonly topicId: string;
+    /** Most-recent replay entries kept in the broadcast frame. */
+    readonly kept: number;
+    /** Replay entries the ring actually held this round. */
+    readonly total: number;
+    /** Bytes of the broadcast (clipped) frame. */
+    readonly frameBytes: number;
+    /** The configured per-frame ceiling. */
+    readonly maxBytes: number;
+}
+/** Construction inputs for a {@link ReactivityPushStateGossipDriver}. */
+export interface ReactivityPushStateGossipDriverDeps {
+    /** Reuse the node's cohort gossip transport (`broadcastOver`) — no new transport. */
+    readonly gossipTransport: Pick<FretCohortGossipTransport, "broadcastOver">;
+    /** The live forwarder collections to gossip each round, with the cohort coord to broadcast to. */
+    readonly liveCollections: () => Iterable<ReactivityGossipCollection>;
+    /** Resolve the collection owning an inbound frame (by collectionId/topicId) → its {@link PushState}, or undefined. */
+    readonly pushStateForGossip: (g: PushStateGossipV1) => PushState | undefined;
+    /** Inbound authenticity gate: is `fromPeerId` a member of the cohort for the frame's coord? Absent ⇒ accept all. */
+    readonly isCohortMember?: (fromPeerId: string, g: PushStateGossipV1) => boolean;
+    /** Cadence interval. Default {@link DEFAULT_GOSSIP_INTERVAL_MS}. */
+    readonly intervalMs?: number;
+    /** Per-frame ceiling (frame, including the length prefix, stays within this). Default {@link DEFAULT_STREAM_MAX_BYTES}. */
+    readonly maxBytes?: number;
+    /** Reserved for parity with the cohort host's tick discipline; unused today (gossip carries its own `receivedAt`). */
+    readonly clock?: () => number;
+    /** Observe a clipped (over-bound) frame, in addition to the "no silent cap" log. Test/diagnostic seam. */
+    readonly onTruncate?: (info: PushStateGossipTruncation) => void;
+}
+/**
+ * Drives {@link PushState} convergence across a forwarder cohort: each round it broadcasts every live
+ * collection's serialized push-state to the cohort (clipped to the frame bound), and each inbound frame is
+ * gated, resolved to the owning collection, and merged. Build one per node and bind its inbound
+ * {@link ReactivityPushStateGossipDriver.deliver} to the `push-state-gossip` protocol handler.
+ */
+export declare class ReactivityPushStateGossipDriver {
+    private readonly gossipTransport;
+    private readonly liveCollections;
+    private readonly pushStateForGossip;
+    private readonly isCohortMember?;
+    private readonly intervalMs;
+    private readonly maxBytes;
+    private readonly onTruncate?;
+    private timer?;
+    private stopped;
+    /** Re-entrancy guard mirroring the host tick: skip a round that overlaps a slow prior one. */
+    private rounding;
+    constructor(deps: ReactivityPushStateGossipDriverDeps);
+    /** Begin the unref'd cadence timer. Idempotent; a no-op once {@link stop} has run. */
+    start(): void;
+    /**
+     * One round: broadcast each live collection's serialized {@link PushState} to its cohort, clipped to the
+     * frame bound. Per-collection isolated (one collection's fault never skips the rest) and `stopped`-gated
+     * mid-loop, mirroring the host tick.
+     */
+    round(): void;
+    /**
+     * Inbound handler body: decode → membership gate → resolve owning collection → merge. Never throws on a
+     * bad frame (a malformed/forged/foreign frame is logged and dropped), so a stream handler can call it
+     * directly. `mergeGossip` independently guards a collection/topic mismatch, so the resolve step is a fast
+     * pre-filter, not the only line of defense.
+     */
+    deliver(fromPeerId: string, frame: Uint8Array): void;
+    /** Stop the cadence: short-circuit any in-flight/future round and clear the timer. */
+    stop(): void;
+    /** Serialize one collection, clip to the frame bound, and broadcast to its cohort. */
+    private broadcastOne;
+    /**
+     * Build the broadcast frame for one serialized push-state, kept within {@link maxBytes}.
+     *
+     * The whole replay ring (`W` up to 256 full `NotificationV1`s) can exceed the frame bound. When it does,
+     * keep the full (small) dedupe window and the **most-recent-N** replay entries that fit — sliced from the
+     * high-revision end, since a lagging subscriber backfills the newest gap first and older revisions roll
+     * to the parent checkpoint anyway. Frame size is monotone in the entry count, so binary-search the
+     * high-water N rather than re-encoding per entry.
+     */
+    private boundedFrame;
+    /** Encode `g` with only its most-recent `keep` replay entries retained (the full dedupe window is kept). */
+    private encodeSlice;
+}
+/**
+ * Register the inbound push-state-gossip protocol handler: read one bounded frame and hand it to
+ * {@link ReactivityPushStateGossipDriver.deliver} (which decodes, membership-gates, and merges), then close.
+ * One-way — no reply frame, matching the cohort-topic gossip handlers. A read error aborts the stream and
+ * {@link ReactivityPushStateGossipDriver.deliver} swallows a decode/forge/foreign failure, so the handler
+ * never throws on the stream. Mirrors {@link import("./notify-transport.js").registerNotifyHandler}.
+ */
+export declare function registerPushStateGossipHandler(node: Libp2p, protocol: string, driver: Pick<ReactivityPushStateGossipDriver, "deliver">, maxBytes?: number): void;
+//# sourceMappingURL=push-state-gossip.d.ts.map

package/dist/src/reactivity/push-state-gossip.d.ts.map

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