footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/reactive/types.d.ts

@@ -7,6 +7,9 @@
  *
  * Dependency: type-only imports from engine/ and scope/ (zero runtime cost).
  */
+import type { AttemptContext, CallOptions, RetryPolicy } from '../attempt/types.js';
+import type { FlowChart } from '../builder/types.js';
+import type { DetachDriver, DetachHandle } from '../detach/types.js';
 import type { ExecutionEnv } from '../engine/types.js';
 import type { ScopeRecorder } from '../scope/types.js';
 export interface ReactiveTarget {
@@ -27,6 +30,10 @@ export interface ReactiveTarget {
     getValueSilent?(key?: string): unknown;
     getArgs<T = Record<string, unknown>>(): T;
     getEnv(): Readonly<ExecutionEnv>;
+    /** The attempt the stage function runs in — its signal, its cap and the time left (P1b). */
+    getAttempt(): AttemptContext;
+    /** A call to an outside system on the attempt runner, recorded under this stage (P2). */
+    call<R>(target: string, fn: (attempt: AttemptContext) => Promise<R> | R, policy?: RetryPolicy, options?: CallOptions): Promise<R>;
     attachScopeRecorder(recorder: ScopeRecorder): void;
     detachScopeRecorder(recorderId: string): void;
     getScopeRecorders(): ScopeRecorder[];
@@ -36,8 +43,8 @@ export interface ReactiveTarget {
     addMetric(name: string, value: unknown): void;
     addEval(name: string, value: unknown): void;
     emitEvent(name: string, payload?: unknown): void;
-    detachAndJoinLater(driver: import('../detach/types.js').DetachDriver, child: import('../builder/types.js').FlowChart, input?: unknown): import('../detach/types.js').DetachHandle;
-    detachAndForget(driver: import('../detach/types.js').DetachDriver, child: import('../builder/types.js').FlowChart, input?: unknown): void;
+    detachAndJoinLater(driver: DetachDriver, child: FlowChart, input?: unknown): DetachHandle;
+    detachAndForget(driver: DetachDriver, child: FlowChart, input?: unknown): void;
 }
 export interface ScopeMethods {
     $getValue(key: string): unknown;
@@ -48,6 +55,31 @@ export interface ScopeMethods {
     $read(dotPath: string): unknown;
     $getArgs<T = Record<string, unknown>>(): T;
     $getEnv(): Readonly<ExecutionEnv>;
+    /**
+     * The attempt this stage function runs in (P1b): `attempt` / `of`, the `signal` to pass to `fetch` and SDK
+     * calls (it aborts at the attempt's cap, the run's deadline, or a cancellation), and `timeLeftMs()` — the
+     * milliseconds before the run's deadline (`Infinity` without one; reading it with a deadline marks the stage's
+     * commit `untrackedSources: ['env']`). A stage with no retry policy and no deadline is attempt 1 of 1.
+     */
+    $attempt(): AttemptContext;
+    /**
+     * A call to an outside system, made inside this stage (P2): `fn` runs on the attempt runner under `policy`
+     * (none = ONE attempt — still recorded), and every attempt is an `AttemptRecord` of kind `'call'` on this
+     * stage's node and on `onAttempt`, with its timing, outcome, category and decision. It runs under this stage
+     * attempt's time and signal — pass `t.signal` on. `target` is a NAME from code (1–128 characters, no control
+     * character), never a value. A malformed call (target, `fn`, policy) or one from an attempt that already ended
+     * THROWS at the call, synchronously, like every scope refusal — it is the stage's code breaking its contract; a
+     * call that runs and fails REJECTS with its last attempt's own error. A call that changes an outside system
+     * declares it in `options` (`{ touches, idempotencyKey }`, P3): a touching call that may retry needs a key, every
+     * record carries its `effect`, and a call that ends without an answer after any attempt of unknown effect rejects
+     * with `UnknownEffectError`.
+     *
+     * ```typescript
+     * const quote = await scope.$call('stripe.quotes.create', (t) => stripe.quotes.create(body, { signal: t.signal }),
+     *   { attempts: 3, timeoutMs: 10_000 });
+     * ```
+     */
+    $call<R>(target: string, fn: (attempt: AttemptContext) => Promise<R> | R, policy?: RetryPolicy, options?: CallOptions): Promise<R>;
     $debug(key: string, value: unknown): void;
     $log(value: unknown): void;
     $error(key: string, value: unknown): void;
@@ -129,8 +161,8 @@ export interface ScopeMethods {
      * ```
      */
     $emit(name: string, payload?: unknown): void;
-    $detachAndJoinLater(driver: import('../detach/types.js').DetachDriver, child: import('../builder/types.js').FlowChart, input?: unknown): import('../detach/types.js').DetachHandle;
-    $detachAndForget(driver: import('../detach/types.js').DetachDriver, child: import('../builder/types.js').FlowChart, input?: unknown): void;
+    $detachAndJoinLater(driver: DetachDriver, child: FlowChart, input?: unknown): DetachHandle;
+    $detachAndForget(driver: DetachDriver, child: FlowChart, input?: unknown): void;
     /**
      * Stop the current execution context.
      *

package/dist/esm/lib/reactive/types.js

@@ -17,6 +17,8 @@ export const SCOPE_METHOD_NAMES = new Set([
     '$read',
     '$getArgs',
     '$getEnv',
+    '$attempt',
+    '$call',
     '$debug',
     '$log',
     '$error',
@@ -32,4 +34,4 @@ export const SCOPE_METHOD_NAMES = new Set([
     '$detachAndForget',
     '$toRaw',
 ]);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/reactive/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA+PH,+EAA+E;AAC/E,uEAAuE;AAEvE,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAS;IAChD,WAAW;IACX,WAAW;IACX,SAAS;IACT,SAAS;IACT,OAAO;IACP,UAAU;IACV,SAAS;IACT,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,sBAAsB;IACtB,sBAAsB;IACtB,oBAAoB;IACpB,aAAa;IACb,QAAQ;IACR,OAAO;IACP,qBAAqB;IACrB,kBAAkB;IAClB,QAAQ;CACT,CAAC,CAAC","sourcesContent":["/**\n * reactive/types -- Type definitions for the TypedScope<T> reactive proxy system.\n *\n * TypedScope<T> wraps a ReactiveTarget (ScopeFacade) in a Proxy that provides\n * typed property access. All scope infrastructure methods are $-prefixed to\n * avoid collisions with user state keys.\n *\n * Dependency: type-only imports from engine/ and scope/ (zero runtime cost).\n */\n\nimport type { ExecutionEnv } from '../engine/types.js';\nimport type { ScopeRecorder } from '../scope/types.js';\n\n// -- ReactiveTarget ----------------------------------------------------------\n// Minimum protocol required by TypedScope -- a curated subset of ScopeFacade's\n// public API. Not a full mirror: excludes internal/redaction methods that are\n// handled at the executor level (useRedactionPolicy, useSharedRedactedKeys, etc.)\n// and infrastructure methods (getPipelineId, setGlobal, getGlobal, etc.).\n\nexport interface ReactiveTarget {\n  // State access (tracked by recorders)\n  getValue(key?: string): unknown;\n  setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  updateValue(key: string, value: unknown, description?: string): void;\n  deleteValue(key: string, description?: string): void;\n\n  // Non-tracking state inspection (for proxy internals — no recorder dispatch)\n  /** Returns all state keys without firing onRead. Used by ownKeys/has traps. */\n  getStateKeys?(): string[];\n  /** Check key existence without firing onRead. Used by has trap. */\n  hasKey?(key: string): boolean;\n  /**\n   * Read state without firing onRead. Used by array proxy getCurrent() and,\n   * since 9.22.0, by every nested / element / terminal proxy's LIVE read\n   * (`liveView.ts`). A target without it falls back to the tracked read, so\n   * each nested access then fires onRead — provide it (ScopeFacade does).\n   */\n  getValueSilent?(key?: string): unknown;\n\n  // Input & environment (readonly, NOT tracked)\n  getArgs<T = Record<string, unknown>>(): T;\n  getEnv(): Readonly<ExecutionEnv>;\n\n  // ScopeRecorder management\n  attachScopeRecorder(recorder: ScopeRecorder): void;\n  detachScopeRecorder(recorderId: string): void;\n  getScopeRecorders(): ScopeRecorder[];\n\n  // Diagnostics\n  addDebugInfo(key: string, value: unknown): void;\n  addDebugMessage(value: unknown): void;\n  addErrorInfo(key: string, value: unknown): void;\n  addMetric(name: string, value: unknown): void;\n  addEval(name: string, value: unknown): void;\n\n  // Emit channel (Phase 3) — structured user-authored events to EmitRecorders.\n  emitEvent(name: string, payload?: unknown): void;\n\n  // Detach (T4) — fire-and-forget child flowcharts. ScopeFacade\n  // delegates to `detach/spawn`, minting refIds from this stage's\n  // runtimeStageId for diagnostic correlation.\n  detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle;\n\n  detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void;\n}\n\n// -- ScopeMethods ------------------------------------------------------------\n// $-prefixed escape hatches. Non-enumerable on the proxy -- don't appear in\n// Object.keys(), destructuring, or for...in. Only state keys are visible.\n\nexport interface ScopeMethods {\n  // State (untyped escape hatch -- for dynamic keys, redaction, description)\n  $getValue(key: string): unknown;\n  $setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  $update(key: string, value: unknown, description?: string): void;\n  $delete(key: string, description?: string): void;\n  /** Proxy-synthesized: calls getValue(rootKey) then walks the nested path (lodash.get-style, no lodash dep). Not a direct delegation. */\n  $read(dotPath: string): unknown;\n\n  // Input & environment (readonly)\n  $getArgs<T = Record<string, unknown>>(): T;\n  $getEnv(): Readonly<ExecutionEnv>;\n\n  // Observability — legacy diagnostic primitives.\n  //\n  // As of Phase 3 these ALSO dispatch on the emit channel (in addition to\n  // their existing `DiagnosticCollector` side-bag writes for snapshot\n  // inclusion). Any attached `EmitRecorder` will see these events with\n  // the corresponding namespaced names:\n  //\n  //   $debug(key, value)    -> emits `log.debug.${key}`\n  //   $error(key, value)    -> emits `log.error.${key}`\n  //   $metric(name, value)  -> emits `metric.${name}`\n  //   $eval (name, value)   -> emits `eval.${name}`\n  //   $log(value)           -> emits `log.debug.messages`\n  //\n  // This makes the calls observable in real time — no loss of backward\n  // compat; the side bag continues to populate for consumers that inspect\n  // the snapshot directly.\n  $debug(key: string, value: unknown): void;\n  $log(value: unknown): void;\n  $error(key: string, value: unknown): void;\n  $metric(name: string, value: unknown): void;\n  $eval(name: string, value: unknown): void;\n\n  // ScopeRecorder management\n  $attachScopeRecorder(recorder: ScopeRecorder): void;\n  $detachScopeRecorder(recorderId: string): void;\n  $getScopeRecorders(): ScopeRecorder[];\n\n  /**\n   * Batch-mutate an array key in a single clone+write cycle.\n   *\n   * Every `scope.items.push(x)` clones the entire array and commits it — O(N) per call.\n   * For N mutations on an M-length array that is O(N×M). Use `$batchArray` to clone once,\n   * apply all mutations inside `fn`, then commit once — O(M) total.\n   *\n   * ```typescript\n   * // Before: 1000 clones × growing array = O(N²)\n   * for (let i = 0; i < 1000; i++) scope.items.push(i);\n   *\n   * // After: 1 clone + 1 commit = O(N)\n   * scope.$batchArray('items', (arr) => {\n   *   for (let i = 0; i < 1000; i++) arr.push(i);\n   * });\n   * ```\n   *\n   * `fn` receives a plain (non-proxy) mutable **deep copy** (`structuredClone`) of the\n   * current array — \"clone once\" means the elements too. Mutating an element inside `fn`\n   * (`arr[0].n = 9`) changes the copy and lands in the one committed write; the value in\n   * state is never touched (9.22.0 — a shallow copy used to share the committed elements,\n   * so an element edit changed committed state in place with no trace row).\n   *\n   * Mutations inside `fn` are NOT tracked individually — only the final committed array\n   * appears in the narrative as a single write. If the key does not exist or is not an\n   * array, `fn` receives an empty array and the result is committed as the new value.\n   *\n   * If `fn` throws, `setValue` is never called and state remains unchanged (atomic on\n   * error). The exception propagates to the caller.\n   *\n   * `key` is untyped (`string`) — TypeScript will not catch typos. `arr` is typed as\n   * `unknown[]` because `ScopeMethods` is not parameterized by `T`; cast inside `fn`\n   * when element types are known: `(arr as string[]).push(x)`.\n   */\n  $batchArray(key: string, fn: (arr: unknown[]) => void): void;\n\n  // Observability — Emit channel (Phase 3)\n  /**\n   * Fire a structured event to every attached recorder implementing\n   * `onEmit`. The primary primitive for consumer-authored observability\n   * events (LLM tokens, billing metrics, domain milestones, etc.) that\n   * shouldn't live in scope state.\n   *\n   * Synchronous, pass-through — delivered to recorders immediately, in\n   * call order. Zero-allocation when no recorders are attached.\n   *\n   * ## Naming convention\n   *\n   * Use hierarchical dotted names: `'<namespace>.<category>.<event>'`.\n   * Examples:\n   *   - `'agentfootprint.llm.tokens'`\n   *   - `'myapp.billing.spend'`\n   *   - `'auth.check.denied'`\n   *\n   * The library stays vocabulary-agnostic — no central registry, no\n   * reserved prefixes. Namespace prefixes prevent collisions across\n   * libraries and apps naturally.\n   *\n   * ## Redaction\n   *\n   * If `RedactionPolicy.emitPatterns` matches the name, the payload is\n   * replaced with `'[REDACTED]'` before dispatch. No recorder ever sees\n   * the raw value for redacted event names.\n   *\n   * @param name - Consumer-chosen event identifier (see naming convention).\n   * @param payload - Structured data to attach. Shape is up to the\n   *   consumer; library treats it as opaque.\n   *\n   * @example\n   * ```typescript\n   * scope.$emit('agentfootprint.llm.tokens', { input: 100, output: 50 });\n   * scope.$emit('myapp.decision', { branch: 'approved', confidence: 0.92 });\n   * ```\n   */\n  $emit(name: string, payload?: unknown): void;\n\n  // Detach — fire-and-forget child flowchart execution.\n  //\n  // `$detachAndJoinLater(driver, child, input?)` schedules the child via\n  // the given driver and returns a `DetachHandle` the consumer can read\n  // synchronously (`.status`) or await (`.wait()`). The parent stage\n  // does NOT block on the child — it returns to the agent loop the\n  // moment the driver's `schedule()` returns (passive recorder rule).\n  //\n  // `$detachAndForget(driver, child, input?)` discards the handle —\n  // useful for fire-and-forget telemetry where the caller never needs\n  // to know how the child finished. Errors still land on the (now-\n  // dropped) handle and go silent unless an observer surfaces them.\n  //\n  // Driver is REQUIRED — there's no library-default. Pass e.g.\n  // `microtaskBatchDriver` (from 'footprintjs/detach') or your own\n  // custom driver. Explicit passing avoids global state and keeps the\n  // engine free of driver imports.\n  $detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle;\n\n  $detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void;\n\n  // Pipeline control\n  /**\n   * Stop the current execution context.\n   *\n   * - **In a top-level chart:** the traverser exits cleanly after this stage\n   *   completes.\n   * - **Inside a subflow:** by default, only the subflow's own execution\n   *   stops; control returns to the parent as normal. If the subflow is\n   *   mounted with `propagateBreak: true`, the break signal (and its\n   *   optional reason) propagates up to the parent scope, terminating the\n   *   outer loop too. See `SubflowMountOptions.propagateBreak`.\n   *\n   * @param reason - Optional free-form string describing why the break\n   *   happened. Propagates to `FlowBreakEvent.reason` so recorders and\n   *   custom narratives can surface it. Defaults to undefined.\n   */\n  $break(reason?: string): void;\n\n  // Escape hatch -- unwrap to underlying ReactiveTarget\n  $toRaw(): ReactiveTarget;\n}\n\n// -- TypedScope<T> -----------------------------------------------------------\n// The consumer-facing type. T is the user's state interface.\n// Property access is typed; $-methods provide escape hatches.\n\nexport type TypedScope<T extends object = Record<string, unknown>> = T & ScopeMethods;\n\n// -- ReactiveOptions ---------------------------------------------------------\n// Configuration passed to createTypedScope.\n\nexport interface ReactiveOptions {\n  /**\n   * Pipeline break function — injected by StageRunner after scope creation.\n   * Accepts an optional reason string that propagates to `FlowBreakEvent`\n   * and (when `propagateBreak` is set on a mount) up to the parent scope.\n   */\n  breakPipeline?: (reason?: string) => void;\n}\n\n// -- Internal: $-method name set ---------------------------------------------\n// Used by the Proxy get trap to distinguish $-methods from state keys.\n\nexport const SCOPE_METHOD_NAMES = new Set<string>([\n  '$getValue',\n  '$setValue',\n  '$update',\n  '$delete',\n  '$read',\n  '$getArgs',\n  '$getEnv',\n  '$debug',\n  '$log',\n  '$error',\n  '$metric',\n  '$eval',\n  '$attachScopeRecorder',\n  '$detachScopeRecorder',\n  '$getScopeRecorders',\n  '$batchArray',\n  '$break',\n  '$emit',\n  '$detachAndJoinLater',\n  '$detachAndForget',\n  '$toRaw',\n]);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/reactive/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAyRH,+EAA+E;AAC/E,uEAAuE;AAEvE,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAS;IAChD,WAAW;IACX,WAAW;IACX,SAAS;IACT,SAAS;IACT,OAAO;IACP,UAAU;IACV,SAAS;IACT,UAAU;IACV,OAAO;IACP,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,sBAAsB;IACtB,sBAAsB;IACtB,oBAAoB;IACpB,aAAa;IACb,QAAQ;IACR,OAAO;IACP,qBAAqB;IACrB,kBAAkB;IAClB,QAAQ;CACT,CAAC,CAAC","sourcesContent":["/**\n * reactive/types -- Type definitions for the TypedScope<T> reactive proxy system.\n *\n * TypedScope<T> wraps a ReactiveTarget (ScopeFacade) in a Proxy that provides\n * typed property access. All scope infrastructure methods are $-prefixed to\n * avoid collisions with user state keys.\n *\n * Dependency: type-only imports from engine/ and scope/ (zero runtime cost).\n */\n\nimport type { AttemptContext, CallOptions, RetryPolicy } from '../attempt/types.js';\nimport type { FlowChart } from '../builder/types.js';\nimport type { DetachDriver, DetachHandle } from '../detach/types.js';\nimport type { ExecutionEnv } from '../engine/types.js';\nimport type { ScopeRecorder } from '../scope/types.js';\n\n// -- ReactiveTarget ----------------------------------------------------------\n// Minimum protocol required by TypedScope -- a curated subset of ScopeFacade's\n// public API. Not a full mirror: excludes internal/redaction methods that are\n// handled at the executor level (useRedactionPolicy, useSharedRedactedKeys, etc.)\n// and infrastructure methods (getPipelineId, setGlobal, getGlobal, etc.).\n\nexport interface ReactiveTarget {\n  // State access (tracked by recorders)\n  getValue(key?: string): unknown;\n  setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  updateValue(key: string, value: unknown, description?: string): void;\n  deleteValue(key: string, description?: string): void;\n\n  // Non-tracking state inspection (for proxy internals — no recorder dispatch)\n  /** Returns all state keys without firing onRead. Used by ownKeys/has traps. */\n  getStateKeys?(): string[];\n  /** Check key existence without firing onRead. Used by has trap. */\n  hasKey?(key: string): boolean;\n  /**\n   * Read state without firing onRead. Used by array proxy getCurrent() and,\n   * since 9.22.0, by every nested / element / terminal proxy's LIVE read\n   * (`liveView.ts`). A target without it falls back to the tracked read, so\n   * each nested access then fires onRead — provide it (ScopeFacade does).\n   */\n  getValueSilent?(key?: string): unknown;\n\n  // Input & environment (readonly, NOT tracked)\n  getArgs<T = Record<string, unknown>>(): T;\n  getEnv(): Readonly<ExecutionEnv>;\n  /** The attempt the stage function runs in — its signal, its cap and the time left (P1b). */\n  getAttempt(): AttemptContext;\n  /** A call to an outside system on the attempt runner, recorded under this stage (P2). */\n  call<R>(\n    target: string,\n    fn: (attempt: AttemptContext) => Promise<R> | R,\n    policy?: RetryPolicy,\n    options?: CallOptions,\n  ): Promise<R>;\n\n  // ScopeRecorder management\n  attachScopeRecorder(recorder: ScopeRecorder): void;\n  detachScopeRecorder(recorderId: string): void;\n  getScopeRecorders(): ScopeRecorder[];\n\n  // Diagnostics\n  addDebugInfo(key: string, value: unknown): void;\n  addDebugMessage(value: unknown): void;\n  addErrorInfo(key: string, value: unknown): void;\n  addMetric(name: string, value: unknown): void;\n  addEval(name: string, value: unknown): void;\n\n  // Emit channel (Phase 3) — structured user-authored events to EmitRecorders.\n  emitEvent(name: string, payload?: unknown): void;\n\n  // Detach (T4) — fire-and-forget child flowcharts. ScopeFacade\n  // delegates to `detach/spawn`, minting refIds from this stage's\n  // runtimeStageId for diagnostic correlation.\n  detachAndJoinLater(driver: DetachDriver, child: FlowChart, input?: unknown): DetachHandle;\n\n  detachAndForget(driver: DetachDriver, child: FlowChart, input?: unknown): void;\n}\n\n// -- ScopeMethods ------------------------------------------------------------\n// $-prefixed escape hatches. Non-enumerable on the proxy -- don't appear in\n// Object.keys(), destructuring, or for...in. Only state keys are visible.\n\nexport interface ScopeMethods {\n  // State (untyped escape hatch -- for dynamic keys, redaction, description)\n  $getValue(key: string): unknown;\n  $setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  $update(key: string, value: unknown, description?: string): void;\n  $delete(key: string, description?: string): void;\n  /** Proxy-synthesized: calls getValue(rootKey) then walks the nested path (lodash.get-style, no lodash dep). Not a direct delegation. */\n  $read(dotPath: string): unknown;\n\n  // Input & environment (readonly)\n  $getArgs<T = Record<string, unknown>>(): T;\n  $getEnv(): Readonly<ExecutionEnv>;\n  /**\n   * The attempt this stage function runs in (P1b): `attempt` / `of`, the `signal` to pass to `fetch` and SDK\n   * calls (it aborts at the attempt's cap, the run's deadline, or a cancellation), and `timeLeftMs()` — the\n   * milliseconds before the run's deadline (`Infinity` without one; reading it with a deadline marks the stage's\n   * commit `untrackedSources: ['env']`). A stage with no retry policy and no deadline is attempt 1 of 1.\n   */\n  $attempt(): AttemptContext;\n  /**\n   * A call to an outside system, made inside this stage (P2): `fn` runs on the attempt runner under `policy`\n   * (none = ONE attempt — still recorded), and every attempt is an `AttemptRecord` of kind `'call'` on this\n   * stage's node and on `onAttempt`, with its timing, outcome, category and decision. It runs under this stage\n   * attempt's time and signal — pass `t.signal` on. `target` is a NAME from code (1–128 characters, no control\n   * character), never a value. A malformed call (target, `fn`, policy) or one from an attempt that already ended\n   * THROWS at the call, synchronously, like every scope refusal — it is the stage's code breaking its contract; a\n   * call that runs and fails REJECTS with its last attempt's own error. A call that changes an outside system\n   * declares it in `options` (`{ touches, idempotencyKey }`, P3): a touching call that may retry needs a key, every\n   * record carries its `effect`, and a call that ends without an answer after any attempt of unknown effect rejects\n   * with `UnknownEffectError`.\n   *\n   * ```typescript\n   * const quote = await scope.$call('stripe.quotes.create', (t) => stripe.quotes.create(body, { signal: t.signal }),\n   *   { attempts: 3, timeoutMs: 10_000 });\n   * ```\n   */\n  $call<R>(\n    target: string,\n    fn: (attempt: AttemptContext) => Promise<R> | R,\n    policy?: RetryPolicy,\n    options?: CallOptions,\n  ): Promise<R>;\n\n  // Observability — legacy diagnostic primitives.\n  //\n  // As of Phase 3 these ALSO dispatch on the emit channel (in addition to\n  // their existing `DiagnosticCollector` side-bag writes for snapshot\n  // inclusion). Any attached `EmitRecorder` will see these events with\n  // the corresponding namespaced names:\n  //\n  //   $debug(key, value)    -> emits `log.debug.${key}`\n  //   $error(key, value)    -> emits `log.error.${key}`\n  //   $metric(name, value)  -> emits `metric.${name}`\n  //   $eval (name, value)   -> emits `eval.${name}`\n  //   $log(value)           -> emits `log.debug.messages`\n  //\n  // This makes the calls observable in real time — no loss of backward\n  // compat; the side bag continues to populate for consumers that inspect\n  // the snapshot directly.\n  $debug(key: string, value: unknown): void;\n  $log(value: unknown): void;\n  $error(key: string, value: unknown): void;\n  $metric(name: string, value: unknown): void;\n  $eval(name: string, value: unknown): void;\n\n  // ScopeRecorder management\n  $attachScopeRecorder(recorder: ScopeRecorder): void;\n  $detachScopeRecorder(recorderId: string): void;\n  $getScopeRecorders(): ScopeRecorder[];\n\n  /**\n   * Batch-mutate an array key in a single clone+write cycle.\n   *\n   * Every `scope.items.push(x)` clones the entire array and commits it — O(N) per call.\n   * For N mutations on an M-length array that is O(N×M). Use `$batchArray` to clone once,\n   * apply all mutations inside `fn`, then commit once — O(M) total.\n   *\n   * ```typescript\n   * // Before: 1000 clones × growing array = O(N²)\n   * for (let i = 0; i < 1000; i++) scope.items.push(i);\n   *\n   * // After: 1 clone + 1 commit = O(N)\n   * scope.$batchArray('items', (arr) => {\n   *   for (let i = 0; i < 1000; i++) arr.push(i);\n   * });\n   * ```\n   *\n   * `fn` receives a plain (non-proxy) mutable **deep copy** (`structuredClone`) of the\n   * current array — \"clone once\" means the elements too. Mutating an element inside `fn`\n   * (`arr[0].n = 9`) changes the copy and lands in the one committed write; the value in\n   * state is never touched (9.22.0 — a shallow copy used to share the committed elements,\n   * so an element edit changed committed state in place with no trace row).\n   *\n   * Mutations inside `fn` are NOT tracked individually — only the final committed array\n   * appears in the narrative as a single write. If the key does not exist or is not an\n   * array, `fn` receives an empty array and the result is committed as the new value.\n   *\n   * If `fn` throws, `setValue` is never called and state remains unchanged (atomic on\n   * error). The exception propagates to the caller.\n   *\n   * `key` is untyped (`string`) — TypeScript will not catch typos. `arr` is typed as\n   * `unknown[]` because `ScopeMethods` is not parameterized by `T`; cast inside `fn`\n   * when element types are known: `(arr as string[]).push(x)`.\n   */\n  $batchArray(key: string, fn: (arr: unknown[]) => void): void;\n\n  // Observability — Emit channel (Phase 3)\n  /**\n   * Fire a structured event to every attached recorder implementing\n   * `onEmit`. The primary primitive for consumer-authored observability\n   * events (LLM tokens, billing metrics, domain milestones, etc.) that\n   * shouldn't live in scope state.\n   *\n   * Synchronous, pass-through — delivered to recorders immediately, in\n   * call order. Zero-allocation when no recorders are attached.\n   *\n   * ## Naming convention\n   *\n   * Use hierarchical dotted names: `'<namespace>.<category>.<event>'`.\n   * Examples:\n   *   - `'agentfootprint.llm.tokens'`\n   *   - `'myapp.billing.spend'`\n   *   - `'auth.check.denied'`\n   *\n   * The library stays vocabulary-agnostic — no central registry, no\n   * reserved prefixes. Namespace prefixes prevent collisions across\n   * libraries and apps naturally.\n   *\n   * ## Redaction\n   *\n   * If `RedactionPolicy.emitPatterns` matches the name, the payload is\n   * replaced with `'[REDACTED]'` before dispatch. No recorder ever sees\n   * the raw value for redacted event names.\n   *\n   * @param name - Consumer-chosen event identifier (see naming convention).\n   * @param payload - Structured data to attach. Shape is up to the\n   *   consumer; library treats it as opaque.\n   *\n   * @example\n   * ```typescript\n   * scope.$emit('agentfootprint.llm.tokens', { input: 100, output: 50 });\n   * scope.$emit('myapp.decision', { branch: 'approved', confidence: 0.92 });\n   * ```\n   */\n  $emit(name: string, payload?: unknown): void;\n\n  // Detach — fire-and-forget child flowchart execution.\n  //\n  // `$detachAndJoinLater(driver, child, input?)` schedules the child via\n  // the given driver and returns a `DetachHandle` the consumer can read\n  // synchronously (`.status`) or await (`.wait()`). The parent stage\n  // does NOT block on the child — it returns to the agent loop the\n  // moment the driver's `schedule()` returns (passive recorder rule).\n  //\n  // `$detachAndForget(driver, child, input?)` discards the handle —\n  // useful for fire-and-forget telemetry where the caller never needs\n  // to know how the child finished. Errors still land on the (now-\n  // dropped) handle and go silent unless an observer surfaces them.\n  //\n  // Driver is REQUIRED — there's no library-default. Pass e.g.\n  // `microtaskBatchDriver` (from 'footprintjs/detach') or your own\n  // custom driver. Explicit passing avoids global state and keeps the\n  // engine free of driver imports.\n  $detachAndJoinLater(driver: DetachDriver, child: FlowChart, input?: unknown): DetachHandle;\n\n  $detachAndForget(driver: DetachDriver, child: FlowChart, input?: unknown): void;\n\n  // Pipeline control\n  /**\n   * Stop the current execution context.\n   *\n   * - **In a top-level chart:** the traverser exits cleanly after this stage\n   *   completes.\n   * - **Inside a subflow:** by default, only the subflow's own execution\n   *   stops; control returns to the parent as normal. If the subflow is\n   *   mounted with `propagateBreak: true`, the break signal (and its\n   *   optional reason) propagates up to the parent scope, terminating the\n   *   outer loop too. See `SubflowMountOptions.propagateBreak`.\n   *\n   * @param reason - Optional free-form string describing why the break\n   *   happened. Propagates to `FlowBreakEvent.reason` so recorders and\n   *   custom narratives can surface it. Defaults to undefined.\n   */\n  $break(reason?: string): void;\n\n  // Escape hatch -- unwrap to underlying ReactiveTarget\n  $toRaw(): ReactiveTarget;\n}\n\n// -- TypedScope<T> -----------------------------------------------------------\n// The consumer-facing type. T is the user's state interface.\n// Property access is typed; $-methods provide escape hatches.\n\nexport type TypedScope<T extends object = Record<string, unknown>> = T & ScopeMethods;\n\n// -- ReactiveOptions ---------------------------------------------------------\n// Configuration passed to createTypedScope.\n\nexport interface ReactiveOptions {\n  /**\n   * Pipeline break function — injected by StageRunner after scope creation.\n   * Accepts an optional reason string that propagates to `FlowBreakEvent`\n   * and (when `propagateBreak` is set on a mount) up to the parent scope.\n   */\n  breakPipeline?: (reason?: string) => void;\n}\n\n// -- Internal: $-method name set ---------------------------------------------\n// Used by the Proxy get trap to distinguish $-methods from state keys.\n\nexport const SCOPE_METHOD_NAMES = new Set<string>([\n  '$getValue',\n  '$setValue',\n  '$update',\n  '$delete',\n  '$read',\n  '$getArgs',\n  '$getEnv',\n  '$attempt',\n  '$call',\n  '$debug',\n  '$log',\n  '$error',\n  '$metric',\n  '$eval',\n  '$attachScopeRecorder',\n  '$detachScopeRecorder',\n  '$getScopeRecorders',\n  '$batchArray',\n  '$break',\n  '$emit',\n  '$detachAndJoinLater',\n  '$detachAndForget',\n  '$toRaw',\n]);\n"]}

package/dist/esm/lib/recorder/AttemptRecorder.d.ts

@@ -0,0 +1,141 @@
+import type { FlowAttemptEvent, FlowDecisionEvent, FlowPauseEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent } from '../engine/narrative/types.js';
+import type { AttemptAggregate, AttemptDecisionRow, AttemptQuery, AttemptRecorderOptions, AttemptStorageStats, AttemptStore, PhysicalAttemptRow } from './attemptMetricsTypes.js';
+export declare class AttemptRecorder implements FlowRecorder {
+    readonly id: string;
+    private readonly rows;
+    private readonly logical;
+    private readonly starts;
+    private reads;
+    private readonly pending;
+    private readonly exemplars;
+    private readonly maxRows;
+    private readonly maxPending;
+    private readonly timeoutMs;
+    private readonly store?;
+    private failed;
+    private dropped;
+    private omittedRows;
+    constructor(options?: AttemptRecorderOptions);
+    onRunStart(event: FlowRunEvent): void;
+    onRunEnd(event: FlowRunEvent): void;
+    onPause(event: FlowPauseEvent): void;
+    onRunFailed(event: FlowRunFailedEvent): void;
+    private end;
+    onAttempt(event: FlowAttemptEvent): void;
+    onDecision(event: FlowDecisionEvent): void;
+    private collect;
+    storage(): AttemptStorageStats;
+    flush(): Promise<AttemptStorageStats>;
+    byTarget(): AttemptAggregate['byTarget'];
+    byRun(): AttemptAggregate['byRun'];
+    slowest(target: string, limit?: number): import("./attemptMetricsTypes.js").AttemptMetricRef[];
+    series(series: string, runId?: string): {
+        attempts: PhysicalAttemptRow[];
+        decisions: AttemptDecisionRow[];
+    };
+    aggregate(supplied?: AttemptQuery): Promise<AttemptAggregate>;
+    private readStored;
+    toSnapshot(): {
+        name: string;
+        data: {
+            byTarget: Map<string, import("./attemptMetricsTypes.js").AttemptStats>;
+            byRun: Map<string, import("./attemptMetricsTypes.js").AttemptRunStats>;
+        };
+        meta: {
+            projection: string;
+            exemplars: number;
+            rows: number;
+            maxRows: number;
+            storage: AttemptStorageStats;
+            workTime: string;
+        };
+    };
+    toOTel(): {
+        resourceMetrics: {
+            resource: {
+                attributes: never[];
+            };
+            scopeMetrics: {
+                scope: {
+                    name: string;
+                };
+                metrics: ({
+                    name: string;
+                    unit: string;
+                    description: string;
+                    histogram: {
+                        aggregationTemporality: number;
+                        dataPoints: {
+                            attributes: {
+                                key: string;
+                                value: {
+                                    stringValue: string;
+                                };
+                            }[];
+                            startTimeUnixNano: string;
+                            timeUnixNano: string;
+                            count: string;
+                            sum: number;
+                            explicitBounds: number[];
+                            bucketCounts: string[];
+                            exemplars: {
+                                traceId?: string | undefined;
+                                asDouble: number;
+                                timeUnixNano: string;
+                                filteredAttributes: {
+                                    key: string;
+                                    value: {
+                                        stringValue: string;
+                                    };
+                                }[];
+                            }[];
+                        }[];
+                    };
+                    sum?: undefined;
+                } | {
+                    name: string;
+                    unit: string;
+                    sum: {
+                        aggregationTemporality: number;
+                        isMonotonic: boolean;
+                        dataPoints: {
+                            attributes: {
+                                key: string;
+                                value: {
+                                    stringValue: string;
+                                };
+                            }[];
+                            startTimeUnixNano: string;
+                            timeUnixNano: string;
+                            asDouble: number;
+                            exemplars: {
+                                asDouble: number;
+                                traceId?: string | undefined;
+                                timeUnixNano: string;
+                                filteredAttributes: {
+                                    key: string;
+                                    value: {
+                                        stringValue: string;
+                                    };
+                                }[];
+                            }[];
+                        }[];
+                    };
+                    description?: undefined;
+                    histogram?: undefined;
+                })[];
+            }[];
+        }[];
+    };
+    /** Clear completed local projections; active/paused evidence and bounded ownership survive executor auto-clear. */
+    clear(): void;
+}
+/** Bounded reference adapter for tests/local use; apps supply their own database adapter. */
+export declare function memoryStore(options?: {
+    readonly maxRows?: number;
+}): AttemptStore & {
+    stats(): {
+        rows: number;
+        omittedRows: number;
+    };
+};