qlogicagent 2.13.5 → 2.13.6

package/dist/orchestration/workflow/workflow-runtime.d.ts

@@ -1,171 +0,0 @@
-/**
- * WorkflowRuntime — the automation data-routing driver (M2; plan §M2, spec §A1/§A5).
- *
- * Responsibilities (control/data separation, spec §A1):
- *   - DagScheduler v2 owns CONTROL (ready/skip/loop/ports). The runtime owns DATA:
- *     for each ready node it collects upstream outputs along data edges (fromPort→toPort),
- *     resolves param expressions, invokes the registered NodeExecutor, stores outputs, and
- *     reports completion + firedPorts back to the scheduler.
- *   - run-from-node + output cache (spec §A5): cache key = hash(kind + resolved params +
- *     input signature + runIndex). A clean node hits cache (executor skipped); a changed node
- *     and its dirty downstream recompute. This is content-addressed, so successive run() calls
- *     after a param change recompute only the dirty subgraph.
- *   - loop control is runtime-owned (DagScheduler.decideLoop), not a user executor.
- *   - every node passes an injectable budget/permission gate before executing (plan D15).
- *
- * fail-loud: unknown kinds, gate rejections, and executor errors all throw and halt the run.
- */
-import { DagScheduler } from "../dag-scheduler.js";
-import { type PortMap } from "./data-item.js";
-import { NodeRegistry } from "./node-registry.js";
-import type { RunCheckpoint } from "./run-checkpoint-store.js";
-import type { WorkflowDef, ExecutorHost } from "./node-schema.js";
-/** Gate invoked before each node executes (budget / permission). Throw to halt the run. */
-export interface ExecutionGate {
-    check(nodeId: string, kind: string): void;
-    /**
-     * Optionally raise the gate's remaining allowance so a budget-paused run can resume (D15
-     * "抬预算后 resume"). Gates without a budget may omit this. Implementations are fail-loud on
-     * non-positive deltas.
-     */
-    extend?(delta: {
-        executions?: number;
-        durationMs?: number;
-    }): void;
-}
-/**
- * Thrown by a gate (or `pause()`) to suspend the run gracefully. Unlike a plain error this is
- * not a failure: completed work stays cached, and a later `run()` on the same instance resumes
- * (cached nodes hit, only the not-yet-run remainder executes).
- */
-export declare class WorkflowPauseSignal extends Error {
-    readonly atNodeId?: string | undefined;
-    constructor(atNodeId?: string | undefined);
-}
-/** Controlled cancellation requested by the controller/delete path. */
-export declare class WorkflowRunCanceled extends Error {
-    constructor(message?: string);
-}
-/** Per-node execution stats for the run trace (D33, IT-9). */
-export interface NodeRunStats {
-    /** Execution order (1-based; cache hits count too — they advance the dag). */
-    seq: number;
-    startedAt: string;
-    finishedAt: string;
-    durationMs: number;
-    /** Executor attempts actually made (≥1; >1 means retries happened). */
-    attempts: number;
-    /** True when the content-addressed cache satisfied this node (no executor invocation). */
-    cacheHit: boolean;
-    /** Final per-node disposition (errorPort/continue keep the run alive but mark failed). */
-    status: "completed" | "failed";
-}
-export interface RunResult {
-    status: "completed" | "failed" | "paused";
-    /** nodeId → its output PortMap. */
-    outputs: Record<string, PortMap>;
-    /** nodeIds whose executor actually ran in this run (cache misses). */
-    executed: Set<string>;
-    progress: ReturnType<DagScheduler["getProgress"]>;
-    /** Set when status === "paused": the node the run suspended at. */
-    pausedAt?: string;
-    /** Ordered per-node trace (D33): timing, attempts, cache hits, disposition. */
-    nodeStats: Record<string, NodeRunStats>;
-}
-export interface WorkflowRuntimeOptions {
-    registry?: NodeRegistry;
-    gate?: ExecutionGate;
-    now?: () => Date;
-    trigger?: Record<string, unknown>;
-    /** This run's trigger KIND (manual/schedule/…) — exposed on ExecutorContext for IT-7b audits. */
-    triggerKind?: string;
-    log?: {
-        info(m: string): void;
-        warn(m: string): void;
-    };
-    /** Host capabilities for host-backed kinds (agent/tool/http/mcp/channel), D13. */
-    host?: ExecutorHost;
-    /** Cancellation propagated to host calls. */
-    signal?: AbortSignal;
-    /** Durable run checkpoint for crash-restart recovery (plan §M3). */
-    checkpoint?: RunCheckpoint;
-    /**
-     * R5 跨 run 缓存(reuseCache):完成后不清 checkpoint 而是整表回写 —— 同一工作流的
-     * 下一个 run seed 它,未变节点(同 kind+params+inputs 签名)命中跳过(ComfyUI 语义)。
-     * 默认 false = 既有崩溃恢复语义(完成即清)。
-     */
-    preserveCheckpoint?: boolean;
-    /** Per-node lifecycle callback for live status (canvas coloring). Fire-and-forget, not durable. */
-    onNodeStatus?: (nodeId: string, status: "running" | "completed" | "failed") => void;
-}
-export declare class WorkflowRuntime {
-    private def;
-    private readonly registry;
-    private readonly gate?;
-    private readonly now;
-    private readonly trigger?;
-    private readonly triggerKind?;
-    private readonly log?;
-    private readonly host?;
-    private readonly abortController?;
-    private readonly signal;
-    private readonly checkpoint?;
-    private readonly preserveCheckpoint;
-    private readonly onNodeStatus?;
-    private dag;
-    private readonly nodeDefs;
-    private readonly nodeOutputs;
-    /** Content-addressed output cache; persists across run() calls for run-from-node. */
-    private readonly cache;
-    /** loopBack source nodeId → loop controller nodeId. */
-    private readonly loopBackOf;
-    /** Cooperative pause request; honored before the next node executes. */
-    private pauseRequested;
-    /** Per-node trace (D33): seq/timing/attempts/cacheHit/disposition, keyed by nodeId. */
-    private readonly nodeStats;
-    private statsSeq;
-    /** True once the durable checkpoint has been loaded into `cache` (load once per instance). */
-    private checkpointLoaded;
-    constructor(def: WorkflowDef, opts?: WorkflowRuntimeOptions);
-    /** Patch a node's params (for run-from-node param changes). Invalidates nothing directly —
-     * the content-addressed cache recomputes only what changed. */
-    setNodeParams(nodeId: string, params: Record<string, unknown>): void;
-    /** Request a cooperative pause: the in-flight run suspends before the next node executes. */
-    pause(): void;
-    /** Cancel the run and abort the signal exposed to long-running executors. */
-    cancel(reason?: string): void;
-    /**
-     * Raise the budget gate's remaining allowance so a budget-paused run can resume (D15
-     * "抬预算后 resume"). fail-loud if this runtime was built without an extensible budget gate.
-     */
-    extendBudget(delta: {
-        executions?: number;
-        durationMs?: number;
-    }): void;
-    /** Execute the workflow to completion (or until the gate halts / a branch fails / a pause). */
-    run(): Promise<RunResult>;
-    /**
-     * Seed the content-addressed cache from a durable checkpoint (once per instance). After a
-     * crash-restart a fresh runtime replays the DAG; nodes that completed before the crash hit
-     * these entries and their executors are not re-invoked (no duplicate side effects).
-     */
-    private loadCheckpoint;
-    /** Persist the full content-addressed cache so a crash mid-run can resume from here. */
-    private persistCheckpoint;
-    private executeNode;
-    /** Loop entry: fire the "loop" port once to kick the first iteration. */
-    private enterLoop;
-    private decideLoopBack;
-    /** Loop again? No condition → loop until the scheduler's maxIterations cap. */
-    private evalLoopCondition;
-    /** Collect inputs for a node from completed upstream outputs along forward data edges. */
-    private collectInputs;
-    private buildExprContext;
-    private cacheKey;
-    private isCanceled;
-    private canceledError;
-    private throwIfCanceled;
-    /** Cancel-aware sleep for retry backoff: aborts immediately when the run is canceled. */
-    private cancellableDelay;
-    private buildDag;
-}

package/dist/orchestration/workflow/workflow-runtime.js

@@ -1,474 +0,0 @@
-/**
- * WorkflowRuntime — the automation data-routing driver (M2; plan §M2, spec §A1/§A5).
- *
- * Responsibilities (control/data separation, spec §A1):
- *   - DagScheduler v2 owns CONTROL (ready/skip/loop/ports). The runtime owns DATA:
- *     for each ready node it collects upstream outputs along data edges (fromPort→toPort),
- *     resolves param expressions, invokes the registered NodeExecutor, stores outputs, and
- *     reports completion + firedPorts back to the scheduler.
- *   - run-from-node + output cache (spec §A5): cache key = hash(kind + resolved params +
- *     input signature + runIndex). A clean node hits cache (executor skipped); a changed node
- *     and its dirty downstream recompute. This is content-addressed, so successive run() calls
- *     after a param change recompute only the dirty subgraph.
- *   - loop control is runtime-owned (DagScheduler.decideLoop), not a user executor.
- *   - every node passes an injectable budget/permission gate before executing (plan D15).
- *
- * fail-loud: unknown kinds, gate rejections, and executor errors all throw and halt the run.
- */
-import { DagScheduler } from "../dag-scheduler.js";
-import { signaturePortMap, stableStringify } from "./data-item.js";
-import { resolveParams, resolveBinding } from "./expression.js";
-import { NodeRegistry } from "./node-registry.js";
-import { hostExecutors } from "./host-executors.js";
-import { RAW_PARAM_KEYS } from "./builtin-executors.js";
-/**
- * Thrown by a gate (or `pause()`) to suspend the run gracefully. Unlike a plain error this is
- * not a failure: completed work stays cached, and a later `run()` on the same instance resumes
- * (cached nodes hit, only the not-yet-run remainder executes).
- */
-export class WorkflowPauseSignal extends Error {
-    atNodeId;
-    constructor(atNodeId) {
-        super(atNodeId ? `Workflow paused at "${atNodeId}"` : "Workflow paused");
-        this.atNodeId = atNodeId;
-        this.name = "WorkflowPauseSignal";
-    }
-}
-/** Controlled cancellation requested by the controller/delete path. */
-export class WorkflowRunCanceled extends Error {
-    constructor(message = "Workflow run canceled") {
-        super(message);
-        this.name = "WorkflowRunCanceled";
-    }
-}
-export class WorkflowRuntime {
-    def;
-    registry;
-    gate;
-    now;
-    trigger;
-    triggerKind;
-    log;
-    host;
-    abortController;
-    signal;
-    checkpoint;
-    preserveCheckpoint;
-    onNodeStatus;
-    dag;
-    nodeDefs = new Map();
-    nodeOutputs = new Map();
-    /** Content-addressed output cache; persists across run() calls for run-from-node. */
-    cache = new Map();
-    /** loopBack source nodeId → loop controller nodeId. */
-    loopBackOf = new Map();
-    /** Cooperative pause request; honored before the next node executes. */
-    pauseRequested = false;
-    /** Per-node trace (D33): seq/timing/attempts/cacheHit/disposition, keyed by nodeId. */
-    nodeStats = {};
-    statsSeq = 0;
-    /** True once the durable checkpoint has been loaded into `cache` (load once per instance). */
-    checkpointLoaded = false;
-    constructor(def, opts = {}) {
-        this.def = def;
-        this.registry = opts.registry ?? new NodeRegistry();
-        this.gate = opts.gate;
-        this.now = opts.now ?? (() => new Date());
-        this.trigger = opts.trigger;
-        this.triggerKind = opts.triggerKind;
-        this.log = opts.log;
-        this.host = opts.host;
-        this.abortController = opts.signal ? undefined : new AbortController();
-        this.signal = opts.signal ?? this.abortController.signal;
-        this.checkpoint = opts.checkpoint;
-        this.preserveCheckpoint = opts.preserveCheckpoint === true;
-        this.onNodeStatus = opts.onNodeStatus;
-        // Wire host-backed kinds when a host is supplied. A caller that pre-registered a
-        // specialized executor for one of these kinds keeps it (explicit override path).
-        if (this.host) {
-            for (const [kind, exec] of Object.entries(hostExecutors)) {
-                if (!this.registry.has(kind))
-                    this.registry.register(kind, exec);
-            }
-        }
-        for (const n of def.nodes)
-            this.nodeDefs.set(n.id, n);
-        for (const e of def.edges) {
-            if (e.loopBack)
-                this.loopBackOf.set(e.from, e.to);
-        }
-    }
-    /** Patch a node's params (for run-from-node param changes). Invalidates nothing directly —
-     * the content-addressed cache recomputes only what changed. */
-    setNodeParams(nodeId, params) {
-        const def = this.nodeDefs.get(nodeId);
-        if (!def)
-            throw new Error(`Unknown node "${nodeId}"`);
-        def.params = { ...(def.params ?? {}), ...params };
-    }
-    /** Request a cooperative pause: the in-flight run suspends before the next node executes. */
-    pause() {
-        this.pauseRequested = true;
-    }
-    /** Cancel the run and abort the signal exposed to long-running executors. */
-    cancel(reason = "Workflow run canceled") {
-        const err = new WorkflowRunCanceled(reason);
-        if (this.abortController && !this.abortController.signal.aborted) {
-            this.abortController.abort(err);
-        }
-    }
-    /**
-     * Raise the budget gate's remaining allowance so a budget-paused run can resume (D15
-     * "抬预算后 resume"). fail-loud if this runtime was built without an extensible budget gate.
-     */
-    extendBudget(delta) {
-        if (!this.gate?.extend) {
-            throw new Error("WorkflowRuntime has no extensible budget gate to raise");
-        }
-        this.gate.extend(delta);
-    }
-    /** Execute the workflow to completion (or until the gate halts / a branch fails / a pause). */
-    async run() {
-        await this.loadCheckpoint();
-        this.throwIfCanceled();
-        this.dag = this.buildDag();
-        this.nodeOutputs.clear();
-        this.pauseRequested = false;
-        const executed = new Set();
-        let pausedAt;
-        try {
-            let guard = 0;
-            while (!this.dag.isFinished()) {
-                if (++guard > 100_000)
-                    throw new Error("WorkflowRuntime did not converge");
-                const ready = this.dag.getReadyNodes();
-                if (ready.length === 0)
-                    break;
-                for (const node of ready) {
-                    await this.executeNode(node, executed);
-                }
-            }
-        }
-        catch (err) {
-            if (err instanceof WorkflowPauseSignal) {
-                pausedAt = err.atNodeId;
-            }
-            else {
-                throw err;
-            }
-        }
-        const outputs = {};
-        for (const [id, out] of this.nodeOutputs)
-            outputs[id] = out;
-        const status = pausedAt
-            ? "paused"
-            : this.dag.isAllCompleted()
-                ? "completed"
-                : "failed";
-        // A successfully completed run no longer needs its crash-recovery checkpoint —
-        // EXCEPT in reuseCache mode (R5):整表回写共享槽,下个 run seed 它(改参数只重跑下游)。
-        if (status === "completed" && this.checkpoint) {
-            if (this.preserveCheckpoint)
-                await this.persistCheckpoint();
-            else
-                await this.checkpoint.clear();
-        }
-        return { status, outputs, executed, progress: this.dag.getProgress(), pausedAt, nodeStats: { ...this.nodeStats } };
-    }
-    /**
-     * Seed the content-addressed cache from a durable checkpoint (once per instance). After a
-     * crash-restart a fresh runtime replays the DAG; nodes that completed before the crash hit
-     * these entries and their executors are not re-invoked (no duplicate side effects).
-     */
-    async loadCheckpoint() {
-        if (!this.checkpoint || this.checkpointLoaded)
-            return;
-        this.checkpointLoaded = true;
-        const snap = await this.checkpoint.load();
-        if (!snap)
-            return;
-        for (const entry of snap.entries)
-            this.cache.set(entry.key, entry.result);
-    }
-    /** Persist the full content-addressed cache so a crash mid-run can resume from here. */
-    async persistCheckpoint() {
-        if (!this.checkpoint)
-            return;
-        const entries = [...this.cache.entries()].map(([key, result]) => ({ key, result }));
-        await this.checkpoint.persist(entries);
-    }
-    // ── Execution ────────────────────────────────────────────
-    async executeNode(node, executed) {
-        this.throwIfCanceled();
-        if (this.pauseRequested)
-            throw new WorkflowPauseSignal(node.id);
-        if (node.kind === "loop") {
-            // Loop control is bookkeeping, not real work: it does not pass the budget/permission
-            // gate (the scheduler's maxIterations hard-cap bounds loops; the loop BODY nodes pay
-            // budget per iteration via their distinct runIndex cache keys).
-            this.enterLoop(node);
-            return;
-        }
-        const inputs = this.collectInputs(node.id);
-        const exprCtx = this.buildExprContext(inputs);
-        const rawParams = this.nodeDefs.get(node.id)?.params ?? {};
-        // D34: per-item expression params (filter.condition / transform.mapping) stay RAW here —
-        // the executor evaluates them per item with $json bound (same language, same evaluator).
-        const rawKeys = RAW_PARAM_KEYS[node.kind] ?? [];
-        const toResolve = rawKeys.length > 0
-            ? Object.fromEntries(Object.entries(rawParams).filter(([k]) => !rawKeys.includes(k)))
-            : rawParams;
-        const resolvedParams = {
-            ...resolveParams(toResolve, exprCtx),
-            ...Object.fromEntries(rawKeys.filter((k) => k in rawParams).map((k) => [k, rawParams[k]])),
-        };
-        const key = this.cacheKey(node.kind, resolvedParams, inputs, node.runIndex);
-        // D33 trace: timing/attempts/cache disposition for the run-detail view + metrics.
-        const statStartedMs = Date.now();
-        let statAttempts = 0;
-        const recordStats = (status, cacheHit) => {
-            const finished = Date.now();
-            this.nodeStats[node.id] = {
-                seq: ++this.statsSeq,
-                startedAt: new Date(statStartedMs).toISOString(),
-                finishedAt: new Date(finished).toISOString(),
-                durationMs: finished - statStartedMs,
-                attempts: statAttempts,
-                cacheHit,
-                status,
-            };
-        };
-        let result = this.cache.get(key);
-        const wasCacheHit = result !== undefined;
-        let finishedViaErrorPath = false;
-        if (!result) {
-            // The gate guards ACTUAL execution only. A cache hit does no real work (no tokens, no
-            // side effects), so it neither pays budget nor re-checks permission — this is what makes
-            // a budget-paused run genuinely resumable: on resume every pre-pause node hits cache and
-            // the run advances to the first not-yet-run node, which pays against the (raised) budget.
-            this.gate?.check(node.id, node.kind);
-            this.dag.markRunning(node.id);
-            this.onNodeStatus?.(node.id, "running");
-            const reliability = this.nodeDefs.get(node.id);
-            const maxTries = Math.max(1, reliability?.retry?.maxTries ?? 1);
-            const backoffMs = Math.max(0, reliability?.retry?.backoffMs ?? 1000);
-            const timeoutMs = reliability?.timeoutMs;
-            let lastErr;
-            // Reliability loop (D32): per-attempt deadline + bounded retries with exponential backoff.
-            for (let attempt = 0; attempt < maxTries; attempt++) {
-                statAttempts++;
-                this.throwIfCanceled();
-                const execCtx = {
-                    nodeId: node.id,
-                    kind: node.kind,
-                    workflowId: this.def.id,
-                    triggerKind: this.triggerKind,
-                    runIndex: node.runIndex,
-                    vars: this.def.vars ?? {},
-                    trigger: this.trigger,
-                    now: this.now,
-                    log: this.log,
-                    host: this.host,
-                    signal: timeoutMs !== undefined && timeoutMs > 0
-                        ? AbortSignal.any([this.signal, AbortSignal.timeout(timeoutMs)])
-                        : this.signal,
-                };
-                try {
-                    result = await this.registry.get(node.kind)(inputs, resolvedParams, execCtx);
-                    lastErr = undefined;
-                    break;
-                }
-                catch (err) {
-                    if (this.isCanceled())
-                        throw this.canceledError(err);
-                    lastErr = err;
-                    const willRetry = attempt + 1 < maxTries;
-                    this.log?.warn(`node "${node.id}" attempt ${attempt + 1}/${maxTries} failed: ${err instanceof Error ? err.message : String(err)}` +
-                        (willRetry ? ` — retrying in ${backoffMs * 2 ** attempt}ms` : ""));
-                    if (willRetry)
-                        await this.cancellableDelay(backoffMs * 2 ** attempt);
-                }
-            }
-            if (lastErr !== undefined) {
-                const mode = reliability?.onError ?? "stop";
-                const message = lastErr instanceof Error ? lastErr.message : String(lastErr);
-                if (mode === "errorPort") {
-                    // Route the failure out the "error" port (error-handler subgraph runs; the run
-                    // itself survives). The node still SHOWS failed — honesty over green-washing.
-                    this.onNodeStatus?.(node.id, "failed");
-                    result = {
-                        outputs: { error: [{ json: { error: message, nodeId: node.id, kind: node.kind, attempts: maxTries } }] },
-                        firedPorts: ["error"],
-                    };
-                    finishedViaErrorPath = true;
-                }
-                else if (mode === "continue") {
-                    // Fire NO ports → direct downstream skips (DAG skip semantics); sibling branches continue.
-                    this.onNodeStatus?.(node.id, "failed");
-                    result = { outputs: {}, firedPorts: [] };
-                    finishedViaErrorPath = true;
-                }
-                else {
-                    // "stop": surface the per-node "failed" for live canvas coloring before propagating.
-                    this.onNodeStatus?.(node.id, "failed");
-                    recordStats("failed", false);
-                    throw lastErr;
-                }
-            }
-            this.throwIfCanceled();
-            if (!finishedViaErrorPath) {
-                // Error-path synth results are never cached/checkpointed: a resume/re-run must retry
-                // the real work, not replay a stale failure.
-                this.cache.set(key, result);
-                executed.add(node.id);
-                // Durable checkpoint: a crash after this point resumes without re-running this node.
-                await this.persistCheckpoint();
-            }
-            else {
-                executed.add(node.id);
-            }
-        }
-        else {
-            this.dag.markRunning(node.id);
-        }
-        this.nodeOutputs.set(node.id, result.outputs);
-        this.dag.markCompleted(node.id, { output: result.outputs, firedPorts: result.firedPorts });
-        if (!finishedViaErrorPath)
-            this.onNodeStatus?.(node.id, "completed");
-        recordStats(finishedViaErrorPath ? "failed" : "completed", wasCacheHit);
-        // If this node loops back to a controller, decide whether to iterate again.
-        const controllerId = this.loopBackOf.get(node.id);
-        if (controllerId)
-            this.decideLoopBack(controllerId);
-    }
-    /** Loop entry: fire the "loop" port once to kick the first iteration. */
-    enterLoop(node) {
-        this.dag.markRunning(node.id);
-        const out = { loop: [{ json: { iteration: node.iteration ?? 0 } }], done: [] };
-        this.nodeOutputs.set(node.id, out);
-        this.dag.markCompleted(node.id, { output: out, firedPorts: ["loop"] });
-        this.onNodeStatus?.(node.id, "completed");
-    }
-    decideLoopBack(controllerId) {
-        const again = this.evalLoopCondition(controllerId);
-        this.dag.decideLoop(controllerId, again);
-        const ctrl = this.dag.getNode(controllerId);
-        // Keep the controller's published output iteration in sync for body expressions.
-        const fired = ctrl.firedPorts ?? [];
-        this.nodeOutputs.set(controllerId, {
-            loop: fired.includes("loop") ? [{ json: { iteration: ctrl.iteration ?? 0 } }] : [],
-            done: fired.includes("done") ? [{ json: { iteration: ctrl.iteration ?? 0 } }] : [],
-        });
-    }
-    /** Loop again? No condition → loop until the scheduler's maxIterations cap. */
-    evalLoopCondition(controllerId) {
-        const def = this.nodeDefs.get(controllerId);
-        const cond = def?.params?.condition;
-        if (cond === undefined || cond === null || cond === "")
-            return true;
-        const ctx = this.buildExprContext({});
-        return Boolean(typeof cond === "string" ? resolveBinding(cond, ctx) : cond);
-    }
-    // ── Data routing ─────────────────────────────────────────
-    /** Collect inputs for a node from completed upstream outputs along forward data edges. */
-    collectInputs(nodeId) {
-        const inputs = {};
-        for (const e of this.def.edges) {
-            if (e.to !== nodeId || e.loopBack)
-                continue;
-            const fromPort = e.fromPort ?? "default";
-            const toPort = e.toPort ?? "default";
-            const srcOut = this.nodeOutputs.get(e.from);
-            if (!srcOut)
-                continue; // source skipped or not run (e.g. dead branch)
-            const items = srcOut[fromPort];
-            if (!items)
-                continue;
-            (inputs[toPort] ??= []).push(...items);
-        }
-        return inputs;
-    }
-    buildExprContext(inputs) {
-        const nodes = {};
-        for (const [id, out] of this.nodeOutputs)
-            nodes[id] = { output: out };
-        return {
-            input: inputs,
-            json: inputs.default?.[0]?.json ?? {},
-            nodes,
-            vars: this.def.vars ?? {},
-            trigger: this.trigger,
-            now: this.now,
-        };
-    }
-    cacheKey(kind, params, inputs, runIndex) {
-        return stableStringify([kind, params, signaturePortMap(inputs), runIndex]);
-    }
-    isCanceled() {
-        return this.signal.aborted;
-    }
-    canceledError(err) {
-        const reason = this.signal.reason;
-        if (reason instanceof WorkflowRunCanceled)
-            return reason;
-        if (reason instanceof Error)
-            return new WorkflowRunCanceled(reason.message);
-        if (err instanceof WorkflowRunCanceled)
-            return err;
-        if (err instanceof Error && this.signal.aborted)
-            return new WorkflowRunCanceled(err.message);
-        return new WorkflowRunCanceled(reason === undefined ? "Workflow run canceled" : String(reason));
-    }
-    throwIfCanceled() {
-        if (this.isCanceled())
-            throw this.canceledError();
-    }
-    /** Cancel-aware sleep for retry backoff: aborts immediately when the run is canceled. */
-    cancellableDelay(ms) {
-        if (ms <= 0)
-            return Promise.resolve();
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => { this.signal.removeEventListener("abort", onAbort); resolve(); }, ms);
-            const onAbort = () => { clearTimeout(timer); reject(this.canceledError()); };
-            this.signal.addEventListener("abort", onAbort, { once: true });
-        });
-    }
-    // ── DAG construction ─────────────────────────────────────
-    buildDag() {
-        const defs = this.def.nodes.map(n => {
-            let outPorts = n.outPorts ?? defaultOutPorts(n.kind);
-            // onError:"errorPort" routes final failures out an "error" port (D32) — the DAG must
-            // know the port exists for error edges to validate/fire.
-            if (n.onError === "errorPort" && !outPorts.includes("error"))
-                outPorts = [...outPorts, "error"];
-            return {
-                id: n.id,
-                kind: n.kind,
-                params: n.params ?? {},
-                outPorts,
-                joinPolicy: n.joinPolicy ?? "all",
-                maxIterations: n.maxIterations,
-            };
-        });
-        const dag = new DagScheduler(defs);
-        // Forward edges first, loopBack edges last (loopBack validation needs the controller present).
-        for (const e of this.def.edges) {
-            if (e.loopBack)
-                continue;
-            dag.addEdge({ from: e.from, to: e.to, fromPort: e.fromPort ?? "default" });
-        }
-        for (const e of this.def.edges) {
-            if (!e.loopBack)
-                continue;
-            dag.addEdge({ from: e.from, to: e.to, loopBack: true });
-        }
-        return dag;
-    }
-}
-function defaultOutPorts(kind) {
-    if (kind === "if")
-        return ["true", "false"];
-    if (kind === "loop")
-        return ["loop", "done"];
-    return ["default"];
-}