footprintjs 9.4.0 → 9.5.0

package/dist/lib/observer-queue/ring.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * observer-queue/ring.ts — RFC-001 Block 2: bounded ring with overflow policies.
+ *
+ * Pattern:  Fixed-capacity circular buffer with explicit, COUNTED overflow
+ *           behavior. The deferred-observer queue must never grow without
+ *           bound (a slow consumer cannot OOM the producer), and must never
+ *           lose an event silently (every loss increments `drops`).
+ * Role:     Storage primitive under the merged queue (Block 3). Pure data
+ *           structure — zero imports, zero engine knowledge, generic over T.
+ *
+ * Overflow policies (RFC-001 §5, with the accepted 'block' resolution):
+ *   - `'drop-oldest'` — evict the oldest queued item to admit the new one.
+ *     The evicted item is LOST (`drops`++) and returned on the push result
+ *     so the caller can account for it. Sequence stamps on surviving items
+ *     keep loss visible as seq gaps (honest loss accounting). DEFAULT
+ *     posture for telemetry-grade delivery.
+ *   - `'sample'` — while saturated, admit 1 in `sampleEvery` arrivals
+ *     (evicting the oldest to make room — that eviction is also a counted
+ *     loss); refuse the rest (each a counted loss). Keeps a thinned,
+ *     still-fresh stream under sustained overload. The saturation counter
+ *     is episode-scoped: it resets whenever a push succeeds through the
+ *     non-full path.
+ *   - `'block'` — the ring REFUSES the new item (`accepted: false`,
+ *     `rejections`++) and drops NOTHING. In a single-threaded runtime a
+ *     queue cannot literally block its producer; the dispatcher (Block 5)
+ *     interprets a refusal as "deliver this event synchronously inline" —
+ *     re-introducing blocking delivery by the consumer's EXPLICIT choice.
+ *     Rejections are NOT losses: the event is still delivered (inline), so
+ *     `drops` stays untouched.
+ *
+ * Conservation invariant (property-tested):
+ *   pushes === delivered + drops + rejections + size
+ *
+ * CURSOR-READY (amendment A2): v1 consumes destructively through ONE cursor
+ * (`shift()` advances `head`). The designed v1.1 path keeps items in the
+ * ring and gives each listener its own read cursor; `head` then advances to
+ * `min(cursors)` (the reclaim watermark) instead of on read. The storage
+ * layout (contiguous circular window, `head` + `count`) already supports
+ * that — only the consumption surface changes. Documented, not implemented.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedRing = void 0;
+const DEFAULT_SAMPLE_EVERY = 10;
+class BoundedRing {
+    buffer;
+    policy;
+    sampleEvery;
+    /** Index of the oldest queued item — the single v1 cursor (see header). */
+    head = 0;
+    count = 0;
+    /** Arrivals seen while saturated in the current episode (`'sample'`). */
+    saturatedArrivals = 0;
+    pushes = 0;
+    delivered = 0;
+    drops = 0;
+    rejections = 0;
+    constructor(opts) {
+        if (!Number.isInteger(opts.capacity) || opts.capacity <= 0) {
+            throw new RangeError(`BoundedRing capacity must be a positive integer (got ${opts.capacity})`);
+        }
+        const sampleEvery = opts.sampleEvery ?? DEFAULT_SAMPLE_EVERY;
+        if (!Number.isInteger(sampleEvery) || sampleEvery <= 0) {
+            throw new RangeError(`BoundedRing sampleEvery must be a positive integer (got ${opts.sampleEvery})`);
+        }
+        this.buffer = new Array(opts.capacity);
+        this.policy = opts.policy;
+        this.sampleEvery = sampleEvery;
+    }
+    get size() {
+        return this.count;
+    }
+    get capacity() {
+        return this.buffer.length;
+    }
+    /** Lifetime counters — see {@link RingCounters}. */
+    getCounters() {
+        return { pushes: this.pushes, delivered: this.delivered, drops: this.drops, rejections: this.rejections };
+    }
+    /** Admit, evict-and-admit, refuse, or sample per policy — never throws. */
+    push(item) {
+        this.pushes += 1;
+        if (this.count < this.buffer.length) {
+            this.saturatedArrivals = 0; // new saturation episode starts fresh
+            this.store(item);
+            return { accepted: true };
+        }
+        if (this.policy === 'block') {
+            this.rejections += 1;
+            return { accepted: false };
+        }
+        if (this.policy === 'sample') {
+            this.saturatedArrivals += 1;
+            if (this.saturatedArrivals % this.sampleEvery !== 0) {
+                this.drops += 1; // the incoming item is sampled out — lost
+                return { accepted: false };
+            }
+            // The 1-in-N admission falls through to evict-and-store.
+        }
+        // 'drop-oldest' (and the 'sample' admission): evict the oldest — lost.
+        const evicted = this.buffer[this.head];
+        this.buffer[this.head] = undefined;
+        this.head = (this.head + 1) % this.buffer.length;
+        this.count -= 1;
+        this.drops += 1;
+        this.store(item);
+        return { accepted: true, evicted };
+    }
+    /** Pop the oldest queued item (FIFO). `undefined` when empty. */
+    shift() {
+        if (this.count === 0)
+            return undefined;
+        const item = this.buffer[this.head];
+        this.buffer[this.head] = undefined; // release the reference for GC
+        this.head = (this.head + 1) % this.buffer.length;
+        this.count -= 1;
+        this.delivered += 1;
+        return item;
+    }
+    store(item) {
+        this.buffer[(this.head + this.count) % this.buffer.length] = item;
+        this.count += 1;
+    }
+}
+exports.BoundedRing = BoundedRing;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ring.js","sourceRoot":"","sources":["../../../src/lib/observer-queue/ring.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * observer-queue/ring.ts — RFC-001 Block 2: bounded ring with overflow policies.\n *\n * Pattern:  Fixed-capacity circular buffer with explicit, COUNTED overflow\n *           behavior. The deferred-observer queue must never grow without\n *           bound (a slow consumer cannot OOM the producer), and must never\n *           lose an event silently (every loss increments `drops`).\n * Role:     Storage primitive under the merged queue (Block 3). Pure data\n *           structure — zero imports, zero engine knowledge, generic over T.\n *\n * Overflow policies (RFC-001 §5, with the accepted 'block' resolution):\n *   - `'drop-oldest'` — evict the oldest queued item to admit the new one.\n *     The evicted item is LOST (`drops`++) and returned on the push result\n *     so the caller can account for it. Sequence stamps on surviving items\n *     keep loss visible as seq gaps (honest loss accounting). DEFAULT\n *     posture for telemetry-grade delivery.\n *   - `'sample'` — while saturated, admit 1 in `sampleEvery` arrivals\n *     (evicting the oldest to make room — that eviction is also a counted\n *     loss); refuse the rest (each a counted loss). Keeps a thinned,\n *     still-fresh stream under sustained overload. The saturation counter\n *     is episode-scoped: it resets whenever a push succeeds through the\n *     non-full path.\n *   - `'block'` — the ring REFUSES the new item (`accepted: false`,\n *     `rejections`++) and drops NOTHING. In a single-threaded runtime a\n *     queue cannot literally block its producer; the dispatcher (Block 5)\n *     interprets a refusal as \"deliver this event synchronously inline\" —\n *     re-introducing blocking delivery by the consumer's EXPLICIT choice.\n *     Rejections are NOT losses: the event is still delivered (inline), so\n *     `drops` stays untouched.\n *\n * Conservation invariant (property-tested):\n *   pushes === delivered + drops + rejections + size\n *\n * CURSOR-READY (amendment A2): v1 consumes destructively through ONE cursor\n * (`shift()` advances `head`). The designed v1.1 path keeps items in the\n * ring and gives each listener its own read cursor; `head` then advances to\n * `min(cursors)` (the reclaim watermark) instead of on read. The storage\n * layout (contiguous circular window, `head` + `count`) already supports\n * that — only the consumption surface changes. Documented, not implemented.\n */\n\n/** How the ring treats a push when it is at capacity (RFC-001 §5). */\nexport type OverflowPolicy = 'block' | 'drop-oldest' | 'sample';\n\nexport interface RingOptions {\n  /** Max queued items. Positive integer. */\n  readonly capacity: number;\n  /** Overflow behavior at capacity — see the module header. */\n  readonly policy: OverflowPolicy;\n  /**\n   * `'sample'` only: admit 1 in this many arrivals while saturated.\n   * Positive integer; default 10.\n   */\n  readonly sampleEvery?: number;\n}\n\n/** Outcome of one {@link BoundedRing.push}. */\nexport interface RingPushResult<T> {\n  /** True when the pushed item is now queued. */\n  readonly accepted: boolean;\n  /**\n   * The oldest item, when admitting the new one evicted it\n   * (`'drop-oldest'`, or a `'sample'` admission). Already counted in\n   * `drops` — surfaced so callers can do their own loss accounting.\n   */\n  readonly evicted?: T;\n}\n\n/** Monotonic counters — never reset for the lifetime of the ring. */\nexport interface RingCounters {\n  /** Total `push()` calls. */\n  readonly pushes: number;\n  /** `shift()` calls that returned an item. */\n  readonly delivered: number;\n  /** Items LOST — evictions plus sampled-out refusals. Never silent. */\n  readonly drops: number;\n  /** `'block'` refusals — NOT losses; the caller delivers these inline. */\n  readonly rejections: number;\n}\n\nconst DEFAULT_SAMPLE_EVERY = 10;\n\nexport class BoundedRing<T> {\n  private readonly buffer: Array<T | undefined>;\n  private readonly policy: OverflowPolicy;\n  private readonly sampleEvery: number;\n  /** Index of the oldest queued item — the single v1 cursor (see header). */\n  private head = 0;\n  private count = 0;\n  /** Arrivals seen while saturated in the current episode (`'sample'`). */\n  private saturatedArrivals = 0;\n\n  private pushes = 0;\n  private delivered = 0;\n  private drops = 0;\n  private rejections = 0;\n\n  constructor(opts: RingOptions) {\n    if (!Number.isInteger(opts.capacity) || opts.capacity <= 0) {\n      throw new RangeError(`BoundedRing capacity must be a positive integer (got ${opts.capacity})`);\n    }\n    const sampleEvery = opts.sampleEvery ?? DEFAULT_SAMPLE_EVERY;\n    if (!Number.isInteger(sampleEvery) || sampleEvery <= 0) {\n      throw new RangeError(`BoundedRing sampleEvery must be a positive integer (got ${opts.sampleEvery})`);\n    }\n    this.buffer = new Array<T | undefined>(opts.capacity);\n    this.policy = opts.policy;\n    this.sampleEvery = sampleEvery;\n  }\n\n  get size(): number {\n    return this.count;\n  }\n\n  get capacity(): number {\n    return this.buffer.length;\n  }\n\n  /** Lifetime counters — see {@link RingCounters}. */\n  getCounters(): RingCounters {\n    return { pushes: this.pushes, delivered: this.delivered, drops: this.drops, rejections: this.rejections };\n  }\n\n  /** Admit, evict-and-admit, refuse, or sample per policy — never throws. */\n  push(item: T): RingPushResult<T> {\n    this.pushes += 1;\n\n    if (this.count < this.buffer.length) {\n      this.saturatedArrivals = 0; // new saturation episode starts fresh\n      this.store(item);\n      return { accepted: true };\n    }\n\n    if (this.policy === 'block') {\n      this.rejections += 1;\n      return { accepted: false };\n    }\n\n    if (this.policy === 'sample') {\n      this.saturatedArrivals += 1;\n      if (this.saturatedArrivals % this.sampleEvery !== 0) {\n        this.drops += 1; // the incoming item is sampled out — lost\n        return { accepted: false };\n      }\n      // The 1-in-N admission falls through to evict-and-store.\n    }\n\n    // 'drop-oldest' (and the 'sample' admission): evict the oldest — lost.\n    const evicted = this.buffer[this.head] as T;\n    this.buffer[this.head] = undefined;\n    this.head = (this.head + 1) % this.buffer.length;\n    this.count -= 1;\n    this.drops += 1;\n    this.store(item);\n    return { accepted: true, evicted };\n  }\n\n  /** Pop the oldest queued item (FIFO). `undefined` when empty. */\n  shift(): T | undefined {\n    if (this.count === 0) return undefined;\n    const item = this.buffer[this.head] as T;\n    this.buffer[this.head] = undefined; // release the reference for GC\n    this.head = (this.head + 1) % this.buffer.length;\n    this.count -= 1;\n    this.delivered += 1;\n    return item;\n  }\n\n  private store(item: T): void {\n    this.buffer[(this.head + this.count) % this.buffer.length] = item;\n    this.count += 1;\n  }\n}\n"]}

package/dist/types/lib/capture/envelope.d.ts

@@ -0,0 +1,169 @@
+/**
+ * capture/envelope.ts — RFC-001 Block 1: capture envelopes + payload summarizer.
+ *
+ * Pattern:  Point-in-time capture. An observer event is snapshotted into a
+ *           self-contained, immutable envelope at the moment it happens, so
+ *           DELIVERY can be deferred (RFC-001 "one beat behind") without the
+ *           payload drifting under later engine mutations.
+ * Role:     The capture tier of the deferred-observer pipeline
+ *           (`src/lib/observer-queue/`). Pure module — ZERO engine imports
+ *           (only `capture/` internals); the engine wiring is RFC-001
+ *           Blocks 6–10.
+ *
+ * Capture policies (RFC-001 §5):
+ *   - `'summary'` — bounded, reference-free summarization via
+ *     {@link summarizePayload}. Built on the SAME classification path as the
+ *     retention markers in `summarize.ts` (#14 / #13c-A), extended with
+ *     bounded structural descent. Structured-clone-safe by construction.
+ *   - `'clone'`   — `structuredClone` at capture time (the capture-tier
+ *     spelling of retention `'full'` — see the mapping notes in
+ *     `policies.ts`). If the payload is not clonable (functions, symbols,
+ *     live handles), capture DEGRADES to `'summary'` and reports through the
+ *     `warn` hook — a capture must never throw into the producer.
+ *   - `'ref'`     — pass-through of the live reference. The CALLER asserts
+ *     immutability for the delivery window (safe e.g. for committed-state
+ *     reads, proven immutable-after-swap in #13/#13b). Exempt from the
+ *     clone-safety guarantee — see the dev-warn seam below.
+ *
+ * Dev-warn seam (resolves the isDevMode-would-be-an-engine-import problem):
+ *   This module must not import `scope/detectCircular` (engine territory).
+ *   Instead, `capture()` accepts {@link CaptureHooks} with an optional
+ *   `warn` callback and invokes it on every `'ref'` capture and every
+ *   `'clone'` degradation. The WIRING layer (Block 6) binds `warn` to an
+ *   `isDevMode()`-gated, deduplicated console warner; the pure module stays
+ *   engine-free and silent by default (no hooks ⇒ no warning, zero cost).
+ *
+ * Summarizer bounds (documented contract, exported as constants):
+ *   - depth   ≤ {@link PAYLOAD_SUMMARY_MAX_DEPTH}   (3) — deeper structure
+ *     collapses to a classified leaf with `depthClipped: true`.
+ *   - breadth ≤ {@link PAYLOAD_SUMMARY_MAX_ENTRIES} (16) per object/array —
+ *     the remainder is dropped and flagged `truncated: true` (the honest
+ *     `size` still reports the real count).
+ *   - total   ≤ {@link PAYLOAD_SUMMARY_MAX_NODES}   (128) summary nodes per
+ *     payload — a global budget so wide×deep payloads stay O(1)-bounded.
+ *   - string previews ≤ `SUMMARY_PREVIEW_LENGTH` (80) chars.
+ *   Cycles are detected (ancestor set) and flagged `circular: true`;
+ *   throwing getters yield a `'unreadable'` leaf; symbol-keyed properties
+ *   are ignored (same as JSON / `Object.keys`); `Map`/`Set` are leaves with
+ *   their REAL entry count (no descent — matches `summarize.ts`).
+ */
+import { type SummaryValueType } from './summarize.js';
+/** Which observer channel produced a captured event (RFC-001 §5). */
+export type CaptureChannel = 'scope' | 'flow' | 'emit';
+/**
+ * How an event payload is materialized into the envelope (RFC-001 §5).
+ * See the module header for the full per-policy contract.
+ */
+export type CapturePolicy = 'summary' | 'clone' | 'ref';
+/**
+ * A captured observer event — self-contained and immutable (shallow-frozen
+ * at creation). `seq` is the arrival stamp assigned at capture under the
+ * single JS thread: it totally orders events ACROSS all three channels, is
+ * monotonic, and is gap-detectable (a dropped event leaves a visible hole
+ * in the delivered `seq` sequence — honest loss accounting).
+ */
+export interface CaptureEnvelope {
+    /** Arrival stamp — total order across channels; gaps reveal drops. */
+    readonly seq: number;
+    /** Producing observer channel. */
+    readonly channel: CaptureChannel;
+    /** Producing hook name — `'onWrite'`, `'onStageExecuted'`, `'onEmit'`, ... */
+    readonly method: string;
+    /** The execution step that produced the event (`stageId#executionIndex`). */
+    readonly runtimeStageId: string;
+    /** The run that produced the event (Convention 4 per-run scoping). */
+    readonly runId: string;
+    /**
+     * Per {@link CapturePolicy} — NEVER a live engine reference under
+     * `'summary'` / `'clone'`; under `'ref'` the caller asserted immutability.
+     */
+    readonly payload: unknown;
+    /** Capture wall-clock (ms epoch by default; injectable via hooks.now). */
+    readonly capturedAt: number;
+}
+/** The raw event description handed to {@link capture}. */
+export interface CaptureRequest {
+    /** Arrival stamp — assigned by the merged queue's counter (Block 3). */
+    readonly seq: number;
+    readonly channel: CaptureChannel;
+    readonly method: string;
+    readonly runtimeStageId: string;
+    readonly runId: string;
+    /** The LIVE payload — `capture()` materializes it per policy. */
+    readonly payload: unknown;
+}
+/**
+ * Engine-free seams injected by the wiring layer (Block 6). The pure module
+ * never imports dev-mode or clock infrastructure.
+ */
+export interface CaptureHooks {
+    /**
+     * Diagnostic sink — invoked on every `'ref'` capture (caller-asserted
+     * immutability) and every `'clone'` → `'summary'` degradation. Block 6
+     * binds this to an `isDevMode()`-gated, deduplicated warner.
+     */
+    readonly warn?: (message: string) => void;
+    /** Clock for `capturedAt` — defaults to `Date.now`. Injectable for tests. */
+    readonly now?: () => number;
+}
+/** Max nesting depth a payload summary descends before clipping. */
+export declare const PAYLOAD_SUMMARY_MAX_DEPTH = 3;
+/** Max entries summarized per object/array level before truncating. */
+export declare const PAYLOAD_SUMMARY_MAX_ENTRIES = 16;
+/** Global per-payload budget of summary nodes (wide×deep hard bound). */
+export declare const PAYLOAD_SUMMARY_MAX_NODES = 128;
+/**
+ * Leaf classification for a summary node — the `summarize.ts` family plus
+ * `'unreadable'` for properties whose getter threw during capture.
+ */
+export type PayloadSummaryType = SummaryValueType | 'unreadable';
+/**
+ * One node of a payload summary tree. Every field is a primitive, a plain
+ * object, or a plain array — structured-clone-safe by construction.
+ */
+export interface PayloadSummaryNode {
+    /** Classification — same rules as the retention markers (one code path). */
+    readonly type: PayloadSummaryType;
+    /** Honest size proxy: string length, array length, or key/entry count. */
+    readonly size?: number;
+    /** First `SUMMARY_PREVIEW_LENGTH` chars — primitives/strings only. */
+    readonly preview?: string;
+    /** Summarized own enumerable string-keyed properties (objects). */
+    readonly fields?: Readonly<Record<string, PayloadSummaryNode>>;
+    /** Summarized leading items (arrays). */
+    readonly items?: readonly PayloadSummaryNode[];
+    /** Entries were omitted here (breadth cap or node budget). */
+    readonly truncated?: boolean;
+    /** This value is an ancestor of itself — descent stopped. */
+    readonly circular?: true;
+    /** {@link PAYLOAD_SUMMARY_MAX_DEPTH} reached — children not descended. */
+    readonly depthClipped?: true;
+}
+/**
+ * Root of a payload summary — branded so consumers (and tests) can detect
+ * that a payload was summarized rather than cloned. Sibling of the
+ * `__readSummary` / `__writeSummary` retention markers.
+ */
+export interface PayloadSummary extends PayloadSummaryNode {
+    /** Discriminant — `'summary'`-policy envelope payloads carry this. */
+    readonly __payloadSummary: true;
+}
+/**
+ * Produce a bounded, reference-free, structured-clone-safe summary of an
+ * arbitrary payload. Never throws; never holds a reference into the source
+ * value (every node is a fresh object whose fields are primitives). Bounds
+ * are documented in the module header.
+ */
+export declare function summarizePayload(payload: unknown): PayloadSummary;
+/**
+ * Capture one observer event into an immutable {@link CaptureEnvelope}.
+ *
+ * Guarantees:
+ *   - Never throws into the producer (`'clone'` degradation, summarizer
+ *     never-throws contract).
+ *   - The returned envelope is shallow-frozen — `seq`/`channel`/... cannot
+ *     be reassigned. Under `'summary'`/`'clone'` the payload holds no live
+ *     reference into the source; under `'ref'` it intentionally does.
+ *   - Default policy is `'summary'` (cheapest safe tier).
+ */
+export declare function capture(request: CaptureRequest, policy?: CapturePolicy, hooks?: CaptureHooks): CaptureEnvelope;

package/dist/types/lib/engine/handlers/ContinuationResolver.d.ts

@@ -43,6 +43,18 @@ export declare class ContinuationResolver<TOut = any, TScope = any> {
      * Key: node.id, Value: visit count (0 = first visit).
      */
     private iterationCounters;
+    /**
+     * Total fn-bearing dynamic-next hops this traverser has followed.
+     *
+     * Fresh fn-bearing nodes bypass the per-node-id iteration counter (they
+     * are new nodes, often without stable ids — there is no back-edge to
+     * count). Without a bound, a stage that keeps returning a function-bearing
+     * dynamic `next` runs FOREVER on the flat trampoline (no stack overflow
+     * brakes it either). This run-total counter puts such chains under the
+     * same `maxIterations` budget (default 1000, tuned via
+     * `RunOptions.maxIterations`) that bounds loop edges.
+     */
+    private dynamicNextHops;
     private readonly onIterationUpdate?;
     private readonly maxIterations;
     constructor(deps: HandlerDeps<TOut, TScope>, nodeResolver: NodeResolver<TOut, TScope>, onIterationUpdate?: (nodeId: string, count: number) => void, maxIterations?: number);
@@ -62,8 +74,9 @@ export declare class ContinuationResolver<TOut = any, TScope = any> {
      * `onLoop` narrative), in the same order.
      *
      * Three dynamicNext patterns:
-     * - StageNode with fn → truly dynamic node, returned as-is (no iteration
-     *   tracking — it is a fresh node, not a back-edge).
+     * - StageNode with fn → truly dynamic node, returned as-is (no per-node
+     *   iteration tracking — it is a fresh node, not a back-edge — but the
+     *   run-total dynamic-hop budget applies; see `dynamicNextHops`).
      * - String ID → reference to an existing node, resolved via NodeResolver.
      * - StageNode without fn → reference by ID, resolved via NodeResolver.
      */

package/dist/types/lib/engine/types.d.ts

@@ -337,6 +337,9 @@ export interface RunOptions {
      * This is the binding constraint for loop-heavy pipelines — raise it for
      * legitimately long loops (`loopTo` chains run with a flat stack, so high
      * values are safe; memory for state/narrative still grows per iteration).
+     * Also bounds the run-total chain of function-bearing dynamic `next`
+     * continuations (fresh nodes returned from stages) — a runaway dynamic
+     * chain errors instead of running forever.
      * Propagates to subflows. Must be >= 1.
      */
     maxIterations?: number;

package/dist/types/lib/observer-queue/deferredDispatcher.d.ts

@@ -0,0 +1,169 @@
+/**
+ * observer-queue/deferredDispatcher.ts — RFC-001 Block 5: deferred delivery façade.
+ *
+ * Pattern:  capture → enqueue → (microtask) flush → invoke, with per-listener
+ *           error isolation. Composes the whole pure pipeline: MergedQueue
+ *           (Block 3, which captures via Block 1) + FlushDriver (Block 4) +
+ *           a listener registry with timing/inflight accounting.
+ * Role:     The object the engine wiring (Block 6) will hold. Producers call
+ *           `capture()` (cheap, never throws, never blocks); listeners
+ *           receive envelopes at the next checkpoint, "one beat behind".
+ *           Pure module — zero engine imports.
+ *
+ * Delivery semantics (normative, RFC-001 §5 + amendments A2/A4):
+ *   - Per-listener FIFO: every listener sees envelopes in seq order
+ *     (invocation order; an async listener's COMPLETION order is its own
+ *     concern) — EXCEPT under `'block'` overflow, where a refused enqueue
+ *     is delivered inline and overtakes the queued backlog. `seq` always
+ *     records true arrival order, so order-sensitive consumers re-sort;
+ *     see the `'block'` caveat below.
+ *   - Error isolation: a throwing listener (sync) or rejecting listener
+ *     (async) never affects siblings or the producer. Both failure modes
+ *     route to the injected `onError`; a throwing `onError` is itself
+ *     swallowed.
+ *   - The flush NEVER awaits a listener. Async continuations are tracked in
+ *     an inflight set; `drain({ timeoutMs })` settles them
+ *     (`Promise.allSettled` + deadline, shaped like `flushAllDetached`).
+ *   - `'block'` overflow: a refused enqueue is delivered synchronously
+ *     INLINE from `capture()` — re-introducing blocking delivery by the
+ *     consumer's explicit choice. Ordering caveat (documented + tested): an
+ *     inline event overtakes the queued backlog — `'block'` trades global
+ *     ordering for zero loss and bounded memory. `seq` still tells the
+ *     true arrival order.
+ *   - Listener registry is idempotent by id (same id replaces, different
+ *     ids coexist) — mirrors the repo-wide recorder ID contract. Stats
+ *     accumulate per id across replacement; `removeListener` keeps the
+ *     id's accumulated stats for post-run reports.
+ *   - Events captured BEFORE any listener attaches stay queued — a listener
+ *     attached before the next checkpoint still receives the backlog.
+ *
+ * Per-listener time accounting (amendment A2 — "name the hog"): cumulative
+ * `totalMs` and per-checkpoint `lastFlushMs` of SYNC time per listener id —
+ * the time that actually blocks the flush. An async listener's continuation
+ * time is intentionally not attributed (it does not block delivery).
+ */
+import { type CaptureEnvelope, type CaptureHooks, type CapturePolicy } from '../capture/envelope.js';
+import { type FlushSyncResult } from './flushDriver.js';
+import { type EnqueueInput } from './mergedQueue.js';
+import { type OverflowPolicy } from './ring.js';
+/**
+ * One deferred observer. May return a Promise — the dispatcher tracks it in
+ * the inflight set but NEVER awaits it during a flush.
+ */
+export type DeferredListener = (envelope: CaptureEnvelope) => void | Promise<void>;
+export interface DispatchErrorContext {
+    readonly listenerId: string;
+    readonly envelope: CaptureEnvelope;
+    /** `'sync'` = listener threw; `'async'` = returned promise rejected. */
+    readonly phase: 'sync' | 'async';
+}
+/** Injected error sink — the wiring layer routes these (Block 6). */
+export type DispatchErrorHandler = (error: unknown, context: DispatchErrorContext) => void;
+export interface DeferredDispatcherOptions {
+    /** Queue bound — default 10 000 (see `MergedQueue`). */
+    readonly maxQueue?: number;
+    /** Overflow policy — default `'drop-oldest'`. */
+    readonly overflow?: OverflowPolicy;
+    /** `'sample'` overflow only — admit 1 in this many saturated arrivals. */
+    readonly sampleEvery?: number;
+    /** Default capture policy — default `'summary'`. */
+    readonly capturePolicy?: CapturePolicy;
+    /** Per-flush time budget, ms (A1) — default 2; `Infinity` = full drain. */
+    readonly flushBudgetMs?: number;
+    /** Listener-failure sink. No default — without it, failures are silent. */
+    readonly onError?: DispatchErrorHandler;
+    /** Capture seams (dev-warn, capturedAt clock) — see `CaptureHooks`. */
+    readonly hooks?: CaptureHooks;
+    /** Timing clock for budget + per-listener accounting. Injectable. */
+    readonly now?: () => number;
+    /** Checkpoint primitive — default `queueMicrotask`. Injectable. */
+    readonly schedule?: (cb: () => void) => void;
+}
+/** Per-listener accounting (A2/A4). */
+export interface ListenerStats {
+    /** Envelopes delivered (invocations, including ones that threw). */
+    readonly events: number;
+    /** Cumulative sync delivery time, ms. */
+    readonly totalMs: number;
+    /** Sync delivery time since the last flush started, ms. */
+    readonly lastFlushMs: number;
+}
+/** The Block 9 observability surface (amendment A4) — pure getter. */
+export interface DispatcherStats {
+    /** Current backlog. */
+    readonly depth: number;
+    /** Events LOST (overflow) — never silent; also visible as seq gaps. */
+    readonly drops: number;
+    /** Completed checkpoint flushes. */
+    readonly flushes: number;
+    /** Flushes cut short by `flushBudgetMs` (A1). */
+    readonly budgetExhausted: number;
+    /** p95 flush duration, ms (rolling window). */
+    readonly p95FlushMs: number;
+    /** `'block'`-policy refusals delivered synchronously inline. */
+    readonly inlineDeliveries: number;
+    /** Async listener continuations not yet settled. */
+    readonly inflight: number;
+    /** Per-listener time accounting — "name the hog" (A2). */
+    readonly perListener: Readonly<Record<string, ListenerStats>>;
+}
+/** Result of {@link DeferredDispatcher.drain} — `flushAllDetached` shape. */
+export interface DrainResult {
+    /** Async continuations seen settling fulfilled. Best-effort count — a
+     *  continuation that settles between checks is drained but may not be
+     *  counted (same semantics as `flushAllDetached`). */
+    readonly done: number;
+    /** Continuations whose listener promise rejected (routed to onError). */
+    readonly failed: number;
+    /** Still in flight (or queued) when the deadline expired. `0` = drained. */
+    readonly pending: number;
+}
+export declare class DeferredDispatcher {
+    private readonly queue;
+    private readonly driver;
+    private readonly listeners;
+    private readonly listenerStats;
+    /** Tracked async continuations — resolve `true` (ok) / `false` (failed). */
+    private readonly inflight;
+    private readonly onError?;
+    private readonly now;
+    private inlineDeliveries;
+    constructor(opts?: DeferredDispatcherOptions);
+    /** Idempotent by id — same id replaces (stats continue), ids coexist. */
+    addListener(id: string, listener: DeferredListener): void;
+    /** Stop delivering to `id`. Accumulated stats are kept for reports. */
+    removeListener(id: string): void;
+    /**
+     * Producer entry point: capture the event (seq-stamped, payload per
+     * policy) and stage it for the next checkpoint. Cheap; NEVER throws;
+     * never blocks — except under `'block'` overflow, where a refused
+     * enqueue is delivered synchronously inline (explicit consumer choice).
+     */
+    capture(input: EnqueueInput, policy?: CapturePolicy): void;
+    /**
+     * Terminal flush — synchronously deliver everything queued (end of run /
+     * shutdown). Async listener continuations are NOT awaited; follow with
+     * `drain()` for that.
+     */
+    flushNow(opts?: {
+        maxRounds?: number;
+    }): FlushSyncResult;
+    /**
+     * Flush the backlog, then settle all inflight async continuations —
+     * `Promise.allSettled` under a deadline, shaped like `flushAllDetached`.
+     * Loops while continuations spawn new captures, until quiescent or the
+     * deadline expires.
+     */
+    drain(opts?: {
+        timeoutMs?: number;
+    }): Promise<DrainResult>;
+    /** A4 — the stats object Block 9 consumes. Pure getter, fresh snapshot. */
+    getStats(): DispatcherStats;
+    private deliverNext;
+    /** Invoke every listener with full error isolation + time accounting. */
+    private deliver;
+    /** Track an async continuation; route its rejection; never reject. */
+    private track;
+    /** The error sink must never become an error source. */
+    private safeOnError;
+}

package/dist/types/lib/observer-queue/flushDriver.d.ts

@@ -0,0 +1,124 @@
+/**
+ * observer-queue/flushDriver.ts — RFC-001 Block 4: armed-once microtask batcher.
+ *
+ * Pattern:  Kernel-style bottom-half. Producers only set a flag ("work
+ *           pending") and return; the actual work runs at the next
+ *           scheduling checkpoint (a microtask), drains under a time
+ *           budget, and re-arms itself if backlog remains. Same shape as
+ *           the detach module's `microtaskBatchDriver` — accumulate during
+ *           the current sync slice, drain at the boundary.
+ * Role:     The scheduler of the deferred-observer pipeline. Owns WHEN
+ *           delivery happens; knows nothing about envelopes or listeners
+ *           (the dispatcher, Block 5, injects `depth`/`processNext`).
+ *           Pure module — zero imports, zero engine knowledge.
+ *
+ * Scheduling semantics (normative, RFC-001 §5 + amendment A1):
+ *   - `arm()` is idempotent: at most ONE pending flush exists (armed flag).
+ *     N captures between checkpoints ⇒ exactly 1 flush.
+ *   - A flush drains a SNAPSHOT: at most `depth()`-at-flush-start items.
+ *     Events enqueued BY listeners during the flush exceed the snapshot and
+ *     land at the NEXT checkpoint — listener-driven cascades cannot starve
+ *     the event loop.
+ *   - `flushBudgetMs` (default 2; `Infinity` = full snapshot drain): the
+ *     flush stops once the budget is exhausted, counts `budgetExhausted`,
+ *     and re-arms. At least ONE item is processed per flush regardless of
+ *     budget — guaranteed progress under any clock.
+ *   - If backlog remains after the flush (budget cut OR listener enqueues),
+ *     the driver re-arms for the next checkpoint.
+ *
+ * Why stage boundaries make this safe: the engine `await`s every stage, so
+ * the microtask queue runs at EVERY stage boundary — flushes are at most
+ * "one beat behind" the producing stage. See
+ * `docs/guides/execution-model.md` ("Stage boundaries are scheduling
+ * points") and the FAQ in `docs/design/rfc-001-deferred-observers.md`.
+ *
+ * Testability: `now` (clock) and `schedule` (checkpoint primitive) are
+ * injectable — tests pump flushes deterministically with a fake clock and
+ * a captured-callback scheduler; production uses `performance.now` and
+ * `queueMicrotask`.
+ */
+/** Result of one flush (also delivered to `onFlushEnd`). */
+export interface FlushOutcome {
+    /** Items processed in this flush. */
+    readonly processed: number;
+    /** True when the time budget cut the flush before the snapshot drained. */
+    readonly budgetExhausted: boolean;
+    /** True when backlog remained and the driver re-armed itself. */
+    readonly rearmed: boolean;
+}
+/** Result of a synchronous {@link FlushDriver.flushSync} drain. */
+export interface FlushSyncResult {
+    /** Items processed across all rounds. */
+    readonly drained: number;
+    /** Items still queued when `maxRounds` stopped a runaway cascade. */
+    readonly remaining: number;
+}
+export interface FlushDriverOptions {
+    /** Current backlog of the queue this driver drains. */
+    readonly depth: () => number;
+    /** Process exactly ONE queued item. Precondition: `depth() > 0`. */
+    readonly processNext: () => void;
+    /**
+     * Per-flush time budget in ms. Default 2. `Infinity` drains the full
+     * snapshot every checkpoint. Must be > 0.
+     */
+    readonly flushBudgetMs?: number;
+    /** Clock — default `performance.now` (falls back to `Date.now`). */
+    readonly now?: () => number;
+    /** Checkpoint primitive — default `queueMicrotask`. */
+    readonly schedule?: (cb: () => void) => void;
+    /** Fires before the first item of every flush (incl. `flushSync`). */
+    readonly onFlushStart?: () => void;
+    /** Fires after every flush with its outcome (incl. `flushSync`). */
+    readonly onFlushEnd?: (outcome: FlushOutcome) => void;
+}
+export interface FlushDriverStats {
+    /** Completed flushes (zero-work wakeups are not counted). */
+    readonly flushes: number;
+    /** Flushes cut short by `flushBudgetMs` (A1 — backlog visibility). */
+    readonly budgetExhausted: number;
+    /** Duration of the most recent flush, ms. */
+    readonly lastFlushMs: number;
+    /** p95 over the last {@link FLUSH_SAMPLE_WINDOW} flush durations, ms. */
+    readonly p95FlushMs: number;
+    /** True while a flush is scheduled but not yet run. */
+    readonly armed: boolean;
+}
+/** Rolling sample window for the p95 flush-duration stat (A4). */
+export declare const FLUSH_SAMPLE_WINDOW = 128;
+export declare class FlushDriver {
+    private readonly depth;
+    private readonly processNext;
+    private readonly flushBudgetMs;
+    private readonly now;
+    private readonly schedule;
+    private readonly onFlushStart?;
+    private readonly onFlushEnd?;
+    private armed;
+    private flushes;
+    private budgetExhaustedCount;
+    private lastFlushMs;
+    private readonly samples;
+    private sampleWriteIdx;
+    constructor(opts: FlushDriverOptions);
+    /**
+     * Request a flush at the next checkpoint. Idempotent — while one flush
+     * is pending, further arms are free no-ops (the armed-once invariant).
+     */
+    arm(): void;
+    /**
+     * Synchronous full drain — the terminal-flush primitive (end of run /
+     * shutdown). Repeats snapshot rounds until the queue is empty so
+     * listener-enqueued cascades drain too, capped at `maxRounds` so a
+     * listener that enqueues forever cannot hang the process (`remaining`
+     * reports what the cap left behind).
+     */
+    flushSync(opts?: {
+        maxRounds?: number;
+    }): FlushSyncResult;
+    getStats(): FlushDriverStats;
+    /** The microtask body — see the module-header semantics. */
+    private flush;
+    private recordFlush;
+    private p95FlushMs;
+}