footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/scope/recorders/DebugRecorder.d.ts

@@ -1,14 +1,27 @@
 /**
  * DebugRecorder — Development-focused recorder for detailed debugging
  *
- * Captures errors (always), mutations and reads (in verbose mode),
- * and stage lifecycle events for troubleshooting.
+ * Captures errors (always — a scope recorder's own failure, the scope
+ * channel's `onError`; a stage's failure is not one), mutations and reads
+ * (in verbose mode), and stage lifecycle events for troubleshooting.
+ *
+ * Attempts (10.1): one `attempt` row per attempt of a series that retried,
+ * gave up or timed out (`recorder/attemptSeries.ts · isRetryEvidence`) — its
+ * outcome, category, duration, decision, the cap and time left it ran under
+ * (present with a cap or a deadline) and served error — and one `attemptStop`
+ * row when the series gave up (exhausted, declined, no time left). Both verbosities: like a
+ * pause, an attempt is significant — and for a retried stage these rows are
+ * the failure evidence (a stage's error is never an `error` row). They arrive on the FLOW channel
+ * (`onAttempt`), so attach with `attachCombinedRecorder` to see them; the
+ * flow channel's own `onError` / `onPause` / `onResume` are ignored, so a
+ * combined attach never doubles a scope row.
  */
+import type { FlowAttemptEvent } from '../../engine/narrative/types.js';
 import type { RecorderOperation } from '../../recorder/RecorderOperation.js';
 import type { ErrorEvent, PauseEvent, ReadEvent, ResumeEvent, ScopeRecorder, StageEvent, WriteEvent } from '../types.js';
 export type DebugVerbosity = 'minimal' | 'verbose';
 export interface DebugEntry {
-    type: 'read' | 'write' | 'error' | 'stageStart' | 'stageEnd' | 'pause' | 'resume';
+    type: 'read' | 'write' | 'error' | 'stageStart' | 'stageEnd' | 'pause' | 'resume' | 'attempt' | 'attemptStop';
     stageName: string;
     timestamp: number;
     data: unknown;
@@ -48,6 +61,7 @@ export declare class DebugRecorder implements ScopeRecorder {
     onStageEnd(event: StageEvent): void;
     onPause(event: PauseEvent): void;
     onResume(event: ResumeEvent): void;
+    onAttempt(event: FlowAttemptEvent): void;
     getEntries(): DebugEntry[];
     getErrors(): DebugEntry[];
     getEntriesForStage(stageName: string): DebugEntry[];

package/dist/esm/lib/scope/recorders/DebugRecorder.js

@@ -1,9 +1,22 @@
 /**
  * DebugRecorder — Development-focused recorder for detailed debugging
  *
- * Captures errors (always), mutations and reads (in verbose mode),
- * and stage lifecycle events for troubleshooting.
+ * Captures errors (always — a scope recorder's own failure, the scope
+ * channel's `onError`; a stage's failure is not one), mutations and reads
+ * (in verbose mode), and stage lifecycle events for troubleshooting.
+ *
+ * Attempts (10.1): one `attempt` row per attempt of a series that retried,
+ * gave up or timed out (`recorder/attemptSeries.ts · isRetryEvidence`) — its
+ * outcome, category, duration, decision, the cap and time left it ran under
+ * (present with a cap or a deadline) and served error — and one `attemptStop`
+ * row when the series gave up (exhausted, declined, no time left). Both verbosities: like a
+ * pause, an attempt is significant — and for a retried stage these rows are
+ * the failure evidence (a stage's error is never an `error` row). They arrive on the FLOW channel
+ * (`onAttempt`), so attach with `attachCombinedRecorder` to see them; the
+ * flow channel's own `onError` / `onPause` / `onResume` are ignored, so a
+ * combined attach never doubles a scope row.
  */
+import { gaveUp, isRetryEvidence } from '../../recorder/attemptSeries.js';
 /**
  * Each instance gets a unique auto-increment ID (`debug-1`, `debug-2`, ...),
  * so multiple recorders with different verbosity coexist.
@@ -51,16 +64,9 @@ export class DebugRecorder {
         });
     }
     onError(event) {
-        // The structured fields only — never `raw` (the thrown value itself, which
-        // may be a function, a Proxy or a cycle), so a snapshot row always
-        // survives `structuredClone` (9.39.0).
-        const { message, name, code, issues } = event.error;
-        const error = {
-            message,
-            ...(name !== undefined && { name }),
-            ...(code !== undefined && { code }),
-            ...(issues !== undefined && { issues }),
-        };
+        if (fromFlowChannel(event))
+            return;
+        const error = debugError(event.error);
         this.entries.push({
             type: 'error',
             stageName: event.stageName,
@@ -89,6 +95,8 @@ export class DebugRecorder {
         });
     }
     onPause(event) {
+        if (fromFlowChannel(event))
+            return;
         // Always log pauses (even in minimal mode — pauses are significant events)
         this.entries.push({
             type: 'pause',
@@ -98,6 +106,8 @@ export class DebugRecorder {
         });
     }
     onResume(event) {
+        if (fromFlowChannel(event))
+            return;
         // Always log resumes (even in minimal mode)
         this.entries.push({
             type: 'resume',
@@ -106,6 +116,44 @@ export class DebugRecorder {
             data: { stageId: event.stageId, hasInput: event.hasInput, pipelineId: event.pipelineId },
         });
     }
+    onAttempt(event) {
+        const { record } = event;
+        if (!isRetryEvidence(record))
+            return;
+        const timestamp = record.startedAt + record.durationMs;
+        const name = { stageId: event.stageId, series: record.series, attempt: record.attempt, of: record.of };
+        this.entries.push({
+            type: 'attempt',
+            stageName: event.stageName,
+            timestamp,
+            data: {
+                ...name,
+                outcome: record.outcome,
+                ...(record.category !== undefined && { category: record.category }),
+                durationMs: record.durationMs,
+                next: record.next,
+                reason: record.reason,
+                ...(record.retryOnThrew && { retryOnThrew: true }),
+                ...(record.delayMs !== undefined && { delayMs: record.delayMs }),
+                ...(record.timeoutMs !== undefined && { timeoutMs: record.timeoutMs }),
+                ...(record.timeLeftMs !== undefined && { timeLeftMs: record.timeLeftMs }),
+                ...(record.error !== undefined && { error: debugError(record.error) }),
+            },
+        });
+        if (!gaveUp(record))
+            return;
+        this.entries.push({
+            type: 'attemptStop',
+            stageName: event.stageName,
+            timestamp,
+            data: {
+                ...name,
+                reason: record.reason,
+                ...(record.category !== undefined && { category: record.category }),
+                ...(record.retryOnThrew && { retryOnThrew: true }),
+            },
+        });
+    }
     getEntries() {
         return [...this.entries];
     }
@@ -133,4 +181,22 @@ export class DebugRecorder {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DebugRecorder.js","sourceRoot":"","sources":["../../../../../src/lib/scope/recorders/DebugRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DebugRecorder — Development-focused recorder for detailed debugging\n *\n * Captures errors (always), mutations and reads (in verbose mode),\n * and stage lifecycle events for troubleshooting.\n */\n\nimport type { RecorderOperation } from '../../recorder/RecorderOperation.js';\nimport type {\n  ErrorEvent,\n  PauseEvent,\n  ReadEvent,\n  ResumeEvent,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from '../types.js';\n\nexport type DebugVerbosity = 'minimal' | 'verbose';\n\nexport interface DebugEntry {\n  type: 'read' | 'write' | 'error' | 'stageStart' | 'stageEnd' | 'pause' | 'resume';\n  stageName: string;\n  timestamp: number;\n  data: unknown;\n}\n\nexport interface DebugRecorderOptions {\n  id?: string;\n  verbosity?: DebugVerbosity;\n  /** Preferred UI operation. Defaults to 'translate' (per-step diagnostic detail). */\n  preferredOperation?: RecorderOperation;\n}\n\n/**\n * Each instance gets a unique auto-increment ID (`debug-1`, `debug-2`, ...),\n * so multiple recorders with different verbosity coexist.\n *\n * @example\n * ```typescript\n * // Verbose debug for development\n * executor.attachScopeRecorder(new DebugRecorder({ verbosity: 'verbose' }));\n *\n * // Minimal debug for production (errors only)\n * executor.attachScopeRecorder(new DebugRecorder({ verbosity: 'minimal' }));\n *\n * // Both coexist — different auto IDs\n * ```\n */\nexport class DebugRecorder implements ScopeRecorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  private entries: DebugEntry[] = [];\n  private verbosity: DebugVerbosity;\n\n  constructor(options?: DebugRecorderOptions) {\n    this.id = options?.id ?? `debug-${++DebugRecorder._counter}`;\n    this.verbosity = options?.verbosity ?? 'verbose';\n    this.preferredOperation = options?.preferredOperation ?? 'translate';\n  }\n\n  onRead(event: ReadEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'read',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { key: event.key, value: event.value, pipelineId: event.pipelineId },\n    });\n  }\n\n  onWrite(event: WriteEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'write',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { key: event.key, value: event.value, operation: event.operation, pipelineId: event.pipelineId },\n    });\n  }\n\n  onError(event: ErrorEvent): void {\n    // The structured fields only — never `raw` (the thrown value itself, which\n    // may be a function, a Proxy or a cycle), so a snapshot row always\n    // survives `structuredClone` (9.39.0).\n    const { message, name, code, issues } = event.error;\n    const error = {\n      message,\n      ...(name !== undefined && { name }),\n      ...(code !== undefined && { code }),\n      ...(issues !== undefined && { issues }),\n    };\n    this.entries.push({\n      type: 'error',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { error, operation: event.operation, key: event.key, pipelineId: event.pipelineId },\n    });\n  }\n\n  onStageStart(event: StageEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'stageStart',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { pipelineId: event.pipelineId },\n    });\n  }\n\n  onStageEnd(event: StageEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'stageEnd',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { pipelineId: event.pipelineId, duration: event.duration },\n    });\n  }\n\n  onPause(event: PauseEvent): void {\n    // Always log pauses (even in minimal mode — pauses are significant events)\n    this.entries.push({\n      type: 'pause',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { stageId: event.stageId, pauseData: event.pauseData, pipelineId: event.pipelineId },\n    });\n  }\n\n  onResume(event: ResumeEvent): void {\n    // Always log resumes (even in minimal mode)\n    this.entries.push({\n      type: 'resume',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { stageId: event.stageId, hasInput: event.hasInput, pipelineId: event.pipelineId },\n    });\n  }\n\n  getEntries(): DebugEntry[] {\n    return [...this.entries];\n  }\n\n  getErrors(): DebugEntry[] {\n    return this.entries.filter((e) => e.type === 'error');\n  }\n\n  getEntriesForStage(stageName: string): DebugEntry[] {\n    return this.entries.filter((e) => e.stageName === stageName);\n  }\n\n  setVerbosity(level: DebugVerbosity): void {\n    this.verbosity = level;\n  }\n\n  getVerbosity(): DebugVerbosity {\n    return this.verbosity;\n  }\n\n  clear(): void {\n    this.entries = [];\n  }\n\n  toSnapshot() {\n    return {\n      name: 'Debug',\n      description: 'Translator (Scope ScopeRecorder) — per-stage diagnostic entries',\n      preferredOperation: this.preferredOperation,\n      data: this.entries,\n    };\n  }\n}\n"]}
+/**
+ * The structured fields only — never `raw` (the thrown value itself, which may be a function, a Proxy or a cycle),
+ * so a snapshot row always survives `structuredClone` (9.39.0). An attempt's error is already the served form
+ * (`AttemptRecord.error`, the run's redaction rule applied), so a redacted stage error reads redacted here too.
+ */
+function debugError(info) {
+    const { message, name, code, issues } = info;
+    return {
+        message,
+        ...(name !== undefined && { name }),
+        ...(code !== undefined && { code }),
+        ...(issues !== undefined && { issues }),
+    };
+}
+/** A shared-name hook (`onError` / `onPause` / `onResume`) delivered on the flow channel of a combined attach. */
+function fromFlowChannel(event) {
+    return event.channel === 'flow';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DebugRecorder.js","sourceRoot":"","sources":["../../../../../src/lib/scope/recorders/DebugRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AA4B1E;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,aAAa;IAChB,MAAM,CAAC,QAAQ,GAAG,CAAC,CAAC;IAEnB,EAAE,CAAS;IACX,kBAAkB,CAAoB;IACvC,OAAO,GAAiB,EAAE,CAAC;IAC3B,SAAS,CAAiB;IAElC,YAAY,OAA8B;QACxC,IAAI,CAAC,EAAE,GAAG,OAAO,EAAE,EAAE,IAAI,SAAS,EAAE,aAAa,CAAC,QAAQ,EAAE,CAAC;QAC7D,IAAI,CAAC,SAAS,GAAG,OAAO,EAAE,SAAS,IAAI,SAAS,CAAC;QACjD,IAAI,CAAC,kBAAkB,GAAG,OAAO,EAAE,kBAAkB,IAAI,WAAW,CAAC;IACvE,CAAC;IAED,MAAM,CAAC,KAAgB;QACrB,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO;QACzC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,MAAM;YACZ,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;SAC3E,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO;QACzC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,OAAO;YACb,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;SACvG,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,IAAI,eAAe,CAAC,KAAK,CAAC;YAAE,OAAO;QACnC,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,OAAO;YACb,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;SAC1F,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CAAC,KAAiB;QAC5B,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO;QACzC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,YAAY;YAClB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;SACvC,CAAC,CAAC;IACL,CAAC;IAED,UAAU,CAAC,KAAiB;QAC1B,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO;QACzC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE;SACjE,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,IAAI,eAAe,CAAC,KAAK,CAAC;YAAE,OAAO;QACnC,2EAA2E;QAC3E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,OAAO;YACb,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;SAC3F,CAAC,CAAC;IACL,CAAC;IAED,QAAQ,CAAC,KAAkB;QACzB,IAAI,eAAe,CAAC,KAAK,CAAC;YAAE,OAAO;QACnC,4CAA4C;QAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,QAAQ;YACd,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;SACzF,CAAC,CAAC;IACL,CAAC;IAED,SAAS,CAAC,KAAuB;QAC/B,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;YAAE,OAAO;QACrC,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC;QACvD,MAAM,IAAI,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QACvG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,SAAS;YACf,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS;YACT,IAAI,EAAE;gBACJ,GAAG,IAAI;gBACP,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACnE,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,GAAG,CAAC,MAAM,CAAC,YAAY,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;gBAClD,GAAG,CAAC,MAAM,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;gBAChE,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC;gBACtE,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC;gBACzE,GAAG,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aACvE;SACF,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;YAAE,OAAO;QAC5B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,aAAa;YACnB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS;YACT,IAAI,EAAE;gBACJ,GAAG,IAAI;gBACP,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACnE,GAAG,CAAC,MAAM,CAAC,YAAY,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;aACnD;SACF,CAAC,CAAC;IACL,CAAC;IAED,UAAU;QACR,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;IACxD,CAAC;IAED,kBAAkB,CAAC,SAAiB;QAClC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;IAC/D,CAAC;IAED,YAAY,CAAC,KAAqB;QAChC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,UAAU;QACR,OAAO;YACL,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,iEAAiE;YAC9E,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,IAAI,EAAE,IAAI,CAAC,OAAO;SACnB,CAAC;IACJ,CAAC;;AAGH;;;;GAIG;AACH,SAAS,UAAU,CAAC,IAAyC;IAC3D,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC7C,OAAO;QACL,OAAO;QACP,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC;QACnC,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC;QACnC,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,CAAC;KACxC,CAAC;AACJ,CAAC;AAED,kHAAkH;AAClH,SAAS,eAAe,CAAC,KAA2B;IAClD,OAAO,KAAK,CAAC,OAAO,KAAK,MAAM,CAAC;AAClC,CAAC","sourcesContent":["/**\n * DebugRecorder — Development-focused recorder for detailed debugging\n *\n * Captures errors (always — a scope recorder's own failure, the scope\n * channel's `onError`; a stage's failure is not one), mutations and reads\n * (in verbose mode), and stage lifecycle events for troubleshooting.\n *\n * Attempts (10.1): one `attempt` row per attempt of a series that retried,\n * gave up or timed out (`recorder/attemptSeries.ts · isRetryEvidence`) — its\n * outcome, category, duration, decision, the cap and time left it ran under\n * (present with a cap or a deadline) and served error — and one `attemptStop`\n * row when the series gave up (exhausted, declined, no time left). Both verbosities: like a\n * pause, an attempt is significant — and for a retried stage these rows are\n * the failure evidence (a stage's error is never an `error` row). They arrive on the FLOW channel\n * (`onAttempt`), so attach with `attachCombinedRecorder` to see them; the\n * flow channel's own `onError` / `onPause` / `onResume` are ignored, so a\n * combined attach never doubles a scope row.\n */\n\nimport type { AttemptRecord } from '../../attempt/types.js';\nimport type { FlowAttemptEvent } from '../../engine/narrative/types.js';\nimport { gaveUp, isRetryEvidence } from '../../recorder/attemptSeries.js';\nimport type { RecorderOperation } from '../../recorder/RecorderOperation.js';\nimport type {\n  ErrorEvent,\n  PauseEvent,\n  ReadEvent,\n  ResumeEvent,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from '../types.js';\n\nexport type DebugVerbosity = 'minimal' | 'verbose';\n\nexport interface DebugEntry {\n  type: 'read' | 'write' | 'error' | 'stageStart' | 'stageEnd' | 'pause' | 'resume' | 'attempt' | 'attemptStop';\n  stageName: string;\n  timestamp: number;\n  data: unknown;\n}\n\nexport interface DebugRecorderOptions {\n  id?: string;\n  verbosity?: DebugVerbosity;\n  /** Preferred UI operation. Defaults to 'translate' (per-step diagnostic detail). */\n  preferredOperation?: RecorderOperation;\n}\n\n/**\n * Each instance gets a unique auto-increment ID (`debug-1`, `debug-2`, ...),\n * so multiple recorders with different verbosity coexist.\n *\n * @example\n * ```typescript\n * // Verbose debug for development\n * executor.attachScopeRecorder(new DebugRecorder({ verbosity: 'verbose' }));\n *\n * // Minimal debug for production (errors only)\n * executor.attachScopeRecorder(new DebugRecorder({ verbosity: 'minimal' }));\n *\n * // Both coexist — different auto IDs\n * ```\n */\nexport class DebugRecorder implements ScopeRecorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  private entries: DebugEntry[] = [];\n  private verbosity: DebugVerbosity;\n\n  constructor(options?: DebugRecorderOptions) {\n    this.id = options?.id ?? `debug-${++DebugRecorder._counter}`;\n    this.verbosity = options?.verbosity ?? 'verbose';\n    this.preferredOperation = options?.preferredOperation ?? 'translate';\n  }\n\n  onRead(event: ReadEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'read',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { key: event.key, value: event.value, pipelineId: event.pipelineId },\n    });\n  }\n\n  onWrite(event: WriteEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'write',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { key: event.key, value: event.value, operation: event.operation, pipelineId: event.pipelineId },\n    });\n  }\n\n  onError(event: ErrorEvent): void {\n    if (fromFlowChannel(event)) return;\n    const error = debugError(event.error);\n    this.entries.push({\n      type: 'error',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { error, operation: event.operation, key: event.key, pipelineId: event.pipelineId },\n    });\n  }\n\n  onStageStart(event: StageEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'stageStart',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { pipelineId: event.pipelineId },\n    });\n  }\n\n  onStageEnd(event: StageEvent): void {\n    if (this.verbosity !== 'verbose') return;\n    this.entries.push({\n      type: 'stageEnd',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { pipelineId: event.pipelineId, duration: event.duration },\n    });\n  }\n\n  onPause(event: PauseEvent): void {\n    if (fromFlowChannel(event)) return;\n    // Always log pauses (even in minimal mode — pauses are significant events)\n    this.entries.push({\n      type: 'pause',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { stageId: event.stageId, pauseData: event.pauseData, pipelineId: event.pipelineId },\n    });\n  }\n\n  onResume(event: ResumeEvent): void {\n    if (fromFlowChannel(event)) return;\n    // Always log resumes (even in minimal mode)\n    this.entries.push({\n      type: 'resume',\n      stageName: event.stageName,\n      timestamp: event.timestamp,\n      data: { stageId: event.stageId, hasInput: event.hasInput, pipelineId: event.pipelineId },\n    });\n  }\n\n  onAttempt(event: FlowAttemptEvent): void {\n    const { record } = event;\n    if (!isRetryEvidence(record)) return;\n    const timestamp = record.startedAt + record.durationMs;\n    const name = { stageId: event.stageId, series: record.series, attempt: record.attempt, of: record.of };\n    this.entries.push({\n      type: 'attempt',\n      stageName: event.stageName,\n      timestamp,\n      data: {\n        ...name,\n        outcome: record.outcome,\n        ...(record.category !== undefined && { category: record.category }),\n        durationMs: record.durationMs,\n        next: record.next,\n        reason: record.reason,\n        ...(record.retryOnThrew && { retryOnThrew: true }),\n        ...(record.delayMs !== undefined && { delayMs: record.delayMs }),\n        ...(record.timeoutMs !== undefined && { timeoutMs: record.timeoutMs }),\n        ...(record.timeLeftMs !== undefined && { timeLeftMs: record.timeLeftMs }),\n        ...(record.error !== undefined && { error: debugError(record.error) }),\n      },\n    });\n    if (!gaveUp(record)) return;\n    this.entries.push({\n      type: 'attemptStop',\n      stageName: event.stageName,\n      timestamp,\n      data: {\n        ...name,\n        reason: record.reason,\n        ...(record.category !== undefined && { category: record.category }),\n        ...(record.retryOnThrew && { retryOnThrew: true }),\n      },\n    });\n  }\n\n  getEntries(): DebugEntry[] {\n    return [...this.entries];\n  }\n\n  getErrors(): DebugEntry[] {\n    return this.entries.filter((e) => e.type === 'error');\n  }\n\n  getEntriesForStage(stageName: string): DebugEntry[] {\n    return this.entries.filter((e) => e.stageName === stageName);\n  }\n\n  setVerbosity(level: DebugVerbosity): void {\n    this.verbosity = level;\n  }\n\n  getVerbosity(): DebugVerbosity {\n    return this.verbosity;\n  }\n\n  clear(): void {\n    this.entries = [];\n  }\n\n  toSnapshot() {\n    return {\n      name: 'Debug',\n      description: 'Translator (Scope ScopeRecorder) — per-stage diagnostic entries',\n      preferredOperation: this.preferredOperation,\n      data: this.entries,\n    };\n  }\n}\n\n/**\n * The structured fields only — never `raw` (the thrown value itself, which may be a function, a Proxy or a cycle),\n * so a snapshot row always survives `structuredClone` (9.39.0). An attempt's error is already the served form\n * (`AttemptRecord.error`, the run's redaction rule applied), so a redacted stage error reads redacted here too.\n */\nfunction debugError(info: NonNullable<AttemptRecord['error']>): Record<string, unknown> {\n  const { message, name, code, issues } = info;\n  return {\n    message,\n    ...(name !== undefined && { name }),\n    ...(code !== undefined && { code }),\n    ...(issues !== undefined && { issues }),\n  };\n}\n\n/** A shared-name hook (`onError` / `onPause` / `onResume`) delivered on the flow channel of a combined attach. */\nfunction fromFlowChannel(event: { channel?: string }): boolean {\n  return event.channel === 'flow';\n}\n"]}

package/dist/esm/lib/scope/recorders/MetricRecorder.d.ts

@@ -6,6 +6,14 @@
  * (Convention 1 — one purpose per recorder: this is the ScopeRecorder; the store
  * is the storage).
  *
+ * Attempts (10.1): a stage with a retry policy runs each attempt in a fresh
+ * scope, so this recorder sees one `onStageStart` per attempt. `attempts` is
+ * that count, present when it is 2 or more; `duration` spans the whole
+ * execution — from the FIRST attempt's start, waits included — never just the
+ * attempt that succeeded. An execution that never returned (it gave up) has
+ * no `onStageEnd`, so its duration stays `0`, as for any failed stage. A stage
+ * that ran once reads exactly as before.
+ *
  * @example
  * ```typescript
  * const metric = new MetricRecorder();
@@ -38,6 +46,8 @@ export interface StepMetrics {
     pauseCount: number;
     /** Duration in ms for this invocation. */
     duration: number;
+    /** How many attempts the execution made (its `onStageStart` count) — present only when it retried (≥ 2). */
+    attempts?: number;
 }
 /** Aggregated metrics across all invocations (backward compatible). */
 export interface AggregatedMetrics {

package/dist/esm/lib/scope/recorders/MetricRecorder.js

@@ -6,6 +6,14 @@
  * (Convention 1 — one purpose per recorder: this is the ScopeRecorder; the store
  * is the storage).
  *
+ * Attempts (10.1): a stage with a retry policy runs each attempt in a fresh
+ * scope, so this recorder sees one `onStageStart` per attempt. `attempts` is
+ * that count, present when it is 2 or more; `duration` spans the whole
+ * execution — from the FIRST attempt's start, waits included — never just the
+ * attempt that succeeded. An execution that never returned (it gave up) has
+ * no `onStageEnd`, so its duration stays `0`, as for any failed stage. A stage
+ * that ran once reads exactly as before.
+ *
  * @example
  * ```typescript
  * const metric = new MetricRecorder();
@@ -83,9 +91,14 @@ export class MetricRecorder {
     onStageStart(event) {
         if (!this.shouldRecord(event.stageName))
             return;
-        this.stageStartTimes.set(event.runtimeStageId, event.timestamp);
         const m = this.forEvent(event);
         m.stageName = event.stageName;
+        if (this.stageStartTimes.has(event.runtimeStageId)) {
+            // Another attempt of the same execution: count it, keep the first start (the duration spans them all).
+            m.attempts = (m.attempts ?? 1) + 1;
+            return;
+        }
+        this.stageStartTimes.set(event.runtimeStageId, event.timestamp);
     }
     onRead(event) {
         if (!this.shouldRecord(event.stageName))
@@ -192,4 +205,4 @@ export class MetricRecorder {
         this.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MetricRecorder.js","sourceRoot":"","sources":["../../../../../src/lib/scope/recorders/MetricRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MetricRecorder — per-step timing and execution counts, keyed by runtimeStageId.\n *\n * Stores per-invocation data during traversal. Aggregated views computed on read.\n * Composes a `KeyedStore<StepMetrics>` for O(1) lookup and standard operations\n * (Convention 1 — one purpose per recorder: this is the ScopeRecorder; the store\n * is the storage).\n *\n * @example\n * ```typescript\n * const metric = new MetricRecorder();\n * executor.attachScopeRecorder(metric);\n * await executor.run();\n *\n * // Per-step (time-travel):\n * metric.getByKey('call-llm#5');  // { stageName, readCount, writeCount, duration }\n *\n * // Aggregated (backward compat):\n * metric.getMetrics();  // { totalDuration, totalReads, stageMetrics: Map<stageName, aggregated> }\n *\n * // Progressive (slider):\n * metric.accumulate((sum, m) => sum + m.duration, 0, visibleKeys);\n * ```\n */\n\nimport { KeyedStore } from '../../recorder/KeyedStore.js';\nimport type { RecorderOperation } from '../../recorder/RecorderOperation.js';\nimport type {\n  CommitEvent,\n  PauseEvent,\n  ReadEvent,\n  RecorderContext,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from '../types.js';\n\n/** Per-invocation metrics for a single execution step. */\nexport interface StepMetrics {\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Number of scope reads during this invocation. */\n  readCount: number;\n  /** Number of scope writes during this invocation. */\n  writeCount: number;\n  /** Number of commits during this invocation. */\n  commitCount: number;\n  /** Number of pauses during this invocation. */\n  pauseCount: number;\n  /** Duration in ms for this invocation. */\n  duration: number;\n}\n\n/** Aggregated metrics across all invocations (backward compatible). */\nexport interface AggregatedMetrics {\n  totalDuration: number;\n  totalReads: number;\n  totalWrites: number;\n  totalCommits: number;\n  totalPauses: number;\n  /** Aggregated by stageName — sums across loop invocations. */\n  stageMetrics: Map<string, StageMetrics>;\n}\n\n/** Aggregated per-stageName (backward compatible with pre-runtimeStageId API). */\nexport interface StageMetrics {\n  stageName: string;\n  readCount: number;\n  writeCount: number;\n  commitCount: number;\n  pauseCount: number;\n  totalDuration: number;\n  invocationCount: number;\n}\n\n/** Options for MetricRecorder. */\nexport interface MetricRecorderOptions {\n  /** ScopeRecorder ID. Defaults to auto-increment (`metrics-1`, `metrics-2`, ...). */\n  id?: string;\n  /** Filter which stages are recorded. Return `true` to record, `false` to skip. */\n  stageFilter?: (stageName: string) => boolean;\n  /** Preferred UI operation. Defaults to 'aggregate' (dashboard totals). */\n  preferredOperation?: RecorderOperation;\n}\n\nexport class MetricRecorder implements ScopeRecorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  /** 1:1 per-step storage (Convention 1 — composed, not inherited). */\n  private readonly store = new KeyedStore<StepMetrics>();\n  private stageStartTimes = new Map<string, number>();\n  private stageFilter?: (stageName: string) => boolean;\n\n  constructor(idOrOptions?: string | MetricRecorderOptions) {\n    if (typeof idOrOptions === 'string') {\n      this.id = idOrOptions;\n      this.preferredOperation = 'aggregate';\n    } else {\n      this.id = idOrOptions?.id ?? `metrics-${++MetricRecorder._counter}`;\n      this.stageFilter = idOrOptions?.stageFilter;\n      this.preferredOperation = idOrOptions?.preferredOperation ?? 'aggregate';\n    }\n  }\n\n  private shouldRecord(stageName: string): boolean {\n    return !this.stageFilter || this.stageFilter(stageName);\n  }\n\n  /** Each event owns its attribution; another stage may have started meanwhile. */\n  private forEvent(event: RecorderContext): StepMetrics {\n    const key = event.runtimeStageId;\n    let m = this.store.get(key);\n    if (!m) {\n      m = { stageName: event.stageName, readCount: 0, writeCount: 0, commitCount: 0, pauseCount: 0, duration: 0 };\n      this.store.set(key, m);\n    }\n    return m;\n  }\n\n  // ── Per-step query API (delegates to the composed store) ───────────────\n\n  /** Translate: per-step metrics by runtimeStageId. */\n  getByKey(runtimeStageId: string): StepMetrics | undefined {\n    return this.store.get(runtimeStageId);\n  }\n\n  /** All per-step metrics as a read-only Map (insertion-ordered). */\n  getMap(): ReadonlyMap<string, StepMetrics> {\n    return this.store.getMap();\n  }\n\n  /** All per-step metrics (insertion-ordered). */\n  values(): StepMetrics[] {\n    return this.store.values();\n  }\n\n  /** Number of recorded steps. */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /** Aggregate: reduce ALL steps to a single value (dashboards, totals). */\n  aggregate<R>(fn: (acc: R, entry: StepMetrics, key: string) => R, initial: R): R {\n    return this.store.aggregate(fn, initial);\n  }\n\n  /** Accumulate: reduce steps up to a slider position (progressive view). */\n  accumulate<R>(fn: (acc: R, entry: StepMetrics, key: string) => R, initial: R, keys?: ReadonlySet<string>): R {\n    return this.store.accumulate(fn, initial, keys);\n  }\n\n  onStageStart(event: StageEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.stageStartTimes.set(event.runtimeStageId, event.timestamp);\n    const m = this.forEvent(event);\n    m.stageName = event.stageName;\n  }\n\n  onRead(event: ReadEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).readCount++;\n  }\n\n  onWrite(event: WriteEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).writeCount++;\n  }\n\n  onCommit(event: CommitEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).commitCount++;\n  }\n\n  onPause(event: PauseEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).pauseCount++;\n  }\n\n  onStageEnd(event: StageEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    const m = this.forEvent(event);\n    if (event.duration !== undefined) {\n      m.duration = event.duration;\n    } else {\n      const startTime = this.stageStartTimes.get(event.runtimeStageId);\n      m.duration = startTime !== undefined ? event.timestamp - startTime : 0;\n    }\n    this.stageStartTimes.delete(event.runtimeStageId);\n  }\n\n  /** Aggregated metrics — computes totals on the fly from per-step data (backward compatible). */\n  getMetrics(): AggregatedMetrics {\n    const byName = new Map<string, StageMetrics>();\n\n    const totalDuration = this.aggregate((sum, m) => sum + m.duration, 0);\n    const totalReads = this.aggregate((sum, m) => sum + m.readCount, 0);\n    const totalWrites = this.aggregate((sum, m) => sum + m.writeCount, 0);\n    const totalCommits = this.aggregate((sum, m) => sum + m.commitCount, 0);\n    const totalPauses = this.aggregate((sum, m) => sum + m.pauseCount, 0);\n\n    // Group by stageName for backward compat\n    for (const m of this.values()) {\n      const existing = byName.get(m.stageName);\n      if (existing) {\n        existing.readCount += m.readCount;\n        existing.writeCount += m.writeCount;\n        existing.commitCount += m.commitCount;\n        existing.pauseCount += m.pauseCount;\n        existing.totalDuration += m.duration;\n        existing.invocationCount++;\n      } else {\n        byName.set(m.stageName, {\n          stageName: m.stageName,\n          readCount: m.readCount,\n          writeCount: m.writeCount,\n          commitCount: m.commitCount,\n          pauseCount: m.pauseCount,\n          totalDuration: m.duration,\n          invocationCount: 1,\n        });\n      }\n    }\n\n    return { totalDuration, totalReads, totalWrites, totalCommits, totalPauses, stageMetrics: byName };\n  }\n\n  /** Get aggregated metrics for a specific stage name (backward compatible). */\n  getStageMetrics(stageName: string): StageMetrics | undefined {\n    const metrics = this.getMetrics();\n    return metrics.stageMetrics.get(stageName);\n  }\n\n  toSnapshot() {\n    const metrics = this.getMetrics();\n    // Expose per-step data keyed by runtimeStageId (for time-travel UI)\n    // alongside the aggregated totals\n    const steps: Record<string, unknown> = {};\n    for (const [key, value] of this.getMap()) {\n      steps[key] = value;\n    }\n    return {\n      name: 'Metrics',\n      description: 'Aggregator (KeyedStore) — per-step timing and I/O counts',\n      preferredOperation: this.preferredOperation,\n      data: {\n        numericField: 'readCount',\n        grandTotal: metrics.totalReads,\n        totalDuration: metrics.totalDuration,\n        totalReads: metrics.totalReads,\n        totalWrites: metrics.totalWrites,\n        totalCommits: metrics.totalCommits,\n        totalPauses: metrics.totalPauses,\n        steps,\n      },\n    };\n  }\n\n  /** Clear all state — called by executor before each run(). */\n  clear(): void {\n    this.store.clear();\n    this.stageStartTimes.clear();\n  }\n\n  /** Alias for clear() (backward compat). */\n  reset(): void {\n    this.clear();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MetricRecorder.js","sourceRoot":"","sources":["../../../../../src/lib/scope/recorders/MetricRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AA8D1D,MAAM,OAAO,cAAc;IACjB,MAAM,CAAC,QAAQ,GAAG,CAAC,CAAC;IAEnB,EAAE,CAAS;IACX,kBAAkB,CAAoB;IAC/C,qEAAqE;IACpD,KAAK,GAAG,IAAI,UAAU,EAAe,CAAC;IAC/C,eAAe,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC5C,WAAW,CAAkC;IAErD,YAAY,WAA4C;QACtD,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;YACpC,IAAI,CAAC,EAAE,GAAG,WAAW,CAAC;YACtB,IAAI,CAAC,kBAAkB,GAAG,WAAW,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,EAAE,GAAG,WAAW,EAAE,EAAE,IAAI,WAAW,EAAE,cAAc,CAAC,QAAQ,EAAE,CAAC;YACpE,IAAI,CAAC,WAAW,GAAG,WAAW,EAAE,WAAW,CAAC;YAC5C,IAAI,CAAC,kBAAkB,GAAG,WAAW,EAAE,kBAAkB,IAAI,WAAW,CAAC;QAC3E,CAAC;IACH,CAAC;IAEO,YAAY,CAAC,SAAiB;QACpC,OAAO,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IAC1D,CAAC;IAED,iFAAiF;IACzE,QAAQ,CAAC,KAAsB;QACrC,MAAM,GAAG,GAAG,KAAK,CAAC,cAAc,CAAC;QACjC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5B,IAAI,CAAC,CAAC,EAAE,CAAC;YACP,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;YAC5G,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACzB,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC;IAED,0EAA0E;IAE1E,qDAAqD;IACrD,QAAQ,CAAC,cAAsB;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC;IAED,mEAAmE;IACnE,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;IAC7B,CAAC;IAED,gDAAgD;IAChD,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;IAC7B,CAAC;IAED,gCAAgC;IAChC,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED,0EAA0E;IAC1E,SAAS,CAAI,EAAkD,EAAE,OAAU;QACzE,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,2EAA2E;IAC3E,UAAU,CAAI,EAAkD,EAAE,OAAU,EAAE,IAA0B;QACtG,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,YAAY,CAAC,KAAiB;QAC5B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YAAE,OAAO;QAChD,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QAC9B,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC;YACnD,uGAAuG;YACvG,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;YACnC,OAAO;QACT,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,CAAC,KAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YAAE,OAAO;QAChD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,CAAC;IACnC,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YAAE,OAAO;QAChD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC;IACpC,CAAC;IAED,QAAQ,CAAC,KAAkB;QACzB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YAAE,OAAO;QAChD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IACrC,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YAAE,OAAO;QAChD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC;IACpC,CAAC;IAED,UAAU,CAAC,KAAiB;QAC1B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YAAE,OAAO;QAChD,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YACjC,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;YACjE,CAAC,CAAC,QAAQ,GAAG,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IACpD,CAAC;IAED,gGAAgG;IAChG,UAAU;QACR,MAAM,MAAM,GAAG,IAAI,GAAG,EAAwB,CAAC;QAE/C,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACtE,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACpE,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QACtE,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACxE,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QAEtE,yCAAyC;QACzC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,QAAQ,EAAE,CAAC;gBACb,QAAQ,CAAC,SAAS,IAAI,CAAC,CAAC,SAAS,CAAC;gBAClC,QAAQ,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC;gBACpC,QAAQ,CAAC,WAAW,IAAI,CAAC,CAAC,WAAW,CAAC;gBACtC,QAAQ,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC;gBACpC,QAAQ,CAAC,aAAa,IAAI,CAAC,CAAC,QAAQ,CAAC;gBACrC,QAAQ,CAAC,eAAe,EAAE,CAAC;YAC7B,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE;oBACtB,SAAS,EAAE,CAAC,CAAC,SAAS;oBACtB,SAAS,EAAE,CAAC,CAAC,SAAS;oBACtB,UAAU,EAAE,CAAC,CAAC,UAAU;oBACxB,WAAW,EAAE,CAAC,CAAC,WAAW;oBAC1B,UAAU,EAAE,CAAC,CAAC,UAAU;oBACxB,aAAa,EAAE,CAAC,CAAC,QAAQ;oBACzB,eAAe,EAAE,CAAC;iBACnB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IACrG,CAAC;IAED,8EAA8E;IAC9E,eAAe,CAAC,SAAiB;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,OAAO,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IAED,UAAU;QACR,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,oEAAoE;QACpE,kCAAkC;QAClC,MAAM,KAAK,GAA4B,EAAE,CAAC;QAC1C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;YACzC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACrB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,0DAA0D;YACvE,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,IAAI,EAAE;gBACJ,YAAY,EAAE,WAAW;gBACzB,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,YAAY,EAAE,OAAO,CAAC,YAAY;gBAClC,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,KAAK;aACN;SACF,CAAC;IACJ,CAAC;IAED,8DAA8D;IAC9D,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAED,2CAA2C;IAC3C,KAAK;QACH,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC","sourcesContent":["/**\n * MetricRecorder — per-step timing and execution counts, keyed by runtimeStageId.\n *\n * Stores per-invocation data during traversal. Aggregated views computed on read.\n * Composes a `KeyedStore<StepMetrics>` for O(1) lookup and standard operations\n * (Convention 1 — one purpose per recorder: this is the ScopeRecorder; the store\n * is the storage).\n *\n * Attempts (10.1): a stage with a retry policy runs each attempt in a fresh\n * scope, so this recorder sees one `onStageStart` per attempt. `attempts` is\n * that count, present when it is 2 or more; `duration` spans the whole\n * execution — from the FIRST attempt's start, waits included — never just the\n * attempt that succeeded. An execution that never returned (it gave up) has\n * no `onStageEnd`, so its duration stays `0`, as for any failed stage. A stage\n * that ran once reads exactly as before.\n *\n * @example\n * ```typescript\n * const metric = new MetricRecorder();\n * executor.attachScopeRecorder(metric);\n * await executor.run();\n *\n * // Per-step (time-travel):\n * metric.getByKey('call-llm#5');  // { stageName, readCount, writeCount, duration }\n *\n * // Aggregated (backward compat):\n * metric.getMetrics();  // { totalDuration, totalReads, stageMetrics: Map<stageName, aggregated> }\n *\n * // Progressive (slider):\n * metric.accumulate((sum, m) => sum + m.duration, 0, visibleKeys);\n * ```\n */\n\nimport { KeyedStore } from '../../recorder/KeyedStore.js';\nimport type { RecorderOperation } from '../../recorder/RecorderOperation.js';\nimport type {\n  CommitEvent,\n  PauseEvent,\n  ReadEvent,\n  RecorderContext,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from '../types.js';\n\n/** Per-invocation metrics for a single execution step. */\nexport interface StepMetrics {\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Number of scope reads during this invocation. */\n  readCount: number;\n  /** Number of scope writes during this invocation. */\n  writeCount: number;\n  /** Number of commits during this invocation. */\n  commitCount: number;\n  /** Number of pauses during this invocation. */\n  pauseCount: number;\n  /** Duration in ms for this invocation. */\n  duration: number;\n  /** How many attempts the execution made (its `onStageStart` count) — present only when it retried (≥ 2). */\n  attempts?: number;\n}\n\n/** Aggregated metrics across all invocations (backward compatible). */\nexport interface AggregatedMetrics {\n  totalDuration: number;\n  totalReads: number;\n  totalWrites: number;\n  totalCommits: number;\n  totalPauses: number;\n  /** Aggregated by stageName — sums across loop invocations. */\n  stageMetrics: Map<string, StageMetrics>;\n}\n\n/** Aggregated per-stageName (backward compatible with pre-runtimeStageId API). */\nexport interface StageMetrics {\n  stageName: string;\n  readCount: number;\n  writeCount: number;\n  commitCount: number;\n  pauseCount: number;\n  totalDuration: number;\n  invocationCount: number;\n}\n\n/** Options for MetricRecorder. */\nexport interface MetricRecorderOptions {\n  /** ScopeRecorder ID. Defaults to auto-increment (`metrics-1`, `metrics-2`, ...). */\n  id?: string;\n  /** Filter which stages are recorded. Return `true` to record, `false` to skip. */\n  stageFilter?: (stageName: string) => boolean;\n  /** Preferred UI operation. Defaults to 'aggregate' (dashboard totals). */\n  preferredOperation?: RecorderOperation;\n}\n\nexport class MetricRecorder implements ScopeRecorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  /** 1:1 per-step storage (Convention 1 — composed, not inherited). */\n  private readonly store = new KeyedStore<StepMetrics>();\n  private stageStartTimes = new Map<string, number>();\n  private stageFilter?: (stageName: string) => boolean;\n\n  constructor(idOrOptions?: string | MetricRecorderOptions) {\n    if (typeof idOrOptions === 'string') {\n      this.id = idOrOptions;\n      this.preferredOperation = 'aggregate';\n    } else {\n      this.id = idOrOptions?.id ?? `metrics-${++MetricRecorder._counter}`;\n      this.stageFilter = idOrOptions?.stageFilter;\n      this.preferredOperation = idOrOptions?.preferredOperation ?? 'aggregate';\n    }\n  }\n\n  private shouldRecord(stageName: string): boolean {\n    return !this.stageFilter || this.stageFilter(stageName);\n  }\n\n  /** Each event owns its attribution; another stage may have started meanwhile. */\n  private forEvent(event: RecorderContext): StepMetrics {\n    const key = event.runtimeStageId;\n    let m = this.store.get(key);\n    if (!m) {\n      m = { stageName: event.stageName, readCount: 0, writeCount: 0, commitCount: 0, pauseCount: 0, duration: 0 };\n      this.store.set(key, m);\n    }\n    return m;\n  }\n\n  // ── Per-step query API (delegates to the composed store) ───────────────\n\n  /** Translate: per-step metrics by runtimeStageId. */\n  getByKey(runtimeStageId: string): StepMetrics | undefined {\n    return this.store.get(runtimeStageId);\n  }\n\n  /** All per-step metrics as a read-only Map (insertion-ordered). */\n  getMap(): ReadonlyMap<string, StepMetrics> {\n    return this.store.getMap();\n  }\n\n  /** All per-step metrics (insertion-ordered). */\n  values(): StepMetrics[] {\n    return this.store.values();\n  }\n\n  /** Number of recorded steps. */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /** Aggregate: reduce ALL steps to a single value (dashboards, totals). */\n  aggregate<R>(fn: (acc: R, entry: StepMetrics, key: string) => R, initial: R): R {\n    return this.store.aggregate(fn, initial);\n  }\n\n  /** Accumulate: reduce steps up to a slider position (progressive view). */\n  accumulate<R>(fn: (acc: R, entry: StepMetrics, key: string) => R, initial: R, keys?: ReadonlySet<string>): R {\n    return this.store.accumulate(fn, initial, keys);\n  }\n\n  onStageStart(event: StageEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    const m = this.forEvent(event);\n    m.stageName = event.stageName;\n    if (this.stageStartTimes.has(event.runtimeStageId)) {\n      // Another attempt of the same execution: count it, keep the first start (the duration spans them all).\n      m.attempts = (m.attempts ?? 1) + 1;\n      return;\n    }\n    this.stageStartTimes.set(event.runtimeStageId, event.timestamp);\n  }\n\n  onRead(event: ReadEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).readCount++;\n  }\n\n  onWrite(event: WriteEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).writeCount++;\n  }\n\n  onCommit(event: CommitEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).commitCount++;\n  }\n\n  onPause(event: PauseEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    this.forEvent(event).pauseCount++;\n  }\n\n  onStageEnd(event: StageEvent): void {\n    if (!this.shouldRecord(event.stageName)) return;\n    const m = this.forEvent(event);\n    if (event.duration !== undefined) {\n      m.duration = event.duration;\n    } else {\n      const startTime = this.stageStartTimes.get(event.runtimeStageId);\n      m.duration = startTime !== undefined ? event.timestamp - startTime : 0;\n    }\n    this.stageStartTimes.delete(event.runtimeStageId);\n  }\n\n  /** Aggregated metrics — computes totals on the fly from per-step data (backward compatible). */\n  getMetrics(): AggregatedMetrics {\n    const byName = new Map<string, StageMetrics>();\n\n    const totalDuration = this.aggregate((sum, m) => sum + m.duration, 0);\n    const totalReads = this.aggregate((sum, m) => sum + m.readCount, 0);\n    const totalWrites = this.aggregate((sum, m) => sum + m.writeCount, 0);\n    const totalCommits = this.aggregate((sum, m) => sum + m.commitCount, 0);\n    const totalPauses = this.aggregate((sum, m) => sum + m.pauseCount, 0);\n\n    // Group by stageName for backward compat\n    for (const m of this.values()) {\n      const existing = byName.get(m.stageName);\n      if (existing) {\n        existing.readCount += m.readCount;\n        existing.writeCount += m.writeCount;\n        existing.commitCount += m.commitCount;\n        existing.pauseCount += m.pauseCount;\n        existing.totalDuration += m.duration;\n        existing.invocationCount++;\n      } else {\n        byName.set(m.stageName, {\n          stageName: m.stageName,\n          readCount: m.readCount,\n          writeCount: m.writeCount,\n          commitCount: m.commitCount,\n          pauseCount: m.pauseCount,\n          totalDuration: m.duration,\n          invocationCount: 1,\n        });\n      }\n    }\n\n    return { totalDuration, totalReads, totalWrites, totalCommits, totalPauses, stageMetrics: byName };\n  }\n\n  /** Get aggregated metrics for a specific stage name (backward compatible). */\n  getStageMetrics(stageName: string): StageMetrics | undefined {\n    const metrics = this.getMetrics();\n    return metrics.stageMetrics.get(stageName);\n  }\n\n  toSnapshot() {\n    const metrics = this.getMetrics();\n    // Expose per-step data keyed by runtimeStageId (for time-travel UI)\n    // alongside the aggregated totals\n    const steps: Record<string, unknown> = {};\n    for (const [key, value] of this.getMap()) {\n      steps[key] = value;\n    }\n    return {\n      name: 'Metrics',\n      description: 'Aggregator (KeyedStore) — per-step timing and I/O counts',\n      preferredOperation: this.preferredOperation,\n      data: {\n        numericField: 'readCount',\n        grandTotal: metrics.totalReads,\n        totalDuration: metrics.totalDuration,\n        totalReads: metrics.totalReads,\n        totalWrites: metrics.totalWrites,\n        totalCommits: metrics.totalCommits,\n        totalPauses: metrics.totalPauses,\n        steps,\n      },\n    };\n  }\n\n  /** Clear all state — called by executor before each run(). */\n  clear(): void {\n    this.store.clear();\n    this.stageStartTimes.clear();\n  }\n\n  /** Alias for clear() (backward compat). */\n  reset(): void {\n    this.clear();\n  }\n}\n"]}

package/dist/esm/lib/scope/runtime.d.ts

@@ -7,6 +7,7 @@
  * ScopeFacade owns recording, redaction and state access; custom scopes may
  * explicitly supply a smaller port (including `{}` for data-only scopes).
  */
+import type { RunCorrelation } from '../attempt/types.js';
 import type { RedactionPolicy, ScopeRecorder } from './types.js';
 /** Engine-facing capabilities. Never use a strict user-field proxy as this port. */
 export interface ScopeRuntimeTarget {
@@ -15,6 +16,8 @@ export interface ScopeRuntimeTarget {
     getScopeRecorders?(): ScopeRecorder[];
     useSharedRedactedKeys?(keys: Set<string>): void;
     useRedactionPolicy?(policy: RedactionPolicy): void;
+    /** The run's correlation, stamped on every scope and emit event this scope fires (10.1). */
+    useCorrelation?(correlation: RunCorrelation | undefined): void;
     getRedactedKeys?(): Set<string>;
     notifyStageStart?(): void;
     notifyStageEnd?(duration?: number): void;

package/dist/esm/lib/scope/runtime.js

@@ -57,4 +57,4 @@ export function requireScopeRuntime(scope, message = UNREGISTERED) {
 export function requireDecisionScopeRuntime(scope) {
     return requireScopeRuntime(scope, UNREGISTERED_DECISION);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../../src/lib/scope/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA8BH,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAkC,CAAC;AAE/D,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC,IAAI,OAAO,KAAK,KAAK,UAAU,CAAC;AACtF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAmB,KAAQ,EAAE,OAAqB;IACpF,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;IAC3F,IAAI,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,OAAO,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;QAC7F,MAAM,IAAI,SAAS,CAAC,4EAA4E,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QAC7E,MAAM,IAAI,SAAS,CAAC,iEAAiE,CAAC,CAAC;IACzF,CAAC;IACD,QAAQ,CAAC,GAAG,CACV,KAAK,EACL,MAAM,CAAC,MAAM,CAAC;QACZ,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;QAC9C,QAAQ,EAAE,OAAO,CAAC,QAAQ;KAC3B,CAAC,CACH,CAAC;IACF,OAAO,KAAK,CAAC;AACf,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3D,CAAC;AAED,MAAM,YAAY,GAChB,+FAA+F;IAC/F,6HAA6H,CAAC;AAEhI,MAAM,qBAAqB,GACzB,mGAAmG;IACnG,6FAA6F;IAC7F,4DAA4D,CAAC;AAE/D,gGAAgG;AAChG,MAAM,UAAU,mBAAmB,CAAC,KAAc,EAAE,UAAkB,YAAY;IAChF,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IACvC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,MAAM,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC;AAC/B,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,2BAA2B,CAAC,KAAc;IACxD,OAAO,mBAAmB,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAC;AAC3D,CAAC","sourcesContent":["/**\n * The scope ↔ engine protocol. A user-facing scope may be a strict schema\n * proxy: asking it for an infrastructure member is a state access, not a\n * capability check. Registration keeps that boundary entirely out of band.\n *\n * This module owns identity and capabilities, not their implementation.\n * ScopeFacade owns recording, redaction and state access; custom scopes may\n * explicitly supply a smaller port (including `{}` for data-only scopes).\n */\n\nimport type { RunCorrelation } from '../attempt/types.js';\nimport type { RedactionPolicy, ScopeRecorder } from './types.js';\n\n/** Engine-facing capabilities. Never use a strict user-field proxy as this port. */\nexport interface ScopeRuntimeTarget {\n  attachScopeRecorder?(recorder: ScopeRecorder): void;\n  detachScopeRecorder?(recorderId: string): void;\n  getScopeRecorders?(): ScopeRecorder[];\n  useSharedRedactedKeys?(keys: Set<string>): void;\n  useRedactionPolicy?(policy: RedactionPolicy): void;\n  /** The run's correlation, stamped on every scope and emit event this scope fires (10.1). */\n  useCorrelation?(correlation: RunCorrelation | undefined): void;\n  getRedactedKeys?(): Set<string>;\n  notifyStageStart?(): void;\n  notifyStageEnd?(duration?: number): void;\n  notifyPause?(data?: unknown): void;\n  getValue?(key?: string): unknown;\n  setValue?(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n}\n\nexport interface ScopeRuntime {\n  readonly target: ScopeRuntimeTarget;\n  /** The scope already routes property assignments into managed state. */\n  readonly handlesAssignments: boolean;\n  /** Install this execution's break callback, if the scope exposes one. */\n  readonly setBreak?: (breakPipeline: (reason?: string) => void) => void;\n}\n\nconst runtimes = new WeakMap<object, Readonly<ScopeRuntime>>();\n\nfunction isObject(value: unknown): value is object {\n  return (typeof value === 'object' && value !== null) || typeof value === 'function';\n}\n\n/**\n * Register a custom scope's engine-facing port and return the SAME scope.\n * Registration never reads, writes or enumerates properties on `scope`.\n * Re-registering explicitly replaces its binding. The descriptor is copied\n * and frozen; the target itself remains live and belongs to its provider.\n *\n * @example\n * const facade = new ScopeFacade(context, stageName, input, env);\n * return registerScopeRuntime(myProxy, { target: facade, handlesAssignments: true });\n */\nexport function registerScopeRuntime<T extends object>(scope: T, runtime: ScopeRuntime): T {\n  if (!isObject(scope)) throw new TypeError('registerScopeRuntime: scope must be an object');\n  if (!runtime || !isObject(runtime.target) || typeof runtime.handlesAssignments !== 'boolean') {\n    throw new TypeError('registerScopeRuntime: provide a target port and boolean handlesAssignments');\n  }\n  if (runtime.setBreak !== undefined && typeof runtime.setBreak !== 'function') {\n    throw new TypeError('registerScopeRuntime: setBreak must be a function when supplied');\n  }\n  runtimes.set(\n    scope,\n    Object.freeze({\n      target: runtime.target,\n      handlesAssignments: runtime.handlesAssignments,\n      setBreak: runtime.setBreak,\n    }),\n  );\n  return scope;\n}\n\n/** @internal Optional only for wrappers that also work outside the engine. */\nexport function scopeRuntimeFor(scope: unknown): Readonly<ScopeRuntime> | undefined {\n  return isObject(scope) ? runtimes.get(scope) : undefined;\n}\n\nconst UNREGISTERED =\n  '[footprint] Unregistered scope. Custom scope factories must call registerScopeRuntime(scope, ' +\n  '{ target, handlesAssignments }) from footprintjs/advanced. ScopeFacade and built-in scope factories register automatically.';\n\nconst UNREGISTERED_DECISION =\n  \"[footprint] decide()/select() needs the stage's scope (the object your stage function receives), \" +\n  'not a plain object. A hand-built scope must be registered with registerScopeRuntime(scope, ' +\n  '{ target, handlesAssignments }) from footprintjs/advanced.';\n\n/** @internal No method-name guessing: a missing registration is an explicit migration error. */\nexport function requireScopeRuntime(scope: unknown, message: string = UNREGISTERED): Readonly<ScopeRuntime> {\n  const runtime = scopeRuntimeFor(scope);\n  if (runtime) return runtime;\n  throw new TypeError(message);\n}\n\n/** @internal decide()/select() asked outside a stage: name THEM, not the custom-factory migration. */\nexport function requireDecisionScopeRuntime(scope: unknown): Readonly<ScopeRuntime> {\n  return requireScopeRuntime(scope, UNREGISTERED_DECISION);\n}\n"]}

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

@@ -5,6 +5,7 @@
  * Architecture follows composition-over-inheritance: Recorders are
  * attached to Scope instances to observe read/write/commit operations.
  */
+import type { RunCorrelation } from '../attempt/types.js';
 import type { StructuredErrorInfo } from '../errors/errorInfo.js';
 export interface RecorderContext {
     stageName: string;
@@ -14,6 +15,11 @@ export interface RecorderContext {
     runtimeStageId: string;
     pipelineId: string;
     timestamp: number;
+    /**
+     * The run's correlation (10.1) — the same frozen object as `TraversalContext.correlation` on the flow events
+     * and `getSnapshot().correlation`. Absent — no key — when the run's env gave none.
+     */
+    readonly correlation?: RunCorrelation;
 }
 export interface ReadEvent extends RecorderContext {
     key?: string;

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

@@ -6,4 +6,4 @@
  * attached to Scope instances to observe read/write/commit operations.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3Njb3BlL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU2NvcGUgVHlwZSBEZWZpbml0aW9uc1xuICpcbiAqIENvcmUgdHlwZXMgZm9yIHRoZSBjb21wb3NhYmxlIFNjb3BlIHN5c3RlbSB3aXRoIHBsdWdnYWJsZSBSZWNvcmRlcnMuXG4gKiBBcmNoaXRlY3R1cmUgZm9sbG93cyBjb21wb3NpdGlvbi1vdmVyLWluaGVyaXRhbmNlOiBSZWNvcmRlcnMgYXJlXG4gKiBhdHRhY2hlZCB0byBTY29wZSBpbnN0YW5jZXMgdG8gb2JzZXJ2ZSByZWFkL3dyaXRlL2NvbW1pdCBvcGVyYXRpb25zLlxuICovXG5cbmltcG9ydCB0eXBlIHsgUnVuQ29ycmVsYXRpb24gfSBmcm9tICcuLi9hdHRlbXB0L3R5cGVzLmpzJztcbmltcG9ydCB0eXBlIHsgU3RydWN0dXJlZEVycm9ySW5mbyB9IGZyb20gJy4uL2Vycm9ycy9lcnJvckluZm8uanMnO1xuXG4vLyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09XG4vLyBFdmVudCBUeXBlc1xuLy8gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PVxuXG5leHBvcnQgaW50ZXJmYWNlIFJlY29yZGVyQ29udGV4dCB7XG4gIHN0YWdlTmFtZTogc3RyaW5nO1xuICAvKiogU3RhYmxlIHN0YWdlIGlkZW50aWZpZXIgKG1hdGNoZXMgc3BlYyBub2RlIGlkKS4gKi9cbiAgc3RhZ2VJZDogc3RyaW5nO1xuICAvKiogVW5pcXVlIHBlci1leGVjdXRpb24tc3RlcCBpZGVudGlmaWVyLiBGb3JtYXQ6IFtzdWJmbG93UGF0aC9dc3RhZ2VJZCNleGVjdXRpb25JbmRleCAqL1xuICBydW50aW1lU3RhZ2VJZDogc3RyaW5nO1xuICBwaXBlbGluZUlkOiBzdHJpbmc7XG4gIHRpbWVzdGFtcDogbnVtYmVyO1xuICAvKipcbiAgICogVGhlIHJ1bidzIGNvcnJlbGF0aW9uICgxMC4xKSDigJQgdGhlIHNhbWUgZnJvemVuIG9iamVjdCBhcyBgVHJhdmVyc2FsQ29udGV4dC5jb3JyZWxhdGlvbmAgb24gdGhlIGZsb3cgZXZlbnRzXG4gICAqIGFuZCBgZ2V0U25hcHNob3QoKS5jb3JyZWxhdGlvbmAuIEFic2VudCDigJQgbm8ga2V5IOKAlCB3aGVuIHRoZSBydW4ncyBlbnYgZ2F2ZSBub25lLlxuICAgKi9cbiAgcmVhZG9ubHkgY29ycmVsYXRpb24/OiBSdW5Db3JyZWxhdGlvbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZWFkRXZlbnQgZXh0ZW5kcyBSZWNvcmRlckNvbnRleHQge1xuICBrZXk/OiBzdHJpbmc7XG4gIHZhbHVlOiB1bmtub3duO1xuICAvKiogVHJ1ZSB3aGVuIHRoZSB2YWx1ZSBoYXMgYmVlbiByZWRhY3RlZCBmb3IgUElJIHByb3RlY3Rpb24uICovXG4gIHJlZGFjdGVkPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXcml0ZUV2ZW50IGV4dGVuZHMgUmVjb3JkZXJDb250ZXh0IHtcbiAga2V5OiBzdHJpbmc7XG4gIHZhbHVlOiB1bmtub3duO1xuICBvcGVyYXRpb246ICdzZXQnIHwgJ3VwZGF0ZScgfCAnZGVsZXRlJztcbiAgLyoqIFRydWUgd2hlbiB0aGUgdmFsdWUgaGFzIGJlZW4gcmVkYWN0ZWQgZm9yIFBJSSBwcm90ZWN0aW9uLiAqL1xuICByZWRhY3RlZD86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29tbWl0RXZlbnQgZXh0ZW5kcyBSZWNvcmRlckNvbnRleHQge1xuICBtdXRhdGlvbnM6IEFycmF5PHtcbiAgICBrZXk6IHN0cmluZztcbiAgICB2YWx1ZTogdW5rbm93bjtcbiAgICBvcGVyYXRpb246ICdzZXQnIHwgJ3VwZGF0ZScgfCAnZGVsZXRlJztcbiAgfT47XG59XG5cbi8qKlxuICogQSByZWNvcmRlciB0aHJldyBpbiBhIHNjb3BlLWNoYW5uZWwgaG9vayAoYG9wZXJhdGlvbmAgc2F5cyB3aGljaCBraW5kOlxuICogYSByZWFkLCBhIHdyaXRlLCBvciBhIGNvbW1pdCBob29rKS4gRGVsaXZlcmVkIHRvIGV2ZXJ5IHJlY29yZGVyIG9uIHRoZVxuICogc2NvcGUgY2hhbm5lbCwgaW5saW5lIGFuZCBkZWZlcnJlZCBhbGlrZSAoYHJlY29yZGVyL2hvb2tzLnRzIMK3XG4gKiByZWNvcmRlckZhaWx1cmVFdmVudGApLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEVycm9yRXZlbnQgZXh0ZW5kcyBSZWNvcmRlckNvbnRleHQge1xuICAvKipcbiAgICogV2hhdCB0aGUgcmVjb3JkZXIgdGhyZXcsIGluIHRoZSBzdHJ1Y3R1cmVkIGZvcm0gKDkuMzkuMCk6IGBtZXNzYWdlYCBhbmRcbiAgICogYG5hbWVgIHJlYWQgYXMgYmVmb3JlOyBgcmF3YCBpcyB0aGUgdGhyb3duIHZhbHVlIGl0c2VsZiAoYW4gYEVycm9yYCwgYVxuICAgKiBzdHJpbmcsIGFueXRoaW5nKS4gT25lIHNoYXBlIG9uIGV2ZXJ5IHBhdGgg4oCUIHVudGlsIDkuMzguMCB0aGUgaW5saW5lXG4gICAqIHBhdGhzIHBhc3NlZCB0aGUgcmF3IHRocm93biB2YWx1ZSBhbmQgdGhlIGRlZmVycmVkIHRpZXIgYSBgbmV3IEVycm9yKC4uLilgLlxuICAgKi9cbiAgZXJyb3I6IFN0cnVjdHVyZWRFcnJvckluZm87XG4gIG9wZXJhdGlvbjogJ3JlYWQnIHwgJ3dyaXRlJyB8ICdjb21taXQnO1xuICBrZXk/OiBzdHJpbmc7XG4gIC8qKlxuICAgKiBFeHBsaWNpdCBjaGFubmVsIGRpc2NyaW1pbmFudCDigJQgYCdzY29wZSdgIG9uIGV2ZXJ5IGVuZ2luZS1kaXNwYXRjaGVkXG4gICAqIGV2ZW50LiBgaXNGbG93RXZlbnQoKWAgY2hlY2tzIGl0IGZpcnN0IChiYWNrbG9nIEIzKTsgb3B0aW9uYWwgc29cbiAgICogY29uc3VtZXItZmFicmljYXRlZCBldmVudHMgKHRlc3RzLCByZXBsYXlzKSByZW1haW4gdHlwZS12YWxpZCBhbmQgZmFsbFxuICAgKiBiYWNrIHRvIHRoZSBsZWdhY3kgcGlwZWxpbmVJZC1wcmVzZW5jZSBoZXVyaXN0aWMuXG4gICAqL1xuICBjaGFubmVsPzogJ3Njb3BlJztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTdGFnZUV2ZW50IGV4dGVuZHMgUmVjb3JkZXJDb250ZXh0IHtcbiAgZHVyYXRpb24/OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGF1c2VFdmVudCBleHRlbmRzIFJlY29yZGVyQ29udGV4dCB7XG4gIHBhdXNlRGF0YT86IHVua25vd247XG4gIC8qKiBFeHBsaWNpdCBjaGFubmVsIGRpc2NyaW1pbmFudCDigJQgc2VlIHtAbGluayBFcnJvckV2ZW50LmNoYW5uZWx9LiAqL1xuICBjaGFubmVsPzogJ3Njb3BlJztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZXN1bWVFdmVudCBleHRlbmRzIFJlY29yZGVyQ29udGV4dCB7XG4gIGhhc0lucHV0OiBib29sZWFuO1xuICAvKiogVGhlIHBhdXNlZCBleGVjdXRpb24gdGhpcyByZXN1bWUgY29udGludWVzICg5LjM3LjApIOKAlCBzZWUgYFRyYXZlcnNhbENvbnRleHQucmVzdW1lZEZyb21gLiAqL1xuICByZXN1bWVkRnJvbT86IGltcG9ydCgnLi4vZW5naW5lL25hcnJhdGl2ZS90eXBlcy5qcycpLlJlc3VtZUxpbms7XG4gIC8qKiBFeHBsaWNpdCBjaGFubmVsIGRpc2NyaW1pbmFudCDigJQgc2VlIHtAbGluayBFcnJvckV2ZW50LmNoYW5uZWx9LiAqL1xuICBjaGFubmVsPzogJ3Njb3BlJztcbn1cblxuLy8gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PVxuLy8gUmVkYWN0aW9uIFBvbGljeVxuLy8gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PVxuXG4vKipcbiAqIGBSZWRhY3Rpb25Qb2xpY3lgIGFuZCBgUmVkYWN0aW9uUmVwb3J0YCBhcmUgT1dORUQgYnkgYG1lbW9yeS9yZWRhY3Rpb24udHNgXG4gKiAodGhlIE9ORSBvd25lciBvZiB0aGUgdmVyZGljdCDigJQgc2VlIHRoZSBsYXcgdGhlcmUpOyB0aGV5IGFyZSByZS1leHBvcnRlZFxuICogaGVyZSBzbyB0aGUgcHVibGljIHBhdGggYGZvb3RwcmludGpzYCDihpIgYFJlZGFjdGlvblBvbGljeWAgaXMgdW5jaGFuZ2VkLlxuICovXG5leHBvcnQgdHlwZSB7IFJlZGFjdGlvblBvbGljeSwgUmVkYWN0aW9uUmVwb3J0IH0gZnJvbSAnLi4vbWVtb3J5L3JlZGFjdGlvbi5qcyc7XG5cbi8vID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT1cbi8vIFNjb3BlUmVjb3JkZXIgSW50ZXJmYWNlXG4vLyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09XG5cbi8qKlxuICogUGx1Z2dhYmxlIG9ic2VydmVyIGZvciBzY29wZSBvcGVyYXRpb25zLlxuICpcbiAqIEFsbCBtZXRob2RzIGFyZSBvcHRpb25hbCDigJQgaW1wbGVtZW50IG9ubHkgdGhlIGhvb2tzIHlvdSBuZWVkLlxuICogUmVjb3JkZXJzIGFyZSBpbnZva2VkIHN5bmNocm9ub3VzbHkgaW4gYXR0YWNobWVudCBvcmRlci5cbiAqIElmIGEgcmVjb3JkZXIgdGhyb3dzLCB0aGUgZXJyb3IgaXMgY2F1Z2h0IGFuZCBwYXNzZWQgdG8gb25FcnJvclxuICogaG9va3Mgb2Ygb3RoZXIgcmVjb3JkZXJzOyB0aGUgc2NvcGUgb3BlcmF0aW9uIGNvbnRpbnVlcyBub3JtYWxseS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTY29wZVJlY29yZGVyIHtcbiAgcmVhZG9ubHkgaWQ6IHN0cmluZztcbiAgb25SZWFkPyhldmVudDogUmVhZEV2ZW50KTogdm9pZDtcbiAgb25Xcml0ZT8oZXZlbnQ6IFdyaXRlRXZlbnQpOiB2b2lkO1xuICBvbkNvbW1pdD8oZXZlbnQ6IENvbW1pdEV2ZW50KTogdm9pZDtcbiAgb25FcnJvcj8oZXZlbnQ6IEVycm9yRXZlbnQpOiB2b2lkO1xuICBvblN0YWdlU3RhcnQ/KGV2ZW50OiBTdGFnZUV2ZW50KTogdm9pZDtcbiAgb25TdGFnZUVuZD8oZXZlbnQ6IFN0YWdlRXZlbnQpOiB2b2lkO1xuICBvblBhdXNlPyhldmVudDogUGF1c2VFdmVudCk6IHZvaWQ7XG4gIG9uUmVzdW1lPyhldmVudDogUmVzdW1lRXZlbnQpOiB2b2lkO1xuICAvKipcbiAgICogRmlyZXMgZm9yIGV2ZXJ5IGBzY29wZS4kZW1pdChuYW1lLCBwYXlsb2FkKWAgY2FsbCBkdXJpbmcgYSBzdGFnZS5cbiAgICogT3B0aW9uYWwg4oCUIGltcGxlbWVudCBvbmx5IGlmIHlvdSB3YW50IHRvIG9ic2VydmUgY29uc3VtZXItZW1pdHRlZFxuICAgKiBzdHJ1Y3R1cmVkIGV2ZW50cy4gU2VlIGBFbWl0UmVjb3JkZXJgIGZvciB0aGUgZm9jdXNlZCBpbnRlcmZhY2VcbiAgICogKHN0cnVjdHVyYWxseSBjb21wYXRpYmxlOyB0aGlzIGZpZWxkIGlzIHRoZSBzYW1lIHNoYXBlKS5cbiAgICpcbiAgICogQHNlZSBFbWl0UmVjb3JkZXIgaW4gYHNyYy9saWIvcmVjb3JkZXIvRW1pdFJlY29yZGVyLnRzYFxuICAgKi9cbiAgb25FbWl0PyhldmVudDogaW1wb3J0KCcuLi9yZWNvcmRlci9FbWl0UmVjb3JkZXIuanMnKS5FbWl0RXZlbnQpOiB2b2lkO1xuICAvKiogUmVzZXQgc3RhdGUgYmVmb3JlIGVhY2ggZXhlY3V0b3IucnVuKCkg4oCUIHByZXZlbnRzIGNyb3NzLXJ1biBhY2N1bXVsYXRpb24uICovXG4gIGNsZWFyPygpOiB2b2lkO1xuICAvKiogRXhwb3NlIGNvbGxlY3RlZCBkYXRhIGZvciBpbmNsdXNpb24gaW4gZXhlY3V0b3IuZ2V0U25hcHNob3QoKS5yZWNvcmRlcnMuICovXG4gIHRvU25hcHNob3Q/KCk6IGltcG9ydCgnLi4vcmVjb3JkZXIvc25hcHNob3QuanMnKS5SZWNvcmRlckJ1bmRsZTtcbn1cbiJdfQ==