@optimystic/db-core 0.13.4 → 0.14.0

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

@@ -0,0 +1,118 @@
+/**
+ * Reactivity — Backfill RPC (`docs/reactivity.md` §Backfill RPC, §Wire formats).
+ *
+ * A subscriber that detects a revision gap (slow-subscriber drop, brief sleep) requests the missing
+ * range from its serving cohort; the cohort answers from its {@link ReplayBuffer} ring. The reply
+ * carries the **intersection** of the requested range with the buffer plus the `available` window the
+ * cohort actually holds, so a subscriber whose lag fell past the ring's low edge learns it must fall
+ * back further (to a checkpoint resume or a chain read) rather than silently receiving a short answer.
+ *
+ * Entries retain the original threshold signature (the buffer stores full {@link NotificationV1}s), so a
+ * backfill reply is verifiable **end-to-end** — the subscriber re-runs the same {@link NotificationVerifier}
+ * over each backfilled entry it runs over a live notification. Any cohort member can serve, because the
+ * replay buffer is gossiped across the cohort (origination ticket).
+ *
+ * Wire conventions match the rest of reactivity: JSON, byte fields base64url, unix-ms timestamps, `v: 1`,
+ * per-message structural validation on decode. `BackfillV1` is signed by the subscriber's peer key
+ * (`signature`); replay protection rides the request envelope as elsewhere in the substrate.
+ */
+import type { ReplayBuffer } from "./replay-buffer.js";
+import type { ReactivitySubscriber } from "./subscriber.js";
+import { type NotificationV1 } from "./wire.js";
+/** A subscriber's request to replay a contiguous revision range from a cohort's buffer. */
+export interface BackfillV1 {
+    v: 1;
+    /** Collection id, base64url. */
+    collectionId: string;
+    /** Inclusive low edge of the requested range. */
+    fromRevision: number;
+    /** Inclusive high edge of the requested range. */
+    toRevision: number;
+    /**
+     * Unix ms — bound into {@link backfillSigningPayload} so the request's freshness is authenticated.
+     * The serving handler's replay guard keys on the signature + this timestamp, so a captured request
+     * cannot be replayed with a forged-fresh timestamp (the forged value invalidates the signature).
+     */
+    timestamp: number;
+    /** Subscriber peer-key signature over the request. */
+    signature: string;
+}
+/** The cohort's reply: the held intersection of the request, plus the window it actually has. */
+export interface BackfillReplyV1 {
+    v: 1;
+    /** The signed notifications in `[from, to] ∩ buffer`, ascending by revision. */
+    entries: NotificationV1[];
+    /** The revision window the serving cohort actually holds (so the subscriber can fall back further). */
+    available: {
+        fromRevision: number;
+        toRevision: number;
+    };
+}
+/** Narrow an already-parsed value to {@link BackfillV1}, throwing on any defect. */
+export declare function validateBackfillV1(value: unknown): BackfillV1;
+/** A {@link BackfillV1} minus its `signature` — the canonical bytes the subscriber peer-key-signs. */
+export type BackfillSignable = Omit<BackfillV1, "signature">;
+/**
+ * Canonical signed byte image of a {@link BackfillV1} (every field except `signature`). Mirrors the
+ * cohort-topic `registerSigningPayload` pattern: determinism comes from encoding an explicitly-ordered,
+ * type-tagged JSON array (array order is stable; object key order is not) as UTF-8. The leading
+ * `"BackfillV1"` tag means a backfill image can never collide with the `"ResumeV1"` image even when the
+ * shared fields are identical. Signer and verifier must agree byte-for-byte — the array order is the
+ * contract (pinned by the determinism test).
+ */
+export declare function backfillSigningPayload(body: BackfillSignable): Uint8Array;
+/** Narrow an already-parsed value to {@link BackfillReplyV1}, throwing on any defect. */
+export declare function validateBackfillReplyV1(value: unknown): BackfillReplyV1;
+/** Encode a {@link BackfillV1} as a length-prefixed UTF-8 JSON frame. */
+export declare function encodeBackfillV1(msg: BackfillV1, maxMessageBytes?: number): Uint8Array;
+/** Decode a length-prefixed {@link BackfillV1} frame. */
+export declare function decodeBackfillV1(bytes: Uint8Array, maxMessageBytes?: number): BackfillV1;
+/** Encode a {@link BackfillReplyV1} as a length-prefixed UTF-8 JSON frame. */
+export declare function encodeBackfillReplyV1(msg: BackfillReplyV1, maxMessageBytes?: number): Uint8Array;
+/** Decode a length-prefixed {@link BackfillReplyV1} frame. */
+export declare function decodeBackfillReplyV1(bytes: Uint8Array, maxMessageBytes?: number): BackfillReplyV1;
+/**
+ * Serve a {@link BackfillV1} from a cohort's replay buffer: return the intersection of the requested
+ * range with the buffer and report the buffer's actual `available` window. A request whose `collectionId`
+ * does not match `expectedCollectionId` is rejected (a backfill is collection-scoped). When the buffer is
+ * empty, `available` collapses to the request's `fromRevision` (an empty window) and no entries are returned.
+ */
+export declare function serveBackfill(buffer: ReplayBuffer, req: BackfillV1, expectedCollectionId: string): BackfillReplyV1;
+/** Sends a signed {@link BackfillV1} to the serving cohort and awaits its {@link BackfillReplyV1}. */
+export type BackfillTransport = (req: BackfillV1) => Promise<BackfillReplyV1>;
+/** Construction inputs for {@link createBackfillRequester}. */
+export interface BackfillRequesterDeps {
+    /** Collection this subscription tracks, base64url. */
+    readonly collectionId: string;
+    /** Sign the request over its unsigned image (the subscriber's peer key); returns the base64url sig. */
+    readonly sign: (req: Omit<BackfillV1, "signature">) => string;
+    /** Send the request and await the reply (the db-p2p reactivity application protocol supplies this). */
+    readonly transport: BackfillTransport;
+    /** Re-enter each backfilled entry through the delivery path (verify → contiguity → deliver → dedupe). */
+    readonly subscriber: ReactivitySubscriber;
+    /** Unix-ms clock stamped into the signed `timestamp` (injected — db-core proper never reads an ambient clock). */
+    readonly clock: () => number;
+    /**
+     * Called when the cohort's `available` window does not reach the gap's low edge (`available.fromRevision
+     * > from`): the buffer no longer covers the gap, so the subscriber must escalate to a checkpoint resume
+     * or a chain read (`docs/reactivity.md` §Backfill RPC, "fall back further").
+     */
+    readonly onUnderflow?: (requested: {
+        from: number;
+        to: number;
+    }, available: {
+        fromRevision: number;
+        toRevision: number;
+    }) => void;
+}
+/**
+ * Build the `requestBackfill(from, to)` driver that connects the subscriber delivery path's backfill seam
+ * ([reactivity-origination-replay-delivery]) to the {@link BackfillV1} RPC. It signs and sends the request,
+ * replays the returned entries through {@link ReactivitySubscriber.onNotification} (so they close the gap,
+ * verified and deduped), and reports an underflow when the cohort's `available` window fell past the gap's
+ * low edge so the caller can fall back to a checkpoint resume or a chain read.
+ *
+ * Returns a `Promise`; the synchronous `(from, to) => void` seam wraps a call to this with `void`.
+ */
+export declare function createBackfillRequester(deps: BackfillRequesterDeps): (from: number, to: number) => Promise<BackfillReplyV1>;
+//# sourceMappingURL=backfill.d.ts.map

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

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

package/dist/src/reactivity/backfill.js

@@ -0,0 +1,137 @@
+/**
+ * Reactivity — Backfill RPC (`docs/reactivity.md` §Backfill RPC, §Wire formats).
+ *
+ * A subscriber that detects a revision gap (slow-subscriber drop, brief sleep) requests the missing
+ * range from its serving cohort; the cohort answers from its {@link ReplayBuffer} ring. The reply
+ * carries the **intersection** of the requested range with the buffer plus the `available` window the
+ * cohort actually holds, so a subscriber whose lag fell past the ring's low edge learns it must fall
+ * back further (to a checkpoint resume or a chain read) rather than silently receiving a short answer.
+ *
+ * Entries retain the original threshold signature (the buffer stores full {@link NotificationV1}s), so a
+ * backfill reply is verifiable **end-to-end** — the subscriber re-runs the same {@link NotificationVerifier}
+ * over each backfilled entry it runs over a live notification. Any cohort member can serve, because the
+ * replay buffer is gossiped across the cohort (origination ticket).
+ *
+ * Wire conventions match the rest of reactivity: JSON, byte fields base64url, unix-ms timestamps, `v: 1`,
+ * per-message structural validation on decode. `BackfillV1` is signed by the subscriber's peer key
+ * (`signature`); replay protection rides the request envelope as elsewhere in the substrate.
+ */
+import { decodeCohortMessage, encodeCohortMessage, DEFAULT_MAX_MESSAGE_BYTES, } from "../cohort-topic/wire/codec.js";
+import { asObject, b64urlField, failWire, reqFiniteNumber, reqIntInRange, reqString, requireV1, } from "./wire-validate.js";
+import { validateNotificationArray, validateNotificationV1 } from "./wire.js";
+/** Narrow an already-parsed value to {@link BackfillV1}, throwing on any defect. */
+export function validateBackfillV1(value) {
+    const what = "BackfillV1";
+    const obj = asObject(value, what);
+    requireV1(obj, what);
+    const fromRevision = reqIntInRange(obj, "fromRevision", what, 0);
+    const toRevision = reqIntInRange(obj, "toRevision", what, fromRevision);
+    return {
+        v: 1,
+        collectionId: b64urlField(reqString(obj, "collectionId", what), "collectionId", what),
+        fromRevision,
+        toRevision,
+        timestamp: reqFiniteNumber(obj, "timestamp", what),
+        signature: b64urlField(reqString(obj, "signature", what), "signature", what),
+    };
+}
+const utf8 = new TextEncoder();
+/**
+ * Canonical signed byte image of a {@link BackfillV1} (every field except `signature`). Mirrors the
+ * cohort-topic `registerSigningPayload` pattern: determinism comes from encoding an explicitly-ordered,
+ * type-tagged JSON array (array order is stable; object key order is not) as UTF-8. The leading
+ * `"BackfillV1"` tag means a backfill image can never collide with the `"ResumeV1"` image even when the
+ * shared fields are identical. Signer and verifier must agree byte-for-byte — the array order is the
+ * contract (pinned by the determinism test).
+ */
+export function backfillSigningPayload(body) {
+    return utf8.encode(JSON.stringify([
+        "BackfillV1",
+        body.v,
+        body.collectionId,
+        body.fromRevision,
+        body.toRevision,
+        body.timestamp,
+    ]));
+}
+/** Narrow an already-parsed value to {@link BackfillReplyV1}, throwing on any defect. */
+export function validateBackfillReplyV1(value) {
+    const what = "BackfillReplyV1";
+    const obj = asObject(value, what);
+    requireV1(obj, what);
+    const available = asObject(obj["available"], `${what}.available`);
+    const availFrom = reqIntInRange(available, "fromRevision", `${what}.available`, 0);
+    return {
+        v: 1,
+        entries: validateNotificationArray(obj["entries"], what),
+        available: {
+            fromRevision: availFrom,
+            toRevision: reqIntInRange(available, "toRevision", `${what}.available`, availFrom),
+        },
+    };
+}
+/** Encode a {@link BackfillV1} as a length-prefixed UTF-8 JSON frame. */
+export function encodeBackfillV1(msg, maxMessageBytes = DEFAULT_MAX_MESSAGE_BYTES) {
+    return encodeCohortMessage(validateBackfillV1(msg), maxMessageBytes);
+}
+/** Decode a length-prefixed {@link BackfillV1} frame. */
+export function decodeBackfillV1(bytes, maxMessageBytes) {
+    return validateBackfillV1(decodeCohortMessage(bytes, maxMessageBytes));
+}
+/** Encode a {@link BackfillReplyV1} as a length-prefixed UTF-8 JSON frame. */
+export function encodeBackfillReplyV1(msg, maxMessageBytes = DEFAULT_MAX_MESSAGE_BYTES) {
+    return encodeCohortMessage(validateBackfillReplyV1(msg), maxMessageBytes);
+}
+/** Decode a length-prefixed {@link BackfillReplyV1} frame. */
+export function decodeBackfillReplyV1(bytes, maxMessageBytes) {
+    return validateBackfillReplyV1(decodeCohortMessage(bytes, maxMessageBytes));
+}
+/**
+ * Serve a {@link BackfillV1} from a cohort's replay buffer: return the intersection of the requested
+ * range with the buffer and report the buffer's actual `available` window. A request whose `collectionId`
+ * does not match `expectedCollectionId` is rejected (a backfill is collection-scoped). When the buffer is
+ * empty, `available` collapses to the request's `fromRevision` (an empty window) and no entries are returned.
+ */
+export function serveBackfill(buffer, req, expectedCollectionId) {
+    if (req.collectionId !== expectedCollectionId) {
+        failWire(`serveBackfill: request collectionId does not match this cohort's collection`);
+    }
+    const entries = buffer.range(req.fromRevision, req.toRevision).map((e) => validateNotificationV1(e.payload));
+    const low = buffer.lowRevision;
+    const high = buffer.highRevision;
+    const available = low === undefined || high === undefined
+        ? { fromRevision: req.fromRevision, toRevision: req.fromRevision }
+        : { fromRevision: low, toRevision: high };
+    return { v: 1, entries, available };
+}
+/**
+ * Build the `requestBackfill(from, to)` driver that connects the subscriber delivery path's backfill seam
+ * ([reactivity-origination-replay-delivery]) to the {@link BackfillV1} RPC. It signs and sends the request,
+ * replays the returned entries through {@link ReactivitySubscriber.onNotification} (so they close the gap,
+ * verified and deduped), and reports an underflow when the cohort's `available` window fell past the gap's
+ * low edge so the caller can fall back to a checkpoint resume or a chain read.
+ *
+ * Returns a `Promise`; the synchronous `(from, to) => void` seam wraps a call to this with `void`.
+ */
+export function createBackfillRequester(deps) {
+    return async (from, to) => {
+        const unsigned = { v: 1, collectionId: deps.collectionId, fromRevision: from, toRevision: to, timestamp: deps.clock() };
+        const req = { ...unsigned, signature: deps.sign(unsigned) };
+        const reply = await deps.transport(req);
+        // Underflow: the cohort's held window does not reach the gap's low edge (`docs/reactivity.md`
+        // §Backfill RPC, "fall back further"). The returned entries all sit *above* the still-unfillable
+        // low range, so none can apply contiguously from `from`. Replaying them would only re-fire the
+        // subscriber's gap → `requestBackfill` seam (which, when wired back to this driver, recurses
+        // without bound). Escalate to a checkpoint resume / chain read instead and leave the replay to the
+        // recovery path that can actually close the low range.
+        if (reply.available.fromRevision > from) {
+            deps.onUnderflow?.({ from, to }, reply.available);
+            return reply;
+        }
+        for (const entry of reply.entries) {
+            await deps.subscriber.onNotification(entry);
+        }
+        return reply;
+    };
+}
+//# sourceMappingURL=backfill.js.map

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

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

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

@@ -0,0 +1,99 @@
+/**
+ * Reactivity — slow-subscriber backpressure (`docs/reactivity.md` §Slow-subscriber backpressure).
+ *
+ * A forwarder's primary maintains a **per-subscriber** bounded queue with **drop-oldest** semantics. When
+ * a subscriber's queue is full and a new notification arrives, the *oldest* queued entry is dropped and a
+ * monotone `dropped` counter increments. The subscriber detects the resulting revision jump on its next
+ * delivery and issues a `BackfillV1` against the replay buffer (the backfill RPC is owned by
+ * [reactivity-backfill-resume-checkpoints]; this module only produces the gap).
+ *
+ * The point is **isolation**: each subscriber has its own queue, so one phone on a flaky link fills and
+ * drops *its own* queue without stalling fan-out to the rest of the cohort's attached subscribers. Memory
+ * is bounded by `cohort_subscribers × queue_max × notification_size` — the per-subscriber queue depth is
+ * the small `queue_max` (default 32), never the unbounded backlog of the slowest receiver.
+ *
+ * This is the primary-local fan-out buffer, **not** cohort soft state: it is never gossiped (only the
+ * primary drives delivery), so it is absent from {@link import("./push-state.js").PushStateGossipV1}. A
+ * `cohortEpoch` handoff rebuilds it empty at the new primary — a few dropped notifications at handoff are
+ * exactly what the replay buffer + backfill path recover.
+ */
+import type { NotificationV1 } from "./wire.js";
+/** The result of enqueuing one notification onto a subscriber's bounded queue. */
+export interface EnqueueResult {
+    /** `true` iff the queue was full and its oldest entry was evicted to make room (drop-oldest). */
+    readonly droppedOldest: boolean;
+    /** The evicted notification, when `droppedOldest`; the subscriber will detect the gap and backfill. */
+    readonly evicted?: NotificationV1;
+    /** Queue depth after the enqueue (`<= capacity`). */
+    readonly depth: number;
+}
+/**
+ * A bounded, drop-oldest per-subscriber delivery queue (`docs/reactivity.md` §Slow-subscriber
+ * backpressure). Holds at most `capacity` (= `queue_max`) pending notifications; a full queue evicts its
+ * oldest on the next enqueue and increments {@link dropped}.
+ */
+export declare class BoundedQueue {
+    readonly capacity: number;
+    private readonly entries;
+    private droppedCount;
+    constructor(capacity?: number);
+    /** Pending depth (`0..capacity`). */
+    get size(): number;
+    /** Monotone count of notifications dropped to drop-oldest pressure over this queue's lifetime. */
+    get dropped(): number;
+    /** True iff a further enqueue would evict the oldest entry. */
+    get full(): boolean;
+    /**
+     * Enqueue `n` for delivery. On overflow the **oldest** entry is dropped (not the incoming one — a slow
+     * subscriber wants the freshest revisions, and the dropped span is recovered via backfill) and
+     * {@link dropped} increments. Returns whether an eviction occurred and the resulting depth.
+     */
+    enqueue(n: NotificationV1): EnqueueResult;
+    /** The oldest pending notification, or `undefined` when empty (does not dequeue). */
+    peek(): NotificationV1 | undefined;
+    /** Remove and return the oldest pending notification (FIFO delivery), or `undefined` when empty. */
+    dequeue(): NotificationV1 | undefined;
+    /** Drain and return all pending notifications in FIFO order, leaving the queue empty. */
+    drain(): NotificationV1[];
+    /** A read-only snapshot of the pending notifications, oldest first (does not mutate). */
+    pending(): readonly NotificationV1[];
+}
+/** The per-subscriber drop record surfaced by {@link SubscriberBackpressure.enqueue}. */
+export interface SubscriberEnqueueResult extends EnqueueResult {
+    /** The subscriber this enqueue targeted, base64url peer id. */
+    readonly subscriberId: string;
+}
+/**
+ * The forwarder primary's per-subscriber backpressure map (the `PushState.perSubscriberQueue` field). One
+ * {@link BoundedQueue} per attached subscriber, created lazily on first delivery. `enqueue` routes a
+ * notification to exactly one subscriber's queue, so a slow subscriber's drops never touch another
+ * subscriber's queue — the isolation the §Slow-subscriber backpressure section requires.
+ */
+export declare class SubscriberBackpressure {
+    readonly capacity: number;
+    private readonly queues;
+    constructor(capacity?: number);
+    /** Number of subscribers with a live queue. */
+    get subscriberCount(): number;
+    /** The live queue for `subscriberId`, creating an empty one on first use. */
+    queue(subscriberId: string): BoundedQueue;
+    /** The live queue for `subscriberId`, or `undefined` if none exists yet (no lazy creation). */
+    peekQueue(subscriberId: string): BoundedQueue | undefined;
+    /** Enqueue `n` for one subscriber. A drop on that subscriber's queue isolates it from the others. */
+    enqueue(subscriberId: string, n: NotificationV1): SubscriberEnqueueResult;
+    /**
+     * Fan one notification out to every named subscriber, returning only the subscribers whose queue
+     * dropped its oldest under pressure. A slow subscriber that drops is the *only* one affected — fast
+     * subscribers' queues accept the same notification contiguously (the isolation property).
+     */
+    fanOut(subscriberIds: Iterable<string>, n: NotificationV1): SubscriberEnqueueResult[];
+    /** Drop a departed subscriber's queue (TTL eviction / withdrawal), reclaiming its memory. */
+    remove(subscriberId: string): void;
+    /** The total notifications dropped across all subscribers (diagnostics). */
+    totalDropped(): number;
+    /** The subscriber ids currently holding a queue (for iteration / diagnostics). */
+    subscribers(): IterableIterator<string>;
+}
+/** Build a {@link SubscriberBackpressure} map with the configured per-subscriber depth (default `queue_max`). */
+export declare function createSubscriberBackpressure(capacity?: number): SubscriberBackpressure;
+//# sourceMappingURL=backpressure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backpressure.d.ts","sourceRoot":"","sources":["../../../src/reactivity/backpressure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC7B,iGAAiG;IACjG,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,uGAAuG;IACvG,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,qBAAa,YAAY;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,YAAY,CAAK;gBAEb,QAAQ,GAAE,MAA0B;IAOhD,qCAAqC;IACrC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,kGAAkG;IAClG,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,+DAA+D;IAC/D,IAAI,IAAI,IAAI,OAAO,CAElB;IAED;;;;OAIG;IACH,OAAO,CAAC,CAAC,EAAE,cAAc,GAAG,aAAa;IAYzC,qFAAqF;IACrF,IAAI,IAAI,cAAc,GAAG,SAAS;IAIlC,oGAAoG;IACpG,OAAO,IAAI,cAAc,GAAG,SAAS;IAIrC,yFAAyF;IACzF,KAAK,IAAI,cAAc,EAAE;IAIzB,yFAAyF;IACzF,OAAO,IAAI,SAAS,cAAc,EAAE;CAGpC;AAED,yFAAyF;AACzF,MAAM,WAAW,uBAAwB,SAAQ,aAAa;IAC7D,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,qBAAa,sBAAsB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;gBAE9C,QAAQ,GAAE,MAA0B;IAOhD,+CAA+C;IAC/C,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,6EAA6E;IAC7E,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY;IASzC,+FAA+F;IAC/F,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIzD,qGAAqG;IACrG,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,EAAE,cAAc,GAAG,uBAAuB;IAIzE;;;;OAIG;IACH,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,cAAc,GAAG,uBAAuB,EAAE;IAWrF,6FAA6F;IAC7F,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAIlC,4EAA4E;IAC5E,YAAY,IAAI,MAAM;IAQtB,kFAAkF;IAClF,WAAW,IAAI,gBAAgB,CAAC,MAAM,CAAC;CAGvC;AAED,iHAAiH;AACjH,wBAAgB,4BAA4B,CAAC,QAAQ,GAAE,MAA0B,GAAG,sBAAsB,CAEzG"}

package/dist/src/reactivity/backpressure.js

@@ -0,0 +1,153 @@
+/**
+ * Reactivity — slow-subscriber backpressure (`docs/reactivity.md` §Slow-subscriber backpressure).
+ *
+ * A forwarder's primary maintains a **per-subscriber** bounded queue with **drop-oldest** semantics. When
+ * a subscriber's queue is full and a new notification arrives, the *oldest* queued entry is dropped and a
+ * monotone `dropped` counter increments. The subscriber detects the resulting revision jump on its next
+ * delivery and issues a `BackfillV1` against the replay buffer (the backfill RPC is owned by
+ * [reactivity-backfill-resume-checkpoints]; this module only produces the gap).
+ *
+ * The point is **isolation**: each subscriber has its own queue, so one phone on a flaky link fills and
+ * drops *its own* queue without stalling fan-out to the rest of the cohort's attached subscribers. Memory
+ * is bounded by `cohort_subscribers × queue_max × notification_size` — the per-subscriber queue depth is
+ * the small `queue_max` (default 32), never the unbounded backlog of the slowest receiver.
+ *
+ * This is the primary-local fan-out buffer, **not** cohort soft state: it is never gossiped (only the
+ * primary drives delivery), so it is absent from {@link import("./push-state.js").PushStateGossipV1}. A
+ * `cohortEpoch` handoff rebuilds it empty at the new primary — a few dropped notifications at handoff are
+ * exactly what the replay buffer + backfill path recover.
+ */
+import { QUEUE_MAX_DEFAULT } from "./config.js";
+/**
+ * A bounded, drop-oldest per-subscriber delivery queue (`docs/reactivity.md` §Slow-subscriber
+ * backpressure). Holds at most `capacity` (= `queue_max`) pending notifications; a full queue evicts its
+ * oldest on the next enqueue and increments {@link dropped}.
+ */
+export class BoundedQueue {
+    capacity;
+    entries = [];
+    droppedCount = 0;
+    constructor(capacity = QUEUE_MAX_DEFAULT) {
+        if (!Number.isInteger(capacity) || capacity < 1) {
+            throw new RangeError(`reactivity bounded queue: capacity must be an integer >= 1, got ${capacity}`);
+        }
+        this.capacity = capacity;
+    }
+    /** Pending depth (`0..capacity`). */
+    get size() {
+        return this.entries.length;
+    }
+    /** Monotone count of notifications dropped to drop-oldest pressure over this queue's lifetime. */
+    get dropped() {
+        return this.droppedCount;
+    }
+    /** True iff a further enqueue would evict the oldest entry. */
+    get full() {
+        return this.entries.length >= this.capacity;
+    }
+    /**
+     * Enqueue `n` for delivery. On overflow the **oldest** entry is dropped (not the incoming one — a slow
+     * subscriber wants the freshest revisions, and the dropped span is recovered via backfill) and
+     * {@link dropped} increments. Returns whether an eviction occurred and the resulting depth.
+     */
+    enqueue(n) {
+        let evicted;
+        if (this.entries.length >= this.capacity) {
+            evicted = this.entries.shift();
+            this.droppedCount += 1;
+        }
+        this.entries.push(n);
+        return evicted !== undefined
+            ? { droppedOldest: true, evicted, depth: this.entries.length }
+            : { droppedOldest: false, depth: this.entries.length };
+    }
+    /** The oldest pending notification, or `undefined` when empty (does not dequeue). */
+    peek() {
+        return this.entries[0];
+    }
+    /** Remove and return the oldest pending notification (FIFO delivery), or `undefined` when empty. */
+    dequeue() {
+        return this.entries.shift();
+    }
+    /** Drain and return all pending notifications in FIFO order, leaving the queue empty. */
+    drain() {
+        return this.entries.splice(0, this.entries.length);
+    }
+    /** A read-only snapshot of the pending notifications, oldest first (does not mutate). */
+    pending() {
+        return [...this.entries];
+    }
+}
+/**
+ * The forwarder primary's per-subscriber backpressure map (the `PushState.perSubscriberQueue` field). One
+ * {@link BoundedQueue} per attached subscriber, created lazily on first delivery. `enqueue` routes a
+ * notification to exactly one subscriber's queue, so a slow subscriber's drops never touch another
+ * subscriber's queue — the isolation the §Slow-subscriber backpressure section requires.
+ */
+export class SubscriberBackpressure {
+    capacity;
+    queues = new Map();
+    constructor(capacity = QUEUE_MAX_DEFAULT) {
+        if (!Number.isInteger(capacity) || capacity < 1) {
+            throw new RangeError(`reactivity backpressure: capacity must be an integer >= 1, got ${capacity}`);
+        }
+        this.capacity = capacity;
+    }
+    /** Number of subscribers with a live queue. */
+    get subscriberCount() {
+        return this.queues.size;
+    }
+    /** The live queue for `subscriberId`, creating an empty one on first use. */
+    queue(subscriberId) {
+        let q = this.queues.get(subscriberId);
+        if (q === undefined) {
+            q = new BoundedQueue(this.capacity);
+            this.queues.set(subscriberId, q);
+        }
+        return q;
+    }
+    /** The live queue for `subscriberId`, or `undefined` if none exists yet (no lazy creation). */
+    peekQueue(subscriberId) {
+        return this.queues.get(subscriberId);
+    }
+    /** Enqueue `n` for one subscriber. A drop on that subscriber's queue isolates it from the others. */
+    enqueue(subscriberId, n) {
+        return { subscriberId, ...this.queue(subscriberId).enqueue(n) };
+    }
+    /**
+     * Fan one notification out to every named subscriber, returning only the subscribers whose queue
+     * dropped its oldest under pressure. A slow subscriber that drops is the *only* one affected — fast
+     * subscribers' queues accept the same notification contiguously (the isolation property).
+     */
+    fanOut(subscriberIds, n) {
+        const drops = [];
+        for (const id of subscriberIds) {
+            const result = this.enqueue(id, n);
+            if (result.droppedOldest) {
+                drops.push(result);
+            }
+        }
+        return drops;
+    }
+    /** Drop a departed subscriber's queue (TTL eviction / withdrawal), reclaiming its memory. */
+    remove(subscriberId) {
+        this.queues.delete(subscriberId);
+    }
+    /** The total notifications dropped across all subscribers (diagnostics). */
+    totalDropped() {
+        let total = 0;
+        for (const q of this.queues.values()) {
+            total += q.dropped;
+        }
+        return total;
+    }
+    /** The subscriber ids currently holding a queue (for iteration / diagnostics). */
+    subscribers() {
+        return this.queues.keys();
+    }
+}
+/** Build a {@link SubscriberBackpressure} map with the configured per-subscriber depth (default `queue_max`). */
+export function createSubscriberBackpressure(capacity = QUEUE_MAX_DEFAULT) {
+    return new SubscriberBackpressure(capacity);
+}
+//# sourceMappingURL=backpressure.js.map

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

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