footprintjs 9.4.0 → 9.6.0

package/dist/esm/lib/observer-queue/deferredDispatcher.js

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

package/dist/esm/lib/observer-queue/flushDriver.js

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

package/dist/esm/lib/observer-queue/index.js

@@ -0,0 +1,22 @@
+/* istanbul ignore file */
+/**
+ * observer-queue/ — RFC-001 deferred observer delivery, Blocks 2–5.
+ *
+ * The pure "one beat behind" pipeline:
+ *
+ *   producer ─► capture (Block 1, `capture/envelope`) ─► MergedQueue
+ *   (Block 3, seq-stamped over a BoundedRing, Block 2) ─► FlushDriver
+ *   (Block 4, armed-once microtask checkpoints, flushBudgetMs) ─►
+ *   DeferredDispatcher (Block 5, isolated listeners + inflight + stats)
+ *
+ * INTERNAL MODULE — deliberately NOT exported from the public footprintjs
+ * barrels yet. The engine wiring + public surface land with Blocks 6–10
+ * (see docs/design/rfc-001-deferred-observers.md). Zero engine imports:
+ * this directory may import only `../capture/` and its own files.
+ */
+export { capture, PAYLOAD_SUMMARY_MAX_DEPTH, PAYLOAD_SUMMARY_MAX_ENTRIES, PAYLOAD_SUMMARY_MAX_NODES, summarizePayload, } from '../capture/envelope.js';
+export { DeferredDispatcher } from './deferredDispatcher.js';
+export { FLUSH_SAMPLE_WINDOW, FlushDriver } from './flushDriver.js';
+export { DEFAULT_MAX_QUEUE, MergedQueue } from './mergedQueue.js';
+export { BoundedRing } from './ring.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/observer-queue/mergedQueue.js

@@ -0,0 +1,91 @@
+/**
+ * observer-queue/mergedQueue.ts — RFC-001 Block 3: seq stamping + multi-channel merge.
+ *
+ * Pattern:  Single totally-ordered staging queue. All three observer
+ *           channels (`scope` / `flow` / `emit`) funnel through ONE queue;
+ *           the `seq` counter is assigned at capture under the single JS
+ *           thread, so drain order == arrival order ACROSS channels with no
+ *           cross-queue merge logic ever needed.
+ * Role:     Glue between the capture tier (Block 1) and the flush driver
+ *           (Block 4). Pure module — imports only `capture/envelope` and
+ *           the ring (Block 2); zero engine knowledge.
+ *
+ * Seq semantics (normative, RFC-001 §5):
+ *   - Stamped BEFORE admission — an event that is then dropped (overflow)
+ *     or refused (`'block'`) still consumed its seq. Drops therefore leave
+ *     VISIBLE gaps in the delivered stream (honest loss accounting), and
+ *     `'block'`-refused events delivered inline keep their true arrival
+ *     stamp even though they overtake the queued backlog.
+ *   - Monotonic, starts at 0, never reused for the lifetime of the queue.
+ *
+ * Enqueue outcomes:
+ *   - `'queued'`  — staged for the next flush (drop-oldest may have evicted
+ *     an older event to make room; that loss is counted, never silent).
+ *   - `'dropped'` — the event was sampled out at saturation. Lost; counted.
+ *   - `'inline'`  — `'block'` policy refused the enqueue. NOT lost: the
+ *     caller (the dispatcher, Block 5) must deliver the returned envelope
+ *     synchronously inline — blocking delivery by explicit consumer choice.
+ */
+import { capture, } from '../capture/envelope.js';
+import { BoundedRing } from './ring.js';
+/** RFC-001 §5 default queue bound. */
+export const DEFAULT_MAX_QUEUE = 10_000;
+export class MergedQueue {
+    ring;
+    overflow;
+    defaultPolicy;
+    hooks;
+    /** Arrival stamp — monotonic across ALL channels (see module header). */
+    seq = 0;
+    constructor(opts) {
+        this.overflow = opts?.overflow ?? 'drop-oldest';
+        this.ring = new BoundedRing({
+            capacity: opts?.maxQueue ?? DEFAULT_MAX_QUEUE,
+            policy: this.overflow,
+            sampleEvery: opts?.sampleEvery,
+        });
+        this.defaultPolicy = opts?.capturePolicy ?? 'summary';
+        this.hooks = opts?.hooks;
+    }
+    /**
+     * Capture one event (seq-stamped at arrival) and stage it for deferred
+     * delivery. `policy` overrides the queue default per call — e.g. `'ref'`
+     * for payloads the caller proved immutable. Never throws.
+     */
+    enqueue(input, policy) {
+        const envelope = capture({
+            seq: this.seq,
+            channel: input.channel,
+            method: input.method,
+            runtimeStageId: input.runtimeStageId,
+            runId: input.runId,
+            payload: input.payload,
+        }, policy ?? this.defaultPolicy, this.hooks);
+        this.seq += 1;
+        const pushed = this.ring.push(envelope);
+        if (pushed.accepted)
+            return { envelope, outcome: 'queued' };
+        return { envelope, outcome: this.overflow === 'block' ? 'inline' : 'dropped' };
+    }
+    /** Pop the oldest staged envelope (total arrival order across channels). */
+    shift() {
+        return this.ring.shift();
+    }
+    /** Current backlog. */
+    get depth() {
+        return this.ring.size;
+    }
+    /** Ring capacity (the `maxQueue` bound). */
+    get capacity() {
+        return this.ring.capacity;
+    }
+    /** The next seq to be assigned == total events captured so far. */
+    get nextSeq() {
+        return this.seq;
+    }
+    /** Lifetime loss/delivery accounting — delegated to the ring. */
+    getCounters() {
+        return this.ring.getCounters();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mergedQueue.js","sourceRoot":"","sources":["../../../../src/lib/observer-queue/mergedQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAKL,OAAO,GACR,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAA0C,WAAW,EAAE,MAAM,WAAW,CAAC;AAEhF,sCAAsC;AACtC,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAkCxC,MAAM,OAAO,WAAW;IACL,IAAI,CAA+B;IACnC,QAAQ,CAAiB;IACzB,aAAa,CAAgB;IAC7B,KAAK,CAAgB;IACtC,yEAAyE;IACjE,GAAG,GAAG,CAAC,CAAC;IAEhB,YAAY,IAAyB;QACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,EAAE,QAAQ,IAAI,aAAa,CAAC;QAChD,IAAI,CAAC,IAAI,GAAG,IAAI,WAAW,CAAkB;YAC3C,QAAQ,EAAE,IAAI,EAAE,QAAQ,IAAI,iBAAiB;YAC7C,MAAM,EAAE,IAAI,CAAC,QAAQ;YACrB,WAAW,EAAE,IAAI,EAAE,WAAW;SAC/B,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,IAAI,EAAE,aAAa,IAAI,SAAS,CAAC;QACtD,IAAI,CAAC,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAmB,EAAE,MAAsB;QACjD,MAAM,QAAQ,GAAG,OAAO,CACtB;YACE,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,EACD,MAAM,IAAI,IAAI,CAAC,aAAa,EAC5B,IAAI,CAAC,KAAK,CACX,CAAC;QACF,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAEd,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,MAAM,CAAC,QAAQ;YAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;QAC5D,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IACjF,CAAC;IAED,4EAA4E;IAC5E,KAAK;QACH,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;IAED,uBAAuB;IACvB,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACxB,CAAC;IAED,4CAA4C;IAC5C,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED,mEAAmE;IACnE,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,iEAAiE;IACjE,WAAW;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IACjC,CAAC;CACF","sourcesContent":["/**\n * observer-queue/mergedQueue.ts — RFC-001 Block 3: seq stamping + multi-channel merge.\n *\n * Pattern:  Single totally-ordered staging queue. All three observer\n *           channels (`scope` / `flow` / `emit`) funnel through ONE queue;\n *           the `seq` counter is assigned at capture under the single JS\n *           thread, so drain order == arrival order ACROSS channels with no\n *           cross-queue merge logic ever needed.\n * Role:     Glue between the capture tier (Block 1) and the flush driver\n *           (Block 4). Pure module — imports only `capture/envelope` and\n *           the ring (Block 2); zero engine knowledge.\n *\n * Seq semantics (normative, RFC-001 §5):\n *   - Stamped BEFORE admission — an event that is then dropped (overflow)\n *     or refused (`'block'`) still consumed its seq. Drops therefore leave\n *     VISIBLE gaps in the delivered stream (honest loss accounting), and\n *     `'block'`-refused events delivered inline keep their true arrival\n *     stamp even though they overtake the queued backlog.\n *   - Monotonic, starts at 0, never reused for the lifetime of the queue.\n *\n * Enqueue outcomes:\n *   - `'queued'`  — staged for the next flush (drop-oldest may have evicted\n *     an older event to make room; that loss is counted, never silent).\n *   - `'dropped'` — the event was sampled out at saturation. Lost; counted.\n *   - `'inline'`  — `'block'` policy refused the enqueue. NOT lost: the\n *     caller (the dispatcher, Block 5) must deliver the returned envelope\n *     synchronously inline — blocking delivery by explicit consumer choice.\n */\n\nimport {\n  type CaptureChannel,\n  type CaptureEnvelope,\n  type CaptureHooks,\n  type CapturePolicy,\n  capture,\n} from '../capture/envelope.js';\nimport { type OverflowPolicy, type RingCounters, BoundedRing } from './ring.js';\n\n/** RFC-001 §5 default queue bound. */\nexport const DEFAULT_MAX_QUEUE = 10_000;\n\n/** One observer event to merge — {@link capture}'s request minus `seq`. */\nexport interface EnqueueInput {\n  readonly channel: CaptureChannel;\n  readonly method: string;\n  readonly runtimeStageId: string;\n  readonly runId: string;\n  /** LIVE payload — materialized per capture policy at enqueue time. */\n  readonly payload: unknown;\n}\n\n/** Fate of one enqueued event — see the module header. */\nexport type EnqueueOutcome = 'queued' | 'dropped' | 'inline';\n\nexport interface EnqueueResult {\n  /** The captured, seq-stamped envelope (built even when not queued). */\n  readonly envelope: CaptureEnvelope;\n  readonly outcome: EnqueueOutcome;\n}\n\nexport interface MergedQueueOptions {\n  /** Ring capacity. Default {@link DEFAULT_MAX_QUEUE} (10 000). */\n  readonly maxQueue?: number;\n  /** Overflow policy at capacity. Default `'drop-oldest'`. */\n  readonly overflow?: OverflowPolicy;\n  /** `'sample'` only — admit 1 in this many saturated arrivals. */\n  readonly sampleEvery?: number;\n  /** Default capture policy when `enqueue` gets none. Default `'summary'`. */\n  readonly capturePolicy?: CapturePolicy;\n  /** Engine-free seams (dev-warn, clock) passed through to {@link capture}. */\n  readonly hooks?: CaptureHooks;\n}\n\nexport class MergedQueue {\n  private readonly ring: BoundedRing<CaptureEnvelope>;\n  private readonly overflow: OverflowPolicy;\n  private readonly defaultPolicy: CapturePolicy;\n  private readonly hooks?: CaptureHooks;\n  /** Arrival stamp — monotonic across ALL channels (see module header). */\n  private seq = 0;\n\n  constructor(opts?: MergedQueueOptions) {\n    this.overflow = opts?.overflow ?? 'drop-oldest';\n    this.ring = new BoundedRing<CaptureEnvelope>({\n      capacity: opts?.maxQueue ?? DEFAULT_MAX_QUEUE,\n      policy: this.overflow,\n      sampleEvery: opts?.sampleEvery,\n    });\n    this.defaultPolicy = opts?.capturePolicy ?? 'summary';\n    this.hooks = opts?.hooks;\n  }\n\n  /**\n   * Capture one event (seq-stamped at arrival) and stage it for deferred\n   * delivery. `policy` overrides the queue default per call — e.g. `'ref'`\n   * for payloads the caller proved immutable. Never throws.\n   */\n  enqueue(input: EnqueueInput, policy?: CapturePolicy): EnqueueResult {\n    const envelope = capture(\n      {\n        seq: this.seq,\n        channel: input.channel,\n        method: input.method,\n        runtimeStageId: input.runtimeStageId,\n        runId: input.runId,\n        payload: input.payload,\n      },\n      policy ?? this.defaultPolicy,\n      this.hooks,\n    );\n    this.seq += 1;\n\n    const pushed = this.ring.push(envelope);\n    if (pushed.accepted) return { envelope, outcome: 'queued' };\n    return { envelope, outcome: this.overflow === 'block' ? 'inline' : 'dropped' };\n  }\n\n  /** Pop the oldest staged envelope (total arrival order across channels). */\n  shift(): CaptureEnvelope | undefined {\n    return this.ring.shift();\n  }\n\n  /** Current backlog. */\n  get depth(): number {\n    return this.ring.size;\n  }\n\n  /** Ring capacity (the `maxQueue` bound). */\n  get capacity(): number {\n    return this.ring.capacity;\n  }\n\n  /** The next seq to be assigned == total events captured so far. */\n  get nextSeq(): number {\n    return this.seq;\n  }\n\n  /** Lifetime loss/delivery accounting — delegated to the ring. */\n  getCounters(): RingCounters {\n    return this.ring.getCounters();\n  }\n}\n"]}