footprintjs 9.30.0 → 9.32.0

package/dist/esm/lib/builder/structure/StructureRecorderDispatcher.js

@@ -23,7 +23,7 @@
  * dispatcher; events fire from the natural mutation points in
  * FlowChartBuilder (L7.3).
  */
-import { isDevMode } from '../../scope/detectCircular.js';
+import { isDevMode } from '../../devMode.js';
 /**
  * Soft cap on the `errors[]` accumulator. Builds with thousands of
  * stages and a misbehaving recorder that throws on every event would
@@ -180,4 +180,4 @@ export class StructureRecorderDispatcher {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StructureRecorderDispatcher.js","sourceRoot":"","sources":["../../../../../src/lib/builder/structure/StructureRecorderDispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * StructureRecorderDispatcher — Fans build-time structure events out to N\n * attached `StructureRecorder` instances.\n *\n * Mirrors `FlowRecorderDispatcher` (engine/narrative/) exactly:\n *\n *   - `recorders: StructureRecorder[]` — attach order preserved\n *   - per-event fire methods early-return when no recorders attached\n *     (zero-allocation fast path)\n *   - per-recorder try/catch isolates errors; one bad recorder cannot\n *     cascade into the chain build or sibling recorders\n *   - errors route to BOTH the dev-mode console warning (matches\n *     FlowRecorderDispatcher) AND a structured `buildErrors`\n *     accumulator so consumers can inspect failures post-build\n *   - spec payloads are NOT frozen at dispatch time — handlers must\n *     respect the `readonly` markers on event payload types (the\n *     builder still needs to mutate `spec.next` after the immediate\n *     `onStageAdded` fires; see `fireStageAdded` for the full note,\n *     and `StructureRecorder.ts` header \"Spec mutation\" for the\n *     trust-model implications)\n *\n * The dispatcher itself owns NO chart state. The builder owns the\n * dispatcher; events fire from the natural mutation points in\n * FlowChartBuilder (L7.3).\n */\n\nimport { isDevMode } from '../../scope/detectCircular.js';\nimport type { FlowChartSpec } from '../types.js';\nimport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './StructureRecorder.js';\n\n/** Structured error captured when a recorder throws. Read post-build\n *  via `builder.getStructureBuildErrors()` — call on the BUILDER\n *  reference (NOT the chart returned by `.build()`). Capture the\n *  builder reference before `.build()` if you need post-build access. */\nexport interface StructureBuildError {\n  /** Which recorder's handler threw. */\n  readonly recorderId: string;\n  /** Which event method (`'onStageAdded'`, `'onEdgeAdded'`, ...). */\n  readonly method: string;\n  /** Error message extracted from the thrown value. */\n  readonly message: string;\n  /** The original thrown value — `Error` instance or whatever the\n   *  recorder threw. Useful when diagnosis needs a stack trace. */\n  readonly error: unknown;\n}\n\n/**\n * Soft cap on the `errors[]` accumulator. Builds with thousands of\n * stages and a misbehaving recorder that throws on every event would\n * otherwise retain unbounded `{recorderId, method, message, error}`\n * records — each closing over the thrown value (often an Error with\n * a captured stack), preventing GC of any closure data the throw\n * captured. The cap is for diagnosis, not forensic completeness;\n * once exceeded, a single sentinel record signals truncation.\n */\nconst STRUCTURE_BUILD_ERRORS_CAP = 100;\n\nexport class StructureRecorderDispatcher {\n  private recorders: StructureRecorder[] = [];\n  private readonly errors: StructureBuildError[] = [];\n  private _truncated = false;\n\n  /** Attach a `StructureRecorder`. Multiple recorders with the same\n   *  id are allowed; the convention is one id per logical concern. */\n  attach(recorder: StructureRecorder): void {\n    this.recorders.push(recorder);\n  }\n\n  /** Detach every recorder with the given id. */\n  detach(id: string): void {\n    this.recorders = this.recorders.filter((r) => r.id !== id);\n  }\n\n  /** Defensive copy of the attached recorders — used in tests + by\n   *  tooling that wants to inspect what's registered. */\n  getRecorders(): StructureRecorder[] {\n    return [...this.recorders];\n  }\n\n  /** Find one recorder by id. */\n  getRecorderById<T extends StructureRecorder = StructureRecorder>(id: string): T | undefined {\n    return this.recorders.find((r) => r.id === id) as T | undefined;\n  }\n\n  /** Read accumulated errors from this build. Returns a defensive copy. */\n  getErrors(): StructureBuildError[] {\n    return [...this.errors];\n  }\n\n  // ── fire* methods — called by the builder at each event moment ─────\n\n  fireStageAdded(event: StructureStageAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    // NOTE: `event.spec` is NOT frozen here. `onStageAdded` fires\n    // IMMEDIATELY when a spec node is added — the builder still needs\n    // to mutate `spec.next` later (in the subsequent `addX` call).\n    // Freezing here would break the builder. Handler mutation of\n    // `event.spec` is documented as undefined behavior — see the\n    // StructureRecorder type's JSDoc + readonly markers on the\n    // event payload interface.\n    for (const r of this.recorders) {\n      try {\n        r.onStageAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onStageAdded', err);\n      }\n    }\n  }\n\n  fireStageTagged(event: StructureStageTaggedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onStageTagged?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onStageTagged', err);\n      }\n    }\n  }\n\n  fireEdgeAdded(event: StructureEdgeAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    // No spec on this event — pass through.\n    for (const r of this.recorders) {\n      try {\n        r.onEdgeAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onEdgeAdded', err);\n      }\n    }\n  }\n\n  fireLoopEdgeAdded(event: StructureLoopEdgeAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onLoopEdgeAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onLoopEdgeAdded', err);\n      }\n    }\n  }\n\n  fireDeciderComplete(event: StructureDeciderCompleteEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onDeciderComplete?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onDeciderComplete', err);\n      }\n    }\n  }\n\n  fireSubflowMounted(event: StructureSubflowMountedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onSubflowMounted?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onSubflowMounted', err);\n      }\n    }\n  }\n\n  /**\n   * Externally-callable error capture for events the builder fires\n   * OUTSIDE the normal fire* fan-out path — specifically the seed\n   * replay in `FlowChartBuilder.attachStructureRecorder()`, which\n   * targets one specific recorder rather than every attached recorder.\n   *\n   * Same observability contract as the internal `recordError`:\n   * accumulates on `getErrors()` AND logs in dev mode.\n   */\n  recordErrorForReplay(recorderId: string, method: string, err: unknown): void {\n    this.recordError(recorderId, method, err);\n  }\n\n  // ── Internals ───────────────────────────────────────────────────────\n\n  private recordError(recorderId: string, method: string, err: unknown): void {\n    const e = err as { message?: unknown } | undefined;\n    const message = typeof e?.message === 'string' ? e.message : String(err);\n    // Soft cap to prevent unbounded growth + closure retention. Once\n    // hit, push a single sentinel describing the truncation and drop\n    // further records on the floor (still log in dev mode so the\n    // consumer notices the spam at its source).\n    if (this.errors.length < STRUCTURE_BUILD_ERRORS_CAP) {\n      this.errors.push({ recorderId, method, message, error: err });\n    } else if (!this._truncated) {\n      this._truncated = true;\n      this.errors.push({\n        recorderId: '__truncated__',\n        method: '__truncated__',\n        message: `StructureRecorderDispatcher: error accumulator truncated at ${STRUCTURE_BUILD_ERRORS_CAP} entries; further errors suppressed.`,\n        error: null,\n      });\n    }\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] StructureRecorderDispatcher: recorder \"${recorderId}\" threw in ${method}: ${message}. ` +\n          'See builder.getStructureBuildErrors() for the full list.',\n      );\n    }\n  }\n}\n\n/** Re-export the FlowChartSpec type for downstream type completeness. */\nexport type { FlowChartSpec };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StructureRecorderDispatcher.js","sourceRoot":"","sources":["../../../../../src/lib/builder/structure/StructureRecorderDispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * StructureRecorderDispatcher — Fans build-time structure events out to N\n * attached `StructureRecorder` instances.\n *\n * Mirrors `FlowRecorderDispatcher` (engine/narrative/) exactly:\n *\n *   - `recorders: StructureRecorder[]` — attach order preserved\n *   - per-event fire methods early-return when no recorders attached\n *     (zero-allocation fast path)\n *   - per-recorder try/catch isolates errors; one bad recorder cannot\n *     cascade into the chain build or sibling recorders\n *   - errors route to BOTH the dev-mode console warning (matches\n *     FlowRecorderDispatcher) AND a structured `buildErrors`\n *     accumulator so consumers can inspect failures post-build\n *   - spec payloads are NOT frozen at dispatch time — handlers must\n *     respect the `readonly` markers on event payload types (the\n *     builder still needs to mutate `spec.next` after the immediate\n *     `onStageAdded` fires; see `fireStageAdded` for the full note,\n *     and `StructureRecorder.ts` header \"Spec mutation\" for the\n *     trust-model implications)\n *\n * The dispatcher itself owns NO chart state. The builder owns the\n * dispatcher; events fire from the natural mutation points in\n * FlowChartBuilder (L7.3).\n */\n\nimport { isDevMode } from '../../devMode.js';\nimport type { FlowChartSpec } from '../types.js';\nimport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './StructureRecorder.js';\n\n/** Structured error captured when a recorder throws. Read post-build\n *  via `builder.getStructureBuildErrors()` — call on the BUILDER\n *  reference (NOT the chart returned by `.build()`). Capture the\n *  builder reference before `.build()` if you need post-build access. */\nexport interface StructureBuildError {\n  /** Which recorder's handler threw. */\n  readonly recorderId: string;\n  /** Which event method (`'onStageAdded'`, `'onEdgeAdded'`, ...). */\n  readonly method: string;\n  /** Error message extracted from the thrown value. */\n  readonly message: string;\n  /** The original thrown value — `Error` instance or whatever the\n   *  recorder threw. Useful when diagnosis needs a stack trace. */\n  readonly error: unknown;\n}\n\n/**\n * Soft cap on the `errors[]` accumulator. Builds with thousands of\n * stages and a misbehaving recorder that throws on every event would\n * otherwise retain unbounded `{recorderId, method, message, error}`\n * records — each closing over the thrown value (often an Error with\n * a captured stack), preventing GC of any closure data the throw\n * captured. The cap is for diagnosis, not forensic completeness;\n * once exceeded, a single sentinel record signals truncation.\n */\nconst STRUCTURE_BUILD_ERRORS_CAP = 100;\n\nexport class StructureRecorderDispatcher {\n  private recorders: StructureRecorder[] = [];\n  private readonly errors: StructureBuildError[] = [];\n  private _truncated = false;\n\n  /** Attach a `StructureRecorder`. Multiple recorders with the same\n   *  id are allowed; the convention is one id per logical concern. */\n  attach(recorder: StructureRecorder): void {\n    this.recorders.push(recorder);\n  }\n\n  /** Detach every recorder with the given id. */\n  detach(id: string): void {\n    this.recorders = this.recorders.filter((r) => r.id !== id);\n  }\n\n  /** Defensive copy of the attached recorders — used in tests + by\n   *  tooling that wants to inspect what's registered. */\n  getRecorders(): StructureRecorder[] {\n    return [...this.recorders];\n  }\n\n  /** Find one recorder by id. */\n  getRecorderById<T extends StructureRecorder = StructureRecorder>(id: string): T | undefined {\n    return this.recorders.find((r) => r.id === id) as T | undefined;\n  }\n\n  /** Read accumulated errors from this build. Returns a defensive copy. */\n  getErrors(): StructureBuildError[] {\n    return [...this.errors];\n  }\n\n  // ── fire* methods — called by the builder at each event moment ─────\n\n  fireStageAdded(event: StructureStageAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    // NOTE: `event.spec` is NOT frozen here. `onStageAdded` fires\n    // IMMEDIATELY when a spec node is added — the builder still needs\n    // to mutate `spec.next` later (in the subsequent `addX` call).\n    // Freezing here would break the builder. Handler mutation of\n    // `event.spec` is documented as undefined behavior — see the\n    // StructureRecorder type's JSDoc + readonly markers on the\n    // event payload interface.\n    for (const r of this.recorders) {\n      try {\n        r.onStageAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onStageAdded', err);\n      }\n    }\n  }\n\n  fireStageTagged(event: StructureStageTaggedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onStageTagged?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onStageTagged', err);\n      }\n    }\n  }\n\n  fireEdgeAdded(event: StructureEdgeAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    // No spec on this event — pass through.\n    for (const r of this.recorders) {\n      try {\n        r.onEdgeAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onEdgeAdded', err);\n      }\n    }\n  }\n\n  fireLoopEdgeAdded(event: StructureLoopEdgeAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onLoopEdgeAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onLoopEdgeAdded', err);\n      }\n    }\n  }\n\n  fireDeciderComplete(event: StructureDeciderCompleteEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onDeciderComplete?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onDeciderComplete', err);\n      }\n    }\n  }\n\n  fireSubflowMounted(event: StructureSubflowMountedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onSubflowMounted?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onSubflowMounted', err);\n      }\n    }\n  }\n\n  /**\n   * Externally-callable error capture for events the builder fires\n   * OUTSIDE the normal fire* fan-out path — specifically the seed\n   * replay in `FlowChartBuilder.attachStructureRecorder()`, which\n   * targets one specific recorder rather than every attached recorder.\n   *\n   * Same observability contract as the internal `recordError`:\n   * accumulates on `getErrors()` AND logs in dev mode.\n   */\n  recordErrorForReplay(recorderId: string, method: string, err: unknown): void {\n    this.recordError(recorderId, method, err);\n  }\n\n  // ── Internals ───────────────────────────────────────────────────────\n\n  private recordError(recorderId: string, method: string, err: unknown): void {\n    const e = err as { message?: unknown } | undefined;\n    const message = typeof e?.message === 'string' ? e.message : String(err);\n    // Soft cap to prevent unbounded growth + closure retention. Once\n    // hit, push a single sentinel describing the truncation and drop\n    // further records on the floor (still log in dev mode so the\n    // consumer notices the spam at its source).\n    if (this.errors.length < STRUCTURE_BUILD_ERRORS_CAP) {\n      this.errors.push({ recorderId, method, message, error: err });\n    } else if (!this._truncated) {\n      this._truncated = true;\n      this.errors.push({\n        recorderId: '__truncated__',\n        method: '__truncated__',\n        message: `StructureRecorderDispatcher: error accumulator truncated at ${STRUCTURE_BUILD_ERRORS_CAP} entries; further errors suppressed.`,\n        error: null,\n      });\n    }\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] StructureRecorderDispatcher: recorder \"${recorderId}\" threw in ${method}: ${message}. ` +\n          'See builder.getStructureBuildErrors() for the full list.',\n      );\n    }\n  }\n}\n\n/** Re-export the FlowChartSpec type for downstream type completeness. */\nexport type { FlowChartSpec };\n"]}

package/dist/esm/lib/capture/circular.d.ts

@@ -0,0 +1,17 @@
+/**
+ * circular — Dev-mode circular reference detection for scope values.
+ *
+ * Checks if a value contains circular references using a WeakSet traversal.
+ * O(n) where n = total nested objects. Uses WeakSet so no memory leak.
+ *
+ * Gated by the caller — only called in dev mode to avoid production overhead.
+ * Same approach as Immer (detect and warn at runtime).
+ *
+ * A leaf (imports nothing): it moved here from `scope/detectCircular.ts` so the layers
+ * below `scope/` need not import upward for it.
+ */
+/**
+ * Returns true if the value contains circular references.
+ * Only checks plain objects and arrays — class instances, Date, Map, etc. are skipped.
+ */
+export declare function hasCircularReference(value: unknown, ancestors?: WeakSet<object>): boolean;

package/dist/esm/lib/capture/circular.js

@@ -0,0 +1,45 @@
+/**
+ * circular — Dev-mode circular reference detection for scope values.
+ *
+ * Checks if a value contains circular references using a WeakSet traversal.
+ * O(n) where n = total nested objects. Uses WeakSet so no memory leak.
+ *
+ * Gated by the caller — only called in dev mode to avoid production overhead.
+ * Same approach as Immer (detect and warn at runtime).
+ *
+ * A leaf (imports nothing): it moved here from `scope/detectCircular.ts` so the layers
+ * below `scope/` need not import upward for it.
+ */
+/**
+ * Returns true if the value contains circular references.
+ * Only checks plain objects and arrays — class instances, Date, Map, etc. are skipped.
+ */
+export function hasCircularReference(value, ancestors = new WeakSet()) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    // Skip non-plain objects (Date, Map, Set, class instances) — same as allowlist logic
+    if (Array.isArray(value)) {
+        if (ancestors.has(value))
+            return true;
+        ancestors.add(value);
+        for (const item of value) {
+            if (hasCircularReference(item, ancestors))
+                return true;
+        }
+        ancestors.delete(value); // backtrack — allow diamond references
+        return false;
+    }
+    const ctor = value.constructor;
+    if (ctor !== undefined && ctor !== Object)
+        return false; // class instance — skip
+    if (ancestors.has(value))
+        return true;
+    ancestors.add(value);
+    for (const v of Object.values(value)) {
+        if (hasCircularReference(v, ancestors))
+            return true;
+    }
+    ancestors.delete(value); // backtrack — allow diamond references
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -26,7 +26,7 @@
  *     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).
+ *   This module must not import `devMode` (the dev-mode flag is library state).
  *   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

package/dist/esm/lib/capture/envelope.js

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

package/dist/esm/lib/capture/index.d.ts

@@ -7,10 +7,16 @@
  *     #14 `readTracking` and #13c-A `writeTracking` dials.
  *   - `summarizeReadValue` / `summarizeWriteValue` — the parameterized
  *     summary-marker builders sharing one classification path.
+ *   - `summarizeValue` — the human-readable narrative one-liner.
+ *   - `hasCircularReference` — the dev-mode cycle probe (a leaf).
+ *   - `invokeRecorderHook` — the one "look up the hook, bind `this`, call it"
+ *     primitive both recorder delivery tiers share (a leaf).
  *
  * RFC-001 (deferred observer delivery) builds its capture tier on this
  * module — see the mapping notes in `policies.ts`.
  */
+export { hasCircularReference } from './circular.js';
+export { invokeRecorderHook } from './invokeHook.js';
 export type { RetentionPolicy } from './policies.js';
 export type { ReadSummaryMarker, SummaryValueType, WriteSummaryMarker } from './summarize.js';
-export { READ_PREVIEW_LENGTH, summarizeReadValue, summarizeWriteValue, SUMMARY_PREVIEW_LENGTH } from './summarize.js';
+export { READ_PREVIEW_LENGTH, summarizeReadValue, summarizeValue, summarizeWriteValue, SUMMARY_PREVIEW_LENGTH, } from './summarize.js';

package/dist/esm/lib/capture/index.js

@@ -8,9 +8,15 @@
  *     #14 `readTracking` and #13c-A `writeTracking` dials.
  *   - `summarizeReadValue` / `summarizeWriteValue` — the parameterized
  *     summary-marker builders sharing one classification path.
+ *   - `summarizeValue` — the human-readable narrative one-liner.
+ *   - `hasCircularReference` — the dev-mode cycle probe (a leaf).
+ *   - `invokeRecorderHook` — the one "look up the hook, bind `this`, call it"
+ *     primitive both recorder delivery tiers share (a leaf).
  *
  * RFC-001 (deferred observer delivery) builds its capture tier on this
  * module — see the mapping notes in `policies.ts`.
  */
-export { READ_PREVIEW_LENGTH, summarizeReadValue, summarizeWriteValue, SUMMARY_PREVIEW_LENGTH } from './summarize.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NhcHR1cmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMEJBQTBCO0FBQzFCOzs7Ozs7Ozs7Ozs7R0FZRztBQUlILE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxrQkFBa0IsRUFBRSxtQkFBbUIsRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogaXN0YW5idWwgaWdub3JlIGZpbGUgKi9cbi8qKlxuICogY2FwdHVyZS8g4oCUIFNoYXJlZCB2YWx1ZS1jYXB0dXJlIC8gcmV0ZW50aW9uIHByaW1pdGl2ZXMgKHplcm8gZGVwcywgbGVhZlxuICogbW9kdWxlIOKAlCBgbWVtb3J5L2AgaW1wb3J0cyBpdCwgbmV2ZXIgdGhlIHJldmVyc2UpLlxuICpcbiAqIE9uZSBob21lIGZvciBcIndoYXQgZG8gd2Uga2VlcCBhYm91dCBhIHRyYWNrZWQgb3BlcmF0aW9uJ3MgdmFsdWU/XCI6XG4gKiAgIC0gYFJldGVudGlvblBvbGljeWAg4oCUIHRoZSBgJ2Z1bGwnIHwgJ3N1bW1hcnknIHwgJ29mZidgIGZhbWlseSBiZWhpbmQgdGhlXG4gKiAgICAgIzE0IGByZWFkVHJhY2tpbmdgIGFuZCAjMTNjLUEgYHdyaXRlVHJhY2tpbmdgIGRpYWxzLlxuICogICAtIGBzdW1tYXJpemVSZWFkVmFsdWVgIC8gYHN1bW1hcml6ZVdyaXRlVmFsdWVgIOKAlCB0aGUgcGFyYW1ldGVyaXplZFxuICogICAgIHN1bW1hcnktbWFya2VyIGJ1aWxkZXJzIHNoYXJpbmcgb25lIGNsYXNzaWZpY2F0aW9uIHBhdGguXG4gKlxuICogUkZDLTAwMSAoZGVmZXJyZWQgb2JzZXJ2ZXIgZGVsaXZlcnkpIGJ1aWxkcyBpdHMgY2FwdHVyZSB0aWVyIG9uIHRoaXNcbiAqIG1vZHVsZSDigJQgc2VlIHRoZSBtYXBwaW5nIG5vdGVzIGluIGBwb2xpY2llcy50c2AuXG4gKi9cblxuZXhwb3J0IHR5cGUgeyBSZXRlbnRpb25Qb2xpY3kgfSBmcm9tICcuL3BvbGljaWVzLmpzJztcbmV4cG9ydCB0eXBlIHsgUmVhZFN1bW1hcnlNYXJrZXIsIFN1bW1hcnlWYWx1ZVR5cGUsIFdyaXRlU3VtbWFyeU1hcmtlciB9IGZyb20gJy4vc3VtbWFyaXplLmpzJztcbmV4cG9ydCB7IFJFQURfUFJFVklFV19MRU5HVEgsIHN1bW1hcml6ZVJlYWRWYWx1ZSwgc3VtbWFyaXplV3JpdGVWYWx1ZSwgU1VNTUFSWV9QUkVWSUVXX0xFTkdUSCB9IGZyb20gJy4vc3VtbWFyaXplLmpzJztcbiJdfQ==
+export { hasCircularReference } from './circular.js';
+export { invokeRecorderHook } from './invokeHook.js';
+export { READ_PREVIEW_LENGTH, summarizeReadValue, summarizeValue, summarizeWriteValue, SUMMARY_PREVIEW_LENGTH, } from './summarize.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/capture/invokeHook.d.ts

@@ -0,0 +1,36 @@
+/**
+ * capture/invokeHook.ts — the ONE per-listener invoke helper (RFC-001 §9 mitigation).
+ *
+ * Pattern:  Single shared "look up the hook, bind `this`, call it" primitive
+ *           used by BOTH delivery tiers:
+ *             - inline:   `ScopeFacade._invokeHook` / `ScopeFacade.emitEvent`
+ *               call it per recorder per event (the historical direct call);
+ *             - deferred: `DeferredObserverTier`'s dispatcher listener calls
+ *               it per envelope at the flush checkpoint.
+ *           Because both tiers route through the SAME lookup + `.call(this)`
+ *           semantics, the two paths cannot drift: a recorder that works
+ *           inline is invoked identically one beat behind.
+ * Role:     Invocation primitive only. NO error handling here — the two
+ *           tiers isolate failures differently by design (inline routes a
+ *           throw to sibling recorders' `onError` at the dispatch site;
+ *           deferred routes sync throws AND async rejections through
+ *           `DeferredDispatcher`'s injected error callback).
+ *
+ * Lookup semantics: NORMAL property lookup (prototype chain included), the
+ * same as the historical `recorder[hook]` read in `ScopeFacade._invokeHook` —
+ * class-based recorders declare hooks on their prototype. (The own-property
+ * restriction in `hasRecorderMethods` applies only to CHANNEL ROUTING
+ * detection, not to invocation.)
+ *
+ * A leaf (imports nothing): it moved here from `recorder/invokeHook.ts` so `scope/`
+ * (the inline tier) and `runner/` (the deferred tier) can share it without `scope/`
+ * importing `recorder/` — that edge was part of the memory ⇄ scope ⇄ recorder cycle.
+ */
+/**
+ * Invoke `recorder[method](event)` with `this` bound to the recorder, iff
+ * `method` resolves to a function. Returns the hook's return value (a
+ * deferred listener may return a Promise the dispatcher tracks); returns
+ * `undefined` when the hook is absent. Throws whatever the hook throws —
+ * callers own error isolation.
+ */
+export declare function invokeRecorderHook(recorder: object, method: string, event: unknown): unknown;

package/dist/esm/lib/capture/invokeHook.js

@@ -0,0 +1,42 @@
+/**
+ * capture/invokeHook.ts — the ONE per-listener invoke helper (RFC-001 §9 mitigation).
+ *
+ * Pattern:  Single shared "look up the hook, bind `this`, call it" primitive
+ *           used by BOTH delivery tiers:
+ *             - inline:   `ScopeFacade._invokeHook` / `ScopeFacade.emitEvent`
+ *               call it per recorder per event (the historical direct call);
+ *             - deferred: `DeferredObserverTier`'s dispatcher listener calls
+ *               it per envelope at the flush checkpoint.
+ *           Because both tiers route through the SAME lookup + `.call(this)`
+ *           semantics, the two paths cannot drift: a recorder that works
+ *           inline is invoked identically one beat behind.
+ * Role:     Invocation primitive only. NO error handling here — the two
+ *           tiers isolate failures differently by design (inline routes a
+ *           throw to sibling recorders' `onError` at the dispatch site;
+ *           deferred routes sync throws AND async rejections through
+ *           `DeferredDispatcher`'s injected error callback).
+ *
+ * Lookup semantics: NORMAL property lookup (prototype chain included), the
+ * same as the historical `recorder[hook]` read in `ScopeFacade._invokeHook` —
+ * class-based recorders declare hooks on their prototype. (The own-property
+ * restriction in `hasRecorderMethods` applies only to CHANNEL ROUTING
+ * detection, not to invocation.)
+ *
+ * A leaf (imports nothing): it moved here from `recorder/invokeHook.ts` so `scope/`
+ * (the inline tier) and `runner/` (the deferred tier) can share it without `scope/`
+ * importing `recorder/` — that edge was part of the memory ⇄ scope ⇄ recorder cycle.
+ */
+/**
+ * Invoke `recorder[method](event)` with `this` bound to the recorder, iff
+ * `method` resolves to a function. Returns the hook's return value (a
+ * deferred listener may return a Promise the dispatcher tracks); returns
+ * `undefined` when the hook is absent. Throws whatever the hook throws —
+ * callers own error isolation.
+ */
+export function invokeRecorderHook(recorder, method, event) {
+    const hook = recorder[method];
+    if (typeof hook !== 'function')
+        return undefined;
+    return hook.call(recorder, event);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/capture/summarize.d.ts

@@ -8,6 +8,9 @@
  *
  * Deliberately avoids every O(value) operation: no clone, no serialization.
  * See {@link ReadSummaryMarker} for the honest-cost contract.
+ *
+ * Also home of {@link summarizeValue} — the narrative one-liner (a string, not a
+ * marker) the decide() evidence capture and the combined narrative share.
  */
 /** Max characters captured in a summary marker's `preview`. */
 export declare const SUMMARY_PREVIEW_LENGTH = 80;
@@ -62,4 +65,14 @@ export declare function summarizeReadValue(value: unknown): ReadSummaryMarker;
  * of {@link summarizeReadValue} — same classification, distinct brand.
  */
 export declare function summarizeWriteValue(value: unknown): WriteSummaryMarker;
+/**
+ * Human-readable one-line summary of a value, for NARRATIVE output (as opposed to the
+ * retention markers above, which are records). Truncates strings, summarizes arrays and
+ * objects by count. Shared by `CombinedNarrativeRecorder` and the decide()/select()
+ * evidence capture so both format a value the same way.
+ *
+ * Moved here from `scope/recorders/summarizeValue.ts` (a leaf living in a mid-layer
+ * module forced `decide/` and `engine/narrative/` to import it upward).
+ */
+export declare function summarizeValue(value: unknown, maxLen: number): string;
 export {};

package/dist/esm/lib/capture/summarize.js

@@ -8,6 +8,9 @@
  *
  * Deliberately avoids every O(value) operation: no clone, no serialization.
  * See {@link ReadSummaryMarker} for the honest-cost contract.
+ *
+ * Also home of {@link summarizeValue} — the narrative one-liner (a string, not a
+ * marker) the decide() evidence capture and the combined narrative share.
  */
 /** Max characters captured in a summary marker's `preview`. */
 export const SUMMARY_PREVIEW_LENGTH = 80;
@@ -55,4 +58,37 @@ export function summarizeReadValue(value) {
 export function summarizeWriteValue(value) {
     return { __writeSummary: true, ...classifyValue(value) };
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Human-readable one-line summary of a value, for NARRATIVE output (as opposed to the
+ * retention markers above, which are records). Truncates strings, summarizes arrays and
+ * objects by count. Shared by `CombinedNarrativeRecorder` and the decide()/select()
+ * evidence capture so both format a value the same way.
+ *
+ * Moved here from `scope/recorders/summarizeValue.ts` (a leaf living in a mid-layer
+ * module forced `decide/` and `engine/narrative/` to import it upward).
+ */
+export function summarizeValue(value, maxLen) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string') {
+        return value.length <= maxLen ? `"${value}"` : `"${value.slice(0, maxLen - 3)}..."`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value)) {
+        return value.length === 0 ? '[]' : `(${value.length} item${value.length > 1 ? 's' : ''})`;
+    }
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        if (keys.length === 0)
+            return '{}';
+        const preview = keys.slice(0, 4).join(', ');
+        const suffix = keys.length > 4 ? `, ... (${keys.length} keys)` : '';
+        const result = `{${preview}${suffix}}`;
+        return result.length <= maxLen ? result : `{${keys.length} keys}`;
+    }
+    return String(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"summarize.js","sourceRoot":"","sources":["../../../../src/lib/capture/summarize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * summarize.ts — Cheap value summarization for `'summary'` retention.\n *\n * Extracted from `StageContext` (#14's `summarizeReadValue`) into a shared,\n * brand-parameterized helper so both snapshot-tracking dials (#14\n * `readTracking`, #13c-A `writeTracking`) — and later RFC-001's deferred\n * observer capture tier — produce identical summaries from ONE code path.\n *\n * Deliberately avoids every O(value) operation: no clone, no serialization.\n * See {@link ReadSummaryMarker} for the honest-cost contract.\n *\n * Also home of {@link summarizeValue} — the narrative one-liner (a string, not a\n * marker) the decide() evidence capture and the combined narrative share.\n */\n\n/** Max characters captured in a summary marker's `preview`. */\nexport const SUMMARY_PREVIEW_LENGTH = 80;\n\n/**\n * Compat alias for {@link SUMMARY_PREVIEW_LENGTH} — the name shipped with\n * #14, kept so existing import paths (`memory/types`, the memory barrel)\n * stay valid. Same constant; reads and writes share one preview cap.\n */\nexport const READ_PREVIEW_LENGTH = SUMMARY_PREVIEW_LENGTH;\n\n/** `typeof` result, refined to 'array' / 'null' for objects. */\nexport type SummaryValueType =\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'bigint'\n  | 'symbol'\n  | 'function'\n  | 'object'\n  | 'array'\n  | 'null';\n\n/** Brand-free summary fields shared by both marker shapes. */\ninterface ValueSummary {\n  /** `typeof` result, refined to 'array' / 'null' for objects. */\n  type: SummaryValueType;\n  /** Size proxy: string length, array length, or object key count. */\n  size?: number;\n  /** First {@link SUMMARY_PREVIEW_LENGTH} chars — primitives and strings only. */\n  preview?: string;\n}\n\n/**\n * Marker recorded in `StageSnapshot.stageReads` under `readTracking: 'summary'`.\n *\n * Honest cost note: `size` is a cheap proxy (string length / array length /\n * object key count), NOT a serialized byte count — computing real byte size\n * would require an O(value) serialization, which is exactly the cost the\n * summary mode removes. `preview` is only produced for primitives and strings\n * (first {@link SUMMARY_PREVIEW_LENGTH} characters); objects and arrays carry\n * no preview for the same reason.\n */\nexport interface ReadSummaryMarker extends ValueSummary {\n  /** Discriminant — lets snapshot consumers detect marker entries. */\n  __readSummary: true;\n}\n\n/**\n * Marker recorded in `StageSnapshot.stageWrites` (and the commit observer's\n * mutations payload) under `writeTracking: 'summary'` (#13c-A). Same fields\n * and cost contract as {@link ReadSummaryMarker}; distinct brand so consumers\n * can tell which dial produced an entry.\n */\nexport interface WriteSummaryMarker extends ValueSummary {\n  /** Discriminant — lets snapshot consumers detect marker entries. */\n  __writeSummary: true;\n}\n\n/**\n * The one classification path both brands share — every per-type rule\n * (including the Map/Set real-entry-count handling) lives here exactly once.\n */\nfunction classifyValue(value: unknown): ValueSummary {\n  if (value === null) return { type: 'null' };\n  if (typeof value === 'string') {\n    return { type: 'string', size: value.length, preview: value.slice(0, SUMMARY_PREVIEW_LENGTH) };\n  }\n  if (Array.isArray(value)) return { type: 'array', size: value.length };\n  if (value instanceof Map || value instanceof Set) {\n    // Object.keys() on a Map/Set is always [] — report the real entry count.\n    return { type: 'object', size: value.size };\n  }\n  if (typeof value === 'object') {\n    return { type: 'object', size: Object.keys(value as Record<string, unknown>).length };\n  }\n  if (typeof value === 'function') return { type: 'function' };\n  // number | boolean | bigint | symbol — String() is O(rendered length)\n  return { type: typeof value as SummaryValueType, preview: String(value).slice(0, SUMMARY_PREVIEW_LENGTH) };\n}\n\n/**\n * Summarize a tracked READ for `readTracking: 'summary'` (#14). Byte-identical\n * output to the pre-extraction `StageContext`-local implementation.\n */\nexport function summarizeReadValue(value: unknown): ReadSummaryMarker {\n  return { __readSummary: true, ...classifyValue(value) };\n}\n\n/**\n * Summarize a tracked WRITE for `writeTracking: 'summary'` (#13c-A). Sibling\n * of {@link summarizeReadValue} — same classification, distinct brand.\n */\nexport function summarizeWriteValue(value: unknown): WriteSummaryMarker {\n  return { __writeSummary: true, ...classifyValue(value) };\n}\n\n/**\n * Human-readable one-line summary of a value, for NARRATIVE output (as opposed to the\n * retention markers above, which are records). Truncates strings, summarizes arrays and\n * objects by count. Shared by `CombinedNarrativeRecorder` and the decide()/select()\n * evidence capture so both format a value the same way.\n *\n * Moved here from `scope/recorders/summarizeValue.ts` (a leaf living in a mid-layer\n * module forced `decide/` and `engine/narrative/` to import it upward).\n */\nexport function summarizeValue(value: unknown, maxLen: number): string {\n  if (value === undefined) return 'undefined';\n  if (value === null) return 'null';\n  if (typeof value === 'string') {\n    return value.length <= maxLen ? `\"${value}\"` : `\"${value.slice(0, maxLen - 3)}...\"`;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') return String(value);\n  if (Array.isArray(value)) {\n    return value.length === 0 ? '[]' : `(${value.length} item${value.length > 1 ? 's' : ''})`;\n  }\n  if (typeof value === 'object') {\n    const keys = Object.keys(value as Record<string, unknown>);\n    if (keys.length === 0) return '{}';\n    const preview = keys.slice(0, 4).join(', ');\n    const suffix = keys.length > 4 ? `, ... (${keys.length} keys)` : '';\n    const result = `{${preview}${suffix}}`;\n    return result.length <= maxLen ? result : `{${keys.length} keys}`;\n  }\n  return String(value);\n}\n"]}