footprintjs 9.7.0 → 9.8.0

package/dist/esm/lib/recorder/ControlDepRecorder.js

@@ -0,0 +1,228 @@
+/**
+ * ControlDepRecorder — control-dependence tracking from flow events (RFC-003 D5).
+ *
+ * The gap this fills:
+ *   The backtracker's `controlDeps` option (D3) needs a `ControlDepLookup`:
+ *   "which decider execution allowed this stage to run?" The engine knows
+ *   this during traversal but the commit log doesn't record it — control
+ *   flow is a FlowRecorder concern. This recorder is the standard producer:
+ *   one subscription, one lookup, plug it straight into `causalChain`.
+ *
+ * How it works — two correlation structures built during traversal:
+ *
+ *   1. `parentOf` — the runtime ancestor chain, from every stage event's
+ *      `traversalContext.parentRuntimeStageId` (RFC-003 D1). Crosses
+ *      subflow boundaries; loop re-entries stay unambiguous because
+ *      runtime ids differ per iteration.
+ *
+ *   2. `branchEntryToDecision` — on `onDecision`/`onSelected` the decision
+ *      is recorded as PENDING; the next stage(s) executed whose
+ *      `parentRuntimeStageId` IS the decider's runtimeStageId are its
+ *      branch entries (1 for a decider, N = selected.length for a
+ *      selector). Correlation is by parent-id + count, NOT by stage name —
+ *      subflow-mount events carry path-prefixed inner-root names that
+ *      don't match `FlowDecisionEvent.chosen`, and selectors emit a
+ *      synthetic fork event sharing the selector's own runtimeStageId
+ *      (excluded via the self-id guard). A branch that THROWS before
+ *      completing consumes its slot via `onError`, so the post-fan-out
+ *      convergence stage is never misattributed as a branch entry.
+ *
+ *   `lookup(runtimeStageId)` then walks the ancestor chain from the stage
+ *   upward; the first ancestor (or the stage itself) registered as a
+ *   branch entry yields its governing decider — the NEAREST decision.
+ *   Nested decisions compose naturally: the backtracker expands the
+ *   decider node and asks again.
+ *
+ * Convention 4: state resets when `traversalContext.runId` changes — each
+ * run (and each resume, which mints a fresh runId) starts clean. Control
+ * chains therefore do NOT survive a pause/resume boundary: post-resume
+ * stages cannot resolve pre-pause decisions.
+ *
+ * @example
+ * ```typescript
+ * import { controlDepRecorder, causalChain } from 'footprintjs/trace';
+ *
+ * const ctrl = controlDepRecorder();
+ * executor.attachCombinedRecorder(ctrl); // auto-routes to FlowRecorder channel
+ *
+ * await executor.run({ input });
+ *
+ * const dag = causalChain(commitLog, 'approve#2', keysRead, {
+ *   controlDeps: ctrl.asLookup(),
+ * });
+ * ```
+ */
+let _counter = 0;
+/**
+ * Factory — matches the `topologyRecorder()` / `inOutRecorder()` style.
+ */
+export function controlDepRecorder(options = {}) {
+    return new ControlDepRecorder(options);
+}
+/**
+ * Stateful accumulator that watches FlowRecorder events and answers
+ * "which decision allowed this stage to run?" Attach via
+ * `executor.attachCombinedRecorder(recorder)` (or `attachFlowRecorder`).
+ */
+export class ControlDepRecorder {
+    id;
+    /** Runtime ancestor chain: runtimeStageId → parentRuntimeStageId (D1). */
+    parentOf = new Map();
+    /** Recorded decisions, keyed by decider runtimeStageId. */
+    decisions = new Map();
+    /** Branch-entry runtimeStageId → governing decider runtimeStageId. */
+    branchEntryToDecision = new Map();
+    /** Decisions whose branch entries have not all been seen yet. */
+    pending = [];
+    /** Stage ids that already consumed a pending slot (entry OR error). */
+    consumedSlots = new Set();
+    /** Convention 4 — runId of the run currently being recorded. */
+    lastRunId;
+    constructor(options = {}) {
+        this.id = options.id ?? `control-deps-${++_counter}`;
+    }
+    // ── FlowRecorder hooks ────────────────────────────────────────────────
+    onDecision(event) {
+        const ctx = event.traversalContext;
+        if (!ctx)
+            return;
+        this.resetIfNewRun(ctx.runId);
+        const deciderId = ctx.runtimeStageId;
+        const ruleLabel = matchedRuleLabel(event.evidence);
+        this.decisions.set(deciderId, {
+            deciderRuntimeStageId: deciderId,
+            chosen: event.chosen,
+            ...(event.evidence && { evidence: event.evidence }),
+            ...(ruleLabel !== undefined && { ruleLabel }),
+        });
+        this.pending.push({ deciderId, remaining: 1 });
+    }
+    onSelected(event) {
+        const ctx = event.traversalContext;
+        if (!ctx)
+            return;
+        this.resetIfNewRun(ctx.runId);
+        if (event.selected.length === 0)
+            return; // nothing selected → nothing governed
+        const deciderId = ctx.runtimeStageId;
+        this.decisions.set(deciderId, {
+            deciderRuntimeStageId: deciderId,
+            chosen: [...event.selected],
+            ...(event.evidence && { evidence: event.evidence }),
+        });
+        this.pending.push({ deciderId, remaining: event.selected.length });
+    }
+    onStageExecuted(event) {
+        const ctx = event.traversalContext;
+        if (!ctx)
+            return;
+        this.resetIfNewRun(ctx.runId);
+        const { runtimeStageId, parentRuntimeStageId } = ctx;
+        if (parentRuntimeStageId) {
+            this.parentOf.set(runtimeStageId, parentRuntimeStageId);
+            this.consumePendingSlot(runtimeStageId, parentRuntimeStageId, /* register */ true);
+        }
+    }
+    /**
+     * A branch that throws never fires `onStageExecuted` — without this hook
+     * its pending slot would leak and the post-fan-out convergence stage
+     * (whose context also chains to the selector) would be misattributed as
+     * a branch entry under best-effort (`failFast: false`) fan-outs.
+     */
+    onError(event) {
+        const ctx = event.traversalContext;
+        if (!ctx)
+            return;
+        this.resetIfNewRun(ctx.runId);
+        if (ctx.parentRuntimeStageId) {
+            // Record the chain AND attribute the failed stage to its decision —
+            // the stage RAN (and may have committed partial writes) because the
+            // decision chose it; failing afterwards doesn't undo the dependency.
+            this.parentOf.set(ctx.runtimeStageId, ctx.parentRuntimeStageId);
+            this.consumePendingSlot(ctx.runtimeStageId, ctx.parentRuntimeStageId, /* register */ true);
+        }
+    }
+    // ── Queries ───────────────────────────────────────────────────────────
+    /**
+     * Resolve the NEAREST governing decision for an execution step: walks the
+     * runtime ancestor chain (the step itself first) until it hits a
+     * registered branch entry. `undefined` when the step is not downstream of
+     * any recorded decision.
+     */
+    lookup(runtimeStageId) {
+        const seen = new Set();
+        let cur = runtimeStageId;
+        while (cur !== undefined && !seen.has(cur)) {
+            seen.add(cur);
+            const deciderId = this.branchEntryToDecision.get(cur);
+            if (deciderId !== undefined) {
+                const record = this.decisions.get(deciderId);
+                return {
+                    deciderId,
+                    ...(record?.ruleLabel !== undefined && { label: record.ruleLabel }),
+                };
+            }
+            cur = this.parentOf.get(cur);
+        }
+        return undefined;
+    }
+    /** The lookup as a bare function — plug into `causalChain(..., { controlDeps })`. */
+    asLookup() {
+        return (runtimeStageId) => this.lookup(runtimeStageId);
+    }
+    /** All decisions recorded for the current run, in event order. */
+    getDecisions() {
+        return [...this.decisions.values()];
+    }
+    /** Reset all state (also happens automatically on runId change). */
+    clear() {
+        this.parentOf.clear();
+        this.decisions.clear();
+        this.branchEntryToDecision.clear();
+        this.pending = [];
+        this.consumedSlots.clear();
+    }
+    // ── Internals ─────────────────────────────────────────────────────────
+    /** Convention 4: a new runId means a new run — reset transient state. */
+    resetIfNewRun(runId) {
+        if (runId === this.lastRunId)
+            return;
+        this.clear();
+        this.lastRunId = runId;
+    }
+    /**
+     * If `parentRuntimeStageId` is a decider with an unmatched pending slot,
+     * consume one. `register` controls whether the stage is recorded as a
+     * branch entry (stage executed/errored) — both paths consume the slot so
+     * counts stay exact even when a stage produces both events.
+     */
+    consumePendingSlot(runtimeStageId, parentRuntimeStageId, register) {
+        if (runtimeStageId === parentRuntimeStageId)
+            return; // synthetic self-events
+        if (this.consumedSlots.has(runtimeStageId))
+            return;
+        for (let i = 0; i < this.pending.length; i++) {
+            const p = this.pending[i];
+            if (p.deciderId !== parentRuntimeStageId)
+                continue;
+            this.consumedSlots.add(runtimeStageId);
+            if (register)
+                this.branchEntryToDecision.set(runtimeStageId, p.deciderId);
+            p.remaining--;
+            if (p.remaining <= 0)
+                this.pending.splice(i, 1);
+            return;
+        }
+    }
+}
+/**
+ * The decide() rule label that produced the decision: the matched rule
+ * mapping to the chosen branch (first matched rule as fallback).
+ */
+function matchedRuleLabel(evidence) {
+    if (!evidence)
+        return undefined;
+    const rule = evidence.rules.find((r) => r.matched && r.branch === evidence.chosen) ?? evidence.rules.find((r) => r.matched);
+    return rule?.label;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ControlDepRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/ControlDepRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ControlDepRecorder — control-dependence tracking from flow events (RFC-003 D5).\n *\n * The gap this fills:\n *   The backtracker's `controlDeps` option (D3) needs a `ControlDepLookup`:\n *   \"which decider execution allowed this stage to run?\" The engine knows\n *   this during traversal but the commit log doesn't record it — control\n *   flow is a FlowRecorder concern. This recorder is the standard producer:\n *   one subscription, one lookup, plug it straight into `causalChain`.\n *\n * How it works — two correlation structures built during traversal:\n *\n *   1. `parentOf` — the runtime ancestor chain, from every stage event's\n *      `traversalContext.parentRuntimeStageId` (RFC-003 D1). Crosses\n *      subflow boundaries; loop re-entries stay unambiguous because\n *      runtime ids differ per iteration.\n *\n *   2. `branchEntryToDecision` — on `onDecision`/`onSelected` the decision\n *      is recorded as PENDING; the next stage(s) executed whose\n *      `parentRuntimeStageId` IS the decider's runtimeStageId are its\n *      branch entries (1 for a decider, N = selected.length for a\n *      selector). Correlation is by parent-id + count, NOT by stage name —\n *      subflow-mount events carry path-prefixed inner-root names that\n *      don't match `FlowDecisionEvent.chosen`, and selectors emit a\n *      synthetic fork event sharing the selector's own runtimeStageId\n *      (excluded via the self-id guard). A branch that THROWS before\n *      completing consumes its slot via `onError`, so the post-fan-out\n *      convergence stage is never misattributed as a branch entry.\n *\n *   `lookup(runtimeStageId)` then walks the ancestor chain from the stage\n *   upward; the first ancestor (or the stage itself) registered as a\n *   branch entry yields its governing decider — the NEAREST decision.\n *   Nested decisions compose naturally: the backtracker expands the\n *   decider node and asks again.\n *\n * Convention 4: state resets when `traversalContext.runId` changes — each\n * run (and each resume, which mints a fresh runId) starts clean. Control\n * chains therefore do NOT survive a pause/resume boundary: post-resume\n * stages cannot resolve pre-pause decisions.\n *\n * @example\n * ```typescript\n * import { controlDepRecorder, causalChain } from 'footprintjs/trace';\n *\n * const ctrl = controlDepRecorder();\n * executor.attachCombinedRecorder(ctrl); // auto-routes to FlowRecorder channel\n *\n * await executor.run({ input });\n *\n * const dag = causalChain(commitLog, 'approve#2', keysRead, {\n *   controlDeps: ctrl.asLookup(),\n * });\n * ```\n */\n\nimport type { DecisionEvidence, SelectionEvidence } from '../decide/types.js';\nimport type {\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowRecorder,\n  FlowSelectedEvent,\n  FlowStageEvent,\n} from '../engine/narrative/types.js';\nimport type { ControlDependency, ControlDepLookup } from '../memory/backtrack.js';\n\n/** One recorded decision/selection event (RFC-003 D5). */\nexport interface ControlDecisionRecord {\n  /** runtimeStageId of the decider/selector execution step. */\n  deciderRuntimeStageId: string;\n  /** Chosen branch display name (decider) or selected names (selector). */\n  chosen: string | readonly string[];\n  /** Structured evidence from decide()/select(), when the stage used them. */\n  evidence?: DecisionEvidence | SelectionEvidence;\n  /**\n   * The decide() rule label that produced the decision (e.g. 'Good credit').\n   * Deciders only — a selector picks N branches and no single label\n   * attributes to all of them (inspect `evidence` instead).\n   */\n  ruleLabel?: string;\n}\n\nexport interface ControlDepRecorderOptions {\n  /** Recorder id. Defaults to `control-deps-N` (auto-incremented). */\n  id?: string;\n}\n\n/** A decision awaiting branch-entry correlation. */\ninterface PendingDecision {\n  deciderId: string;\n  /** How many branch entries are still expected (decider: 1, selector: N). */\n  remaining: number;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `topologyRecorder()` / `inOutRecorder()` style.\n */\nexport function controlDepRecorder(options: ControlDepRecorderOptions = {}): ControlDepRecorder {\n  return new ControlDepRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches FlowRecorder events and answers\n * \"which decision allowed this stage to run?\" Attach via\n * `executor.attachCombinedRecorder(recorder)` (or `attachFlowRecorder`).\n */\nexport class ControlDepRecorder implements FlowRecorder {\n  readonly id: string;\n\n  /** Runtime ancestor chain: runtimeStageId → parentRuntimeStageId (D1). */\n  private readonly parentOf = new Map<string, string>();\n  /** Recorded decisions, keyed by decider runtimeStageId. */\n  private readonly decisions = new Map<string, ControlDecisionRecord>();\n  /** Branch-entry runtimeStageId → governing decider runtimeStageId. */\n  private readonly branchEntryToDecision = new Map<string, string>();\n  /** Decisions whose branch entries have not all been seen yet. */\n  private pending: PendingDecision[] = [];\n  /** Stage ids that already consumed a pending slot (entry OR error). */\n  private readonly consumedSlots = new Set<string>();\n  /** Convention 4 — runId of the run currently being recorded. */\n  private lastRunId?: string;\n\n  constructor(options: ControlDepRecorderOptions = {}) {\n    this.id = options.id ?? `control-deps-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onDecision(event: FlowDecisionEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n\n    const deciderId = ctx.runtimeStageId;\n    const ruleLabel = matchedRuleLabel(event.evidence);\n    this.decisions.set(deciderId, {\n      deciderRuntimeStageId: deciderId,\n      chosen: event.chosen,\n      ...(event.evidence && { evidence: event.evidence }),\n      ...(ruleLabel !== undefined && { ruleLabel }),\n    });\n    this.pending.push({ deciderId, remaining: 1 });\n  }\n\n  onSelected(event: FlowSelectedEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n    if (event.selected.length === 0) return; // nothing selected → nothing governed\n\n    const deciderId = ctx.runtimeStageId;\n    this.decisions.set(deciderId, {\n      deciderRuntimeStageId: deciderId,\n      chosen: [...event.selected],\n      ...(event.evidence && { evidence: event.evidence }),\n    });\n    this.pending.push({ deciderId, remaining: event.selected.length });\n  }\n\n  onStageExecuted(event: FlowStageEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n\n    const { runtimeStageId, parentRuntimeStageId } = ctx;\n    if (parentRuntimeStageId) {\n      this.parentOf.set(runtimeStageId, parentRuntimeStageId);\n      this.consumePendingSlot(runtimeStageId, parentRuntimeStageId, /* register */ true);\n    }\n  }\n\n  /**\n   * A branch that throws never fires `onStageExecuted` — without this hook\n   * its pending slot would leak and the post-fan-out convergence stage\n   * (whose context also chains to the selector) would be misattributed as\n   * a branch entry under best-effort (`failFast: false`) fan-outs.\n   */\n  onError(event: FlowErrorEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n    if (ctx.parentRuntimeStageId) {\n      // Record the chain AND attribute the failed stage to its decision —\n      // the stage RAN (and may have committed partial writes) because the\n      // decision chose it; failing afterwards doesn't undo the dependency.\n      this.parentOf.set(ctx.runtimeStageId, ctx.parentRuntimeStageId);\n      this.consumePendingSlot(ctx.runtimeStageId, ctx.parentRuntimeStageId, /* register */ true);\n    }\n  }\n\n  // ── Queries ───────────────────────────────────────────────────────────\n\n  /**\n   * Resolve the NEAREST governing decision for an execution step: walks the\n   * runtime ancestor chain (the step itself first) until it hits a\n   * registered branch entry. `undefined` when the step is not downstream of\n   * any recorded decision.\n   */\n  lookup(runtimeStageId: string): ControlDependency | undefined {\n    const seen = new Set<string>();\n    let cur: string | undefined = runtimeStageId;\n    while (cur !== undefined && !seen.has(cur)) {\n      seen.add(cur);\n      const deciderId = this.branchEntryToDecision.get(cur);\n      if (deciderId !== undefined) {\n        const record = this.decisions.get(deciderId);\n        return {\n          deciderId,\n          ...(record?.ruleLabel !== undefined && { label: record.ruleLabel }),\n        };\n      }\n      cur = this.parentOf.get(cur);\n    }\n    return undefined;\n  }\n\n  /** The lookup as a bare function — plug into `causalChain(..., { controlDeps })`. */\n  asLookup(): ControlDepLookup {\n    return (runtimeStageId) => this.lookup(runtimeStageId);\n  }\n\n  /** All decisions recorded for the current run, in event order. */\n  getDecisions(): ControlDecisionRecord[] {\n    return [...this.decisions.values()];\n  }\n\n  /** Reset all state (also happens automatically on runId change). */\n  clear(): void {\n    this.parentOf.clear();\n    this.decisions.clear();\n    this.branchEntryToDecision.clear();\n    this.pending = [];\n    this.consumedSlots.clear();\n  }\n\n  // ── Internals ─────────────────────────────────────────────────────────\n\n  /** Convention 4: a new runId means a new run — reset transient state. */\n  private resetIfNewRun(runId: string): void {\n    if (runId === this.lastRunId) return;\n    this.clear();\n    this.lastRunId = runId;\n  }\n\n  /**\n   * If `parentRuntimeStageId` is a decider with an unmatched pending slot,\n   * consume one. `register` controls whether the stage is recorded as a\n   * branch entry (stage executed/errored) — both paths consume the slot so\n   * counts stay exact even when a stage produces both events.\n   */\n  private consumePendingSlot(runtimeStageId: string, parentRuntimeStageId: string, register: boolean): void {\n    if (runtimeStageId === parentRuntimeStageId) return; // synthetic self-events\n    if (this.consumedSlots.has(runtimeStageId)) return;\n\n    for (let i = 0; i < this.pending.length; i++) {\n      const p = this.pending[i];\n      if (p.deciderId !== parentRuntimeStageId) continue;\n\n      this.consumedSlots.add(runtimeStageId);\n      if (register) this.branchEntryToDecision.set(runtimeStageId, p.deciderId);\n      p.remaining--;\n      if (p.remaining <= 0) this.pending.splice(i, 1);\n      return;\n    }\n  }\n}\n\n/**\n * The decide() rule label that produced the decision: the matched rule\n * mapping to the chosen branch (first matched rule as fallback).\n */\nfunction matchedRuleLabel(evidence: DecisionEvidence | undefined): string | undefined {\n  if (!evidence) return undefined;\n  const rule =\n    evidence.rules.find((r) => r.matched && r.branch === evidence.chosen) ?? evidence.rules.find((r) => r.matched);\n  return rule?.label;\n}\n"]}