@qaick/executor 0.1.0-alpha.1

package/dist/migrated-runner-engine.js

@@ -0,0 +1,705 @@
+import { InMemoryActionAdapter } from './migrated-adapter.js';
+import { hashExecutionPackage } from './migrated-artifact-hash.js';
+import { RUNNER_PACKAGE_SCHEMA_VERSION } from './migrated-types.js';
+function withRuntimeValues(context, runtimeValues) {
+    return { ...context, runtimeValues: runtimeValues ?? {} };
+}
+const MAX_EXECUTION_TIMEOUT_MS = 300_000;
+const MAX_PARALLEL_BRANCHES = 32;
+export class MigratedRunnerEngine {
+    adapters;
+    runs = new Map();
+    constructor(adapters = [new InMemoryActionAdapter()]) {
+        this.adapters = adapters;
+    }
+    async submit(request) {
+        let resultResolve;
+        const resultPromise = new Promise(resolve => { resultResolve = resolve; });
+        const timeoutMs = request.options?.timeoutMs;
+        const debugSession = { breakpoints: [...(request.debugSession?.breakpoints ?? [])], ...(request.debugSession?.stopAfterStepId ? { stopAfterStepId: request.debugSession.stopAfterStepId } : {}), ...(request.debugSession?.selectedStepId ? { selectedStepId: request.debugSession.selectedStepId } : {}) };
+        const run = { request, debugSession, hitBreakpoints: new Set(), events: [], listeners: [], resultResolve, cancelled: false, timedOut: false, timeoutAt: timeoutMs === undefined ? undefined : Date.now() + timeoutMs, abortController: new AbortController(), controlState: 'idle', pauseRequested: false, stepRequested: false, controlWaiters: [], startedMs: Date.now(), pausedDurationMs: 0 };
+        this.runs.set(request.requestId, run);
+        void this.execute(run, resultPromise);
+        return { requestId: request.requestId };
+    }
+    async cancel(requestId) { const run = this.runs.get(requestId); if (run) {
+        run.cancelled = true;
+        run.controlState = 'stopped';
+        run.abortController.abort();
+        run.controlWaiters.splice(0).forEach(resolve => resolve());
+        run.listeners.splice(0).forEach(resolve => resolve());
+    } }
+    async pauseExecution(requestId) { const run = this.runs.get(requestId); if (!run || run.result || run.cancelled || run.controlState === 'paused' || run.controlState === 'pause-requested')
+        return; run.pauseRequested = true; run.controlState = 'pause-requested'; this.emit(run, 'waiting', 'waiting', 'Pause requested; Runner will pause before the next executable boundary.', undefined, undefined, undefined, { type: 'pause-requested' }); }
+    async resumeExecution(requestId) { const run = this.runs.get(requestId); if (!run || run.result || run.cancelled || (!run.pauseRequested && run.controlState !== 'paused'))
+        return; run.pauseRequested = false; run.controlState = 'resuming'; run.controlWaiters.splice(0).forEach(resolve => resolve()); this.emit(run, 'waiting', 'waiting', 'Execution resumed.', undefined, undefined, undefined, { type: 'resumed' }); }
+    async stepExecution(requestId) { const run = this.runs.get(requestId); if (!run || run.result || run.cancelled || run.controlState !== 'paused')
+        return; run.pauseRequested = false; run.stepRequested = true; run.controlState = 'resuming'; run.controlWaiters.splice(0).forEach(resolve => resolve()); this.emit(run, 'waiting', 'waiting', 'Step requested; Runner will execute one boundary.', undefined, undefined, undefined, { type: 'step-requested' }); }
+    async retryAction(requestId, stepId, invocationPath) { const run = this.runs.get(requestId); if (!run || !run.result || run.cancelled)
+        return; const stepResult = findStepResult(run.result.steps, stepId, invocationPath); const step = findExecutionStep(run.request.executionPackage.steps, stepId, invocationPath); if (!stepResult || !step || step.kind === 'operation' || step.kind === 'control-block' || stepResult.state === 'skipped') {
+        this.emit(run, 'waiting', 'waiting', `Interactive retry unavailable for ${stepId}.`, step, undefined, undefined, { type: 'interactive-retry-requested', stepId });
+        return;
+    } const adapter = this.adapters.find(candidate => candidate.supports(step.action)); if (!adapter) {
+        this.emit(run, 'waiting', 'waiting', `Interactive retry unavailable for ${step.name}: no Action adapter.`, step, undefined, undefined, { type: 'interactive-retry-requested', stepId });
+        return;
+    } const previousAttempts = stepResult.attempts ?? [{ attempt: 1, kind: 'automatic', state: stepResult.state === 'failed' ? 'failed' : 'finished', startedAt: run.result.startedAt, finishedAt: run.result.finishedAt, inputs: { ...stepResult.inputs }, outputs: { ...stepResult.outputs }, durationMs: stepResult.durationMs, ...(stepResult.error ? { error: stepResult.error } : {}) }]; const attempt = previousAttempts.length + 1; const startedAt = new Date().toISOString(); const startedMs = Date.now(); this.emit(run, 'waiting', 'waiting', `Interactive retry requested for ${step.name}.`, step, undefined, undefined, { type: 'interactive-retry-requested', stepId }); this.emit(run, 'step_started', 'running', `${step.name} retry attempt ${attempt} started.`, step); let outputs; let error; try {
+        outputs = await adapter.execute(withRuntimeValues({ action: step.action, inputs: { ...stepResult.inputs }, environment: run.request.environment, step, signal: run.abortController.signal }, run.request.runtimeValues));
+    }
+    catch (cause) {
+        error = { code: isAdapterError(cause) ? cause.code : 'ACTION_FAILED', message: cause instanceof Error ? cause.message : `Action ${step.action} failed.` };
+    } const finishedAt = new Date().toISOString(); const durationMs = Date.now() - startedMs; const interactiveAttempt = { attempt, kind: 'interactive', state: outputs ? 'finished' : 'failed', startedAt, finishedAt, inputs: { ...stepResult.inputs }, outputs: outputs ?? {}, durationMs, ...(error ? { error } : {}) }; stepResult.attempts = [...previousAttempts, interactiveAttempt]; stepResult.durationMs = durationMs; if (outputs) {
+        stepResult.state = 'finished';
+        stepResult.outputs = outputs;
+        delete stepResult.error;
+        stepResult.terminalReason = 'completed';
+    }
+    else {
+        stepResult.state = 'failed';
+        stepResult.outputs = {};
+        stepResult.error = error;
+        stepResult.terminalReason = 'failed';
+    } this.emit(run, 'step_finished', outputs ? 'finished' : 'failed', `${step.name} retry attempt ${attempt} ${outputs ? 'finished' : 'failed'}.`, step); this.emit(run, 'waiting', 'waiting', `Interactive retry attempt ${attempt} ${outputs ? 'completed' : 'failed'}.`, step, undefined, undefined, { type: 'retry-attempt-completed', stepId }); if (outputs && run.result.state === 'failed') {
+        run.result.state = 'completed';
+        run.result.terminalReason = 'completed';
+        delete run.result.error;
+    } }
+    async retryOperation(requestId, stepId, invocationPath) { const run = this.runs.get(requestId); if (!run || !run.result || run.cancelled)
+        return; const stepResult = findStepResult(run.result.steps, stepId, invocationPath); const step = findExecutionStep(run.request.executionPackage.steps, stepId, invocationPath); if (!stepResult || !step || step.kind !== 'operation' || !step.children?.length || stepResult.state === 'skipped') {
+        this.emit(run, 'waiting', 'waiting', `Interactive Operation retry unavailable for ${stepId}.`, step, undefined, undefined, { type: 'interactive-retry-requested', stepId });
+        return;
+    } const childPackage = { ...run.request.executionPackage, target: { kind: 'flow', id: `${run.request.executionPackage.target.id}:${step.id}`, name: step.name }, steps: step.children, flows: undefined, requiredInputs: [] }; const childEngine = new MigratedRunnerEngine(this.adapters); const retryRequestId = `${requestId}:operation-retry:${step.id}:${(stepResult.attempts?.length ?? 0) + 1}`; const startedAt = new Date().toISOString(); const startedMs = Date.now(); this.emit(run, 'waiting', 'waiting', `Interactive Operation retry requested for ${step.name}.`, step, undefined, undefined, { type: 'interactive-retry-requested', stepId }); this.emit(run, 'step_started', 'running', `${step.name} retry attempt ${(stepResult.attempts?.length ?? 0) + 1} started.`, step); await childEngine.submit({ requestId: retryRequestId, executionPackage: childPackage, inputs: run.request.inputs, environment: run.request.environment, runtimeValues: run.request.runtimeValues, options: run.request.options }); const retryResult = await childEngine.result(retryRequestId); const finishedAt = new Date().toISOString(); const durationMs = Date.now() - startedMs; const previousAttempts = stepResult.attempts ?? [{ attempt: 1, kind: 'automatic', state: stepResult.state === 'failed' ? 'failed' : 'finished', startedAt: run.result.startedAt, finishedAt: run.result.finishedAt, inputs: {}, outputs: { ...stepResult.outputs }, durationMs: stepResult.durationMs, children: stepResult.children?.map(child => ({ ...child, attempts: child.attempts })) }]; const attempt = previousAttempts.length + 1; const interactiveAttempt = { attempt, kind: 'interactive', state: retryResult.state === 'completed' ? 'finished' : 'failed', startedAt, finishedAt, inputs: {}, outputs: { ...stepResult.outputs }, durationMs, children: retryResult.steps, ...(retryResult.error ? { error: retryResult.error } : {}) }; stepResult.attempts = [...previousAttempts, interactiveAttempt]; stepResult.children = retryResult.steps; stepResult.state = retryResult.state === 'completed' ? 'finished' : 'failed'; stepResult.durationMs = durationMs; if (retryResult.state === 'completed') {
+        stepResult.outputs = retryResult.steps.at(-1)?.outputs ?? {};
+        delete stepResult.error;
+        stepResult.terminalReason = 'completed';
+        if (run.result.state === 'failed') {
+            run.result.state = 'completed';
+            run.result.terminalReason = 'completed';
+            delete run.result.error;
+        }
+    }
+    else {
+        stepResult.error = retryResult.error;
+        stepResult.terminalReason = 'failed';
+    } this.emit(run, 'step_finished', retryResult.state === 'completed' ? 'finished' : 'failed', `${step.name} retry attempt ${attempt} ${retryResult.state === 'completed' ? 'finished' : 'failed'}.`, step); this.emit(run, 'waiting', 'waiting', `Interactive Operation retry attempt ${attempt} ${retryResult.state === 'completed' ? 'completed' : 'failed'}.`, step, undefined, undefined, { type: 'retry-attempt-completed', stepId }); }
+    async runFromHere(requestId, stepId, invocationPath) { const run = this.runs.get(requestId); if (!run?.result)
+        return undefined; const step = findExecutionStep(run.request.executionPackage.steps, stepId, invocationPath); const selected = findStepResult(run.result.steps, stepId, invocationPath); if (!step || !selected || selected.state === 'skipped')
+        return undefined; const available = new Map(); for (const item of flattenStepResults(run.result.steps))
+        for (const [name, value] of Object.entries(item.outputs))
+            available.set(`${item.id}.${name}`, value); const staticInputs = { ...(step.staticInputs ?? {}) }; for (const [name, reference] of Object.entries(step.bindings ?? {})) {
+        const match = /^\$steps\.([^.]+)\.(.+)$/.exec(reference);
+        if (match) {
+            const value = available.get(`${match[1]}.${match[2]}`);
+            if (value === undefined)
+                return undefined;
+            staticInputs[name] = value;
+        }
+    } const targetedStep = { ...step, bindings: undefined, staticInputs }; const targetedPackage = { ...run.request.executionPackage, target: { kind: 'flow', id: `${run.request.executionPackage.target.id}:from:${step.id}`, name: `${run.request.executionPackage.target.name} · ${step.name}` }, steps: step.kind === 'operation' ? step.children ?? [targetedStep] : [targetedStep], flows: undefined, requiredInputs: [] }; const targetedRequestId = `${requestId}:from:${step.id}:${Date.now()}`; await this.submit({ requestId: targetedRequestId, executionPackage: targetedPackage, inputs: run.request.inputs, environment: run.request.environment, runtimeValues: run.request.runtimeValues, options: run.request.options }); const targetRun = this.runs.get(targetedRequestId); if (targetRun)
+        void this.result(targetedRequestId).then(result => { result.provenance = { kind: 'run-from-here', sourceRequestId: requestId, sourceArtifactHash: run.result?.artifactHash, selectedStepId: step.id, ...(selected.invocationPath ? { selectedInvocationPath: selected.invocationPath } : {}), omittedStepIds: run.request.executionPackage.steps.flatMap(item => item.id === step.id ? [] : [item.id]) }; }); return { requestId: targetedRequestId }; }
+    controlState(requestId) { return this.runs.get(requestId)?.controlState; }
+    debugSession(requestId) { const session = this.runs.get(requestId)?.debugSession; return session ? { ...session, breakpoints: [...session.breakpoints] } : undefined; }
+    async *events(requestId) {
+        const run = this.runs.get(requestId);
+        if (!run)
+            return;
+        let index = 0;
+        while (true) {
+            while (index < run.events.length)
+                yield run.events[index++];
+            if (run.result)
+                return;
+            await new Promise(resolve => run.listeners.push(resolve));
+        }
+    }
+    async result(requestId) {
+        const run = this.runs.get(requestId);
+        if (!run)
+            throw new Error(`Unknown request: ${requestId}`);
+        if (run.result)
+            return run.result;
+        return new Promise(resolve => { const previous = run.resultResolve; run.resultResolve = result => { previous(result); resolve(result); }; });
+    }
+    async execute(run, resultPromise) {
+        const { request } = run;
+        const startedAt = new Date().toISOString();
+        run.controlState = 'running';
+        this.emit(run, 'run_started', 'created', 'Run accepted.');
+        this.emit(run, 'preflight_started', 'preflighting', 'Validating package and runtime inputs.');
+        if (!await this.pause(run, 250)) {
+            this.finishCancelled(run, startedAt, []);
+            return;
+        }
+        if (request.options?.timeoutMs !== undefined && (request.options.timeoutMs <= 0 || request.options.timeoutMs > MAX_EXECUTION_TIMEOUT_MS)) {
+            this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], error: { code: 'EXECUTION_BUDGET_EXCEEDED', message: `Execution timeout must be between 1ms and ${MAX_EXECUTION_TIMEOUT_MS}ms.` } });
+            await resultPromise;
+            return;
+        }
+        const validationIssues = this.validateAll(request.executionPackage, request.inputs, request.runtimeValues ?? {});
+        const validationWarnings = this.validateBrowserWarnings(request.executionPackage);
+        if (request.options?.dryRun) {
+            const dryRunResult = { requestId: request.requestId, state: validationIssues.length ? 'failed' : 'completed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], terminalReason: validationIssues.length ? 'failed' : 'completed', issues: validationIssues, warnings: validationWarnings, ...(validationIssues.length ? { error: { code: 'DRY_RUN_ISSUES', message: `${validationIssues.length} issue${validationIssues.length === 1 ? '' : 's'} found during dry run.` } } : {}) };
+            this.finish(run, dryRunResult);
+            await resultPromise;
+            return;
+        }
+        const validationError = validationIssues.find(issue => !['INVALID_BINDING', 'MISSING_INPUT_BINDING', 'MISSING_STEP_BINDING'].includes(issue.code));
+        if (validationError) {
+            this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], warnings: validationWarnings, error: validationError });
+            return;
+        }
+        const steps = [];
+        const stepOutputs = {};
+        const failedStepIds = new Set();
+        const loopStartedAt = new Map();
+        let plannedSteps;
+        try {
+            plannedSteps = this.orderSteps(this.flattenSteps(request.executionPackage.steps, [], 0, false, undefined, undefined, undefined, request.inputs));
+        }
+        catch (cause) {
+            const error = { code: cause instanceof Error && cause.message.startsWith('Graph') ? 'INVALID_GRAPH' : 'RECURSION_LIMIT', message: cause instanceof Error ? cause.message : 'The execution graph is invalid.' };
+            this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], error });
+            return;
+        }
+        for (let plannedIndex = 0; plannedIndex < plannedSteps.length; plannedIndex += 1) {
+            const planned = plannedSteps[plannedIndex];
+            if (!await this.waitForSafeBoundary(run, planned.step, planned.path)) {
+                this.finishCancelled(run, startedAt, steps);
+                return;
+            }
+            if (planned.parallelGroup) {
+                const group = [];
+                while (plannedIndex < plannedSteps.length && plannedSteps[plannedIndex].parallelGroup === planned.parallelGroup)
+                    group.push(plannedSteps[plannedIndex++]);
+                plannedIndex -= 1;
+                // Parallel execution uses a run-level cooperative policy: inspect every
+                // branch before starting any adapter. A breakpoint in any branch pauses
+                // the whole group at this safe boundary.
+                for (const candidate of group.slice(1)) {
+                    if (!await this.waitForSafeBoundary(run, candidate.step, candidate.path)) {
+                        this.finishCancelled(run, startedAt, steps);
+                        return;
+                    }
+                }
+                const parallel = await this.executeParallelGroup(run, group, request, stepOutputs, failedStepIds);
+                steps.push(...parallel.results);
+                for (const item of parallel.outputs)
+                    stepOutputs[item.id] = item.outputs;
+                if (parallel.mergedOutputs)
+                    stepOutputs[planned.parallelGroup] = parallel.mergedOutputs;
+                for (const item of parallel.failed)
+                    failedStepIds.add(item);
+                if (parallel.cancelled) {
+                    this.finishCancelled(run, startedAt, steps);
+                    return;
+                }
+                const stopAfterStep = parallel.results.find(result => result.state === 'finished' && result.id === run.debugSession.stopAfterStepId);
+                if (stopAfterStep) {
+                    const plannedStopAfter = group.find(item => item.step.id === stopAfterStep.id);
+                    if (plannedStopAfter && !await this.pauseAfterStopAfter(run, plannedStopAfter.step)) {
+                        this.finishCancelled(run, startedAt, steps);
+                        return;
+                    }
+                }
+                const terminalFailure = parallel.errors.find(item => !item.continueOnError);
+                if (terminalFailure) {
+                    this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps, error: terminalFailure.error });
+                    return;
+                }
+                continue;
+            }
+            const { step } = planned;
+            const invocationId = `${request.requestId}:${planned.path.join('.')}`;
+            if (run.cancelled) {
+                this.finish(run, { requestId: request.requestId, state: 'cancelled', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps });
+                return;
+            }
+            if (planned.guards?.some(condition => !conditionMatches(condition, request.inputs, stepOutputs))) {
+                steps.push({ id: step.id, name: step.name, state: 'skipped', terminalReason: 'condition-skipped', inputs: {}, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration });
+                continue;
+            }
+            if (step.dependsOn?.some(dependency => failedStepIds.has(dependency))) {
+                steps.push({ id: step.id, name: step.name, state: 'skipped', terminalReason: 'dependency-skipped', inputs: {}, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration });
+                continue;
+            }
+            if (planned.iteration && planned.loopDurationMs !== undefined) {
+                const loopStarted = loopStartedAt.get(planned.iteration.loopId) ?? Date.now();
+                loopStartedAt.set(planned.iteration.loopId, loopStarted);
+                if (Date.now() - loopStarted >= planned.loopDurationMs)
+                    continue;
+            }
+            if (planned.iteration && planned.iteration.current > 1 && planned.iterationDelayMs && !await this.pause(run, planned.iterationDelayMs)) {
+                this.finishCancelled(run, startedAt, steps);
+                return;
+            }
+            const stepInputs = this.resolveInputs(step, request.inputs, stepOutputs);
+            if (!stepInputs) {
+                const error = { code: 'BINDING_FAILED', message: `Bindings for ${step.name} could not be resolved.` };
+                steps.push({ id: step.id, name: step.name, state: 'failed', inputs: {}, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration, error });
+                failedStepIds.add(step.id);
+                if (!planned.continueOnError) {
+                    this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps, error });
+                    return;
+                }
+                continue;
+            }
+            const stepStarted = Date.now();
+            this.emit(run, 'step_started', 'running', `${step.name} started.`, step, planned.iteration);
+            if (!await this.pause(run, 450)) {
+                this.finishCancelled(run, startedAt, steps);
+                return;
+            }
+            this.emit(run, 'waiting', 'waiting', `${step.name} waiting for its Action adapter.`, step, planned.iteration);
+            if (!await this.pause(run, 450)) {
+                this.finishCancelled(run, startedAt, steps);
+                return;
+            }
+            const adapter = this.adapters.find(candidate => candidate.supports(step.action));
+            if (!adapter) {
+                const error = { code: 'MISSING_ACTION_ADAPTER', message: `No adapter is registered for ${step.action}.` };
+                steps.push({ id: step.id, name: step.name, state: 'failed', inputs: stepInputs, outputs: {}, durationMs: Date.now() - stepStarted, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration, error });
+                failedStepIds.add(step.id);
+                if (!planned.continueOnError) {
+                    this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps, error });
+                    return;
+                }
+                continue;
+            }
+            const maxAttempts = Math.max(1, step.retry?.maxAttempts ?? 1);
+            const transportStartedAt = new Date().toISOString();
+            const transportStartedMs = Date.now();
+            let outputs;
+            let lastError;
+            for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+                try {
+                    outputs = await adapter.execute(withRuntimeValues({ action: step.action, inputs: stepInputs, environment: request.environment, step, signal: run.abortController.signal }, request.runtimeValues));
+                    break;
+                }
+                catch (cause) {
+                    lastError = cause;
+                    if (run.cancelled || run.timedOut) {
+                        this.finishCancelled(run, startedAt, steps);
+                        return;
+                    }
+                    if (attempt < maxAttempts) {
+                        this.emit(run, 'waiting', 'waiting', `${step.name} retrying (${attempt + 1}/${maxAttempts}).`, step, planned.iteration);
+                        if (!await this.pause(run, step.retry?.delayMs ?? 100)) {
+                            this.finishCancelled(run, startedAt, steps);
+                            return;
+                        }
+                    }
+                }
+            }
+            if (!outputs) {
+                const error = { code: isAdapterError(lastError) ? lastError.code : 'ACTION_FAILED', message: lastError instanceof Error ? lastError.message : `Action ${step.action} failed.` };
+                steps.push({ id: step.id, name: step.name, state: 'failed', inputs: stepInputs, outputs: {}, durationMs: Date.now() - stepStarted, transportTiming: { requestStartedAt: transportStartedAt, responseReceivedAt: new Date().toISOString(), durationMs: Date.now() - transportStartedMs }, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration, error });
+                failedStepIds.add(step.id);
+                if (!planned.continueOnError) {
+                    this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps, error });
+                    return;
+                }
+                continue;
+            }
+            if (step.delayMs && !await this.pause(run, step.delayMs)) {
+                this.finishCancelled(run, startedAt, steps);
+                return;
+            }
+            stepOutputs[step.id] = outputs;
+            steps.push({ id: step.id, name: step.name, state: 'finished', inputs: stepInputs, outputs, durationMs: Date.now() - stepStarted, transportTiming: { requestStartedAt: transportStartedAt, responseReceivedAt: new Date().toISOString(), durationMs: Date.now() - transportStartedMs }, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration });
+            this.emit(run, 'step_finished', 'finished', `${step.name} finished.`, step, planned.iteration);
+            if (!await this.pauseAfterStopAfter(run, step)) {
+                this.finishCancelled(run, startedAt, steps);
+                return;
+            }
+        }
+        this.finish(run, { requestId: request.requestId, state: 'completed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: this.normalizeResults(steps, request.executionPackage.steps), warnings: validationWarnings });
+        await resultPromise;
+    }
+    validateAll(pack, inputs, runtimeValues) {
+        const issues = [];
+        if (pack.schemaVersion !== RUNNER_PACKAGE_SCHEMA_VERSION)
+            issues.push({ code: 'UNSUPPORTED_SCHEMA', message: `Schema ${pack.schemaVersion} is not supported.` });
+        if (!pack.steps.length)
+            issues.push({ code: 'EMPTY_TARGET', message: 'The selected target contains no executable steps.' });
+        for (const step of walkSteps(pack.steps)) {
+            for (const issue of unsupportedControlSettings(step))
+                issues.push({ ...issue, stepId: step.id });
+        }
+        const requiredInputs = pack.requiredInputs ?? ['customerId'];
+        for (const name of requiredInputs.filter(name => inputs[name] === undefined || inputs[name] === null || inputs[name] === ''))
+            issues.push({ code: 'MISSING_INPUT', message: `Required input ${name} is missing.` });
+        for (const missingRuntime of (pack.runtimeRequirements ?? []).filter(name => runtimeValues[name] === undefined || runtimeValues[name] === null || runtimeValues[name] === ''))
+            issues.push({ code: 'MISSING_RUNTIME_VALUE', message: `Required runtime value ${missingRuntime} is missing.` });
+        let planned = [];
+        try {
+            planned = this.flattenSteps(pack.steps);
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : 'The execution graph is invalid.';
+            issues.push({ code: message.startsWith('Nested execution depth') ? 'RECURSION_LIMIT' : 'INVALID_GRAPH', message });
+        }
+        const graphStepIds = new Set();
+        const graphStepsById = new Map();
+        const collectGraphStepIds = (steps) => steps.forEach(step => { graphStepIds.add(step.id); graphStepsById.set(step.id, step); if (step.children)
+            collectGraphStepIds(step.children); if (step.control?.branches)
+            step.control.branches.forEach(branch => collectGraphStepIds(branch.children)); });
+        collectGraphStepIds(pack.steps);
+        for (const step of walkSteps(pack.steps))
+            if (step.control?.type === 'parallel' && (step.control.branches?.length ?? 0) > MAX_PARALLEL_BRANCHES)
+                issues.push({ code: 'PARALLEL_LIMIT_EXCEEDED', message: `Parallel Control Block ${step.name} has ${step.control.branches.length} branches; the maximum is ${MAX_PARALLEL_BRANCHES}.`, stepId: step.id });
+        for (const item of planned) {
+            if (!pack.definitions.some(definition => definition.kind === 'action' && definition.id === item.step.action) && item.step.kind !== 'control-block')
+                issues.push({ code: 'MISSING_ACTION_DEFINITION', message: `Action definition ${item.step.action} is not present in the package.`, stepId: item.step.id });
+            for (const [name, reference] of Object.entries(item.step.bindings ?? {})) {
+                const match = /^\$(inputs|steps)\.([^.]+)(?:\.(.+))?$/.exec(reference);
+                if (!match)
+                    issues.push({ code: 'INVALID_BINDING', message: `Binding ${name} on ${item.step.name} is invalid.`, stepId: item.step.id });
+                else if (match[1] === 'inputs' && (inputs[match[2]] === undefined || inputs[match[2]] === null || inputs[match[2]] === ''))
+                    issues.push({ code: 'MISSING_INPUT_BINDING', message: `Binding ${name} on ${item.step.name} requires input ${match[2]}.`, stepId: item.step.id });
+                else if (match[1] === 'steps' && !graphStepIds.has(match[2]))
+                    issues.push({ code: 'MISSING_STEP_BINDING', message: `Binding ${name} on ${item.step.name} references step ${match[2]}, but that step is not present in the loaded execution graph. Check for a stale Studio node ID, a deleted or moved node, or a binding that crosses an Operation/loop scope.`, stepId: item.step.id });
+                else if (match[1] === 'steps' && match[3] && !Object.prototype.hasOwnProperty.call(graphStepsById.get(match[2])?.output ?? {}, match[3]))
+                    issues.push({ code: 'MISSING_STEP_OUTPUT', message: `Binding ${name} on ${item.step.name} requests output ${match[3]} from step ${match[2]}, but that output is not declared by the source step.`, stepId: item.step.id });
+            }
+        }
+        return [...new Map(issues.map(issue => [`${issue.code}|${issue.stepId ?? ''}|${issue.message}`, issue])).values()];
+    }
+    validateBrowserWarnings(pack) {
+        const warnings = [];
+        for (const step of walkSteps(pack.steps)) {
+            if (!step.action.startsWith('http.'))
+                continue;
+            warnings.push({ code: 'BROWSER_CORS_REQUIRED', message: `HTTP Action ${step.name} runs in the browser and requires the target API to allow CORS.`, stepId: step.id });
+            const headers = step.staticInputs?.headers;
+            const hasCredentialHeader = headers && typeof headers === 'object' && Object.keys(headers).some(name => /(authorization|token|secret|password|api[-_]?key|cookie)/i.test(name));
+            const hasCredentialTemplate = JSON.stringify(step.staticInputs ?? {}).match(/\{\{\s*\$?(?:inputs\.)?(?:authorization|token|secret|password|api[-_]?key|cookie)/i);
+            if (hasCredentialHeader || hasCredentialTemplate)
+                warnings.push({ code: 'BROWSER_CREDENTIAL_EXPOSURE', message: `HTTP Action ${step.name} sends credential-like data from the browser; credentials may be exposed to page and network tooling.`, stepId: step.id });
+        }
+        return warnings;
+    }
+    flattenSteps(steps, parentPath = [], depth = 0, continueOnError = false, iteration, loopDurationMs, iterationDelayMs, inputs = {}, guards = []) {
+        if (depth > 32)
+            throw new Error('Nested execution depth exceeded.');
+        return steps.flatMap(step => {
+            if ((step.control?.type === 'condition' || step.control?.type === 'repeat') && step.control.condition === false)
+                return [];
+            const nestedChildren = step.children;
+            if (!nestedChildren?.length)
+                return [{ step, path: [...parentPath, step.id], continueOnError, iteration, loopDurationMs: loopDurationMs ?? step.control?.durationMs, iterationDelayMs: iterationDelayMs ?? step.control?.iterationDelayMs, guards }];
+            const childContinueOnError = continueOnError || step.control?.onError === 'continue';
+            const conditionGuards = step.control?.type === 'condition' && step.control.condition !== undefined ? [...guards, step.control.condition] : guards;
+            if (step.control?.type === 'repeat') {
+                const iterations = Math.max(1, Math.min(step.control.iterations ?? (step.control.durationMs !== undefined ? 32 : 1), 32));
+                const repeatGuards = step.control.condition === undefined ? conditionGuards : [...conditionGuards, step.control.condition];
+                return Array.from({ length: iterations }, (_, index) => this.flattenSteps(nestedChildren, [...parentPath, `${step.id}[${index + 1}]`], depth + 1, childContinueOnError, { loopId: step.id, current: index + 1, total: iterations }, step.control?.durationMs, step.control?.iterationDelayMs, inputs, repeatGuards)).flat();
+            }
+            if ((step.control?.type === 'branch' || step.control?.type === 'parallel') && step.control.branches?.length) {
+                const branches = step.control.branches;
+                const parallelGroup = step.control.type === 'parallel' ? step.id : undefined;
+                return branches.flatMap(branch => this.flattenStepsWithParallel(branch.children, [...parentPath, `${step.id}.${branch.id}`], depth + 1, childContinueOnError, iteration, loopDurationMs, iterationDelayMs, inputs, [...conditionGuards, branch.condition], parallelGroup, step.control?.join ?? 'all', step.control?.merge ?? (step.control?.join === 'first' ? 'first' : 'collect'), step.control?.mergeBindings));
+            }
+            return this.flattenSteps(nestedChildren, [...parentPath, step.id], depth + 1, childContinueOnError, iteration, loopDurationMs, iterationDelayMs, inputs, conditionGuards);
+        });
+    }
+    flattenStepsWithParallel(steps, parentPath, depth, continueOnError, iteration, loopDurationMs, iterationDelayMs, inputs, guards, parallelGroup, parallelJoin, parallelMerge, parallelMergeBindings) {
+        return this.flattenSteps(steps, parentPath, depth, continueOnError, iteration, loopDurationMs, iterationDelayMs, inputs, guards).map(planned => ({ ...planned, parallelGroup, parallelJoin, parallelMerge, parallelMergeBindings }));
+    }
+    async executeParallelGroup(run, group, request, stepOutputs, failedStepIds) {
+        const groupId = group[0].parallelGroup ?? 'parallel';
+        const join = group[0].parallelJoin ?? 'all';
+        const controllers = new Map();
+        let winnerPath;
+        this.emit(run, 'waiting', 'waiting', `Parallel group ${groupId} started with ${group.length} branches.`, undefined, undefined, { groupId, completed: 0, total: group.length, join });
+        const outcomes = await Promise.all(group.map(async (planned) => {
+            const { step } = planned;
+            const invocationId = `${request.requestId}:${planned.path.join('.')}`;
+            const pathKey = planned.path.join('.');
+            const controller = new AbortController();
+            controllers.set(pathKey, controller);
+            const abortFromRun = () => controller.abort();
+            run.abortController.signal.addEventListener('abort', abortFromRun, { once: true });
+            if (planned.guards?.some(condition => !conditionMatches(condition, request.inputs, stepOutputs)))
+                return { result: { id: step.id, name: step.name, state: 'skipped', terminalReason: 'condition-skipped', inputs: {}, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: false, continueOnError: planned.continueOnError };
+            if (step.dependsOn?.some(dependency => failedStepIds.has(dependency)))
+                return { result: { id: step.id, name: step.name, state: 'skipped', terminalReason: 'dependency-skipped', inputs: {}, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: false, continueOnError: planned.continueOnError };
+            const stepInputs = this.resolveInputs(step, request.inputs, stepOutputs);
+            if (!stepInputs) {
+                const error = { code: 'BINDING_FAILED', message: `Bindings for ${step.name} could not be resolved.` };
+                return { result: { id: step.id, name: step.name, state: 'failed', inputs: {}, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration, error }, output: undefined, failed: true, error, cancelled: false, continueOnError: planned.continueOnError };
+            }
+            this.emit(run, 'step_started', 'running', `${step.name} started.`, step, planned.iteration);
+            if (!await this.pause(run, 450))
+                return { result: { id: step.id, name: step.name, state: 'cancelled', terminalReason: run.timedOut ? 'timeout' : 'cancelled', inputs: stepInputs, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: true, continueOnError: planned.continueOnError };
+            this.emit(run, 'waiting', 'waiting', `${step.name} waiting for its Action adapter.`, step, planned.iteration);
+            if (!await this.pause(run, 450))
+                return { result: { id: step.id, name: step.name, state: 'cancelled', terminalReason: run.timedOut ? 'timeout' : 'cancelled', inputs: stepInputs, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: true, continueOnError: planned.continueOnError };
+            const adapter = this.adapters.find(candidate => candidate.supports(step.action));
+            if (!adapter) {
+                const error = { code: 'MISSING_ACTION_ADAPTER', message: `No adapter is registered for ${step.action}.` };
+                return { result: { id: step.id, name: step.name, state: 'failed', inputs: stepInputs, outputs: {}, durationMs: 0, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration, error }, output: undefined, failed: true, error, cancelled: false, continueOnError: planned.continueOnError };
+            }
+            const startedAt = Date.now();
+            const transportStartedAt = new Date().toISOString();
+            let outputs;
+            let lastError;
+            const maxAttempts = Math.max(1, step.retry?.maxAttempts ?? 1);
+            for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+                try {
+                    outputs = await adapter.execute(withRuntimeValues({ action: step.action, inputs: stepInputs, environment: request.environment, step, signal: controller.signal }, request.runtimeValues));
+                    break;
+                }
+                catch (cause) {
+                    lastError = cause;
+                    if (run.cancelled || run.timedOut || controller.signal.aborted)
+                        return { result: { id: step.id, name: step.name, state: 'cancelled', terminalReason: run.timedOut ? 'timeout' : 'cancelled', inputs: stepInputs, outputs: {}, durationMs: Date.now() - startedAt, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: true, continueOnError: planned.continueOnError };
+                    if (attempt < maxAttempts) {
+                        this.emit(run, 'waiting', 'waiting', `${step.name} retrying (${attempt + 1}/${maxAttempts}).`, step, planned.iteration);
+                        if (!await this.pause(run, step.retry?.delayMs ?? 100))
+                            return { result: { id: step.id, name: step.name, state: 'cancelled', terminalReason: run.timedOut ? 'timeout' : 'cancelled', inputs: stepInputs, outputs: {}, durationMs: Date.now() - startedAt, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: true, continueOnError: planned.continueOnError };
+                    }
+                }
+            }
+            if (!outputs) {
+                const error = { code: 'ACTION_FAILED', message: lastError instanceof Error ? lastError.message : `Action ${step.action} failed.` };
+                return { result: { id: step.id, name: step.name, state: 'failed', inputs: stepInputs, outputs: {}, durationMs: Date.now() - startedAt, transportTiming: { requestStartedAt: transportStartedAt, responseReceivedAt: new Date().toISOString(), durationMs: Date.now() - startedAt }, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration, error }, output: undefined, failed: true, error, cancelled: false, continueOnError: planned.continueOnError };
+            }
+            if (step.delayMs && !await this.pause(run, step.delayMs))
+                return { result: { id: step.id, name: step.name, state: 'cancelled', terminalReason: run.timedOut ? 'timeout' : 'cancelled', inputs: stepInputs, outputs: {}, durationMs: Date.now() - startedAt, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: true, continueOnError: planned.continueOnError };
+            if (join === 'first' && winnerPath === undefined) {
+                winnerPath = pathKey;
+                controllers.forEach((candidate, candidatePath) => { if (candidatePath !== pathKey)
+                    candidate.abort(); });
+            }
+            if (join === 'first' && winnerPath !== pathKey)
+                return { result: { id: step.id, name: step.name, state: 'cancelled', terminalReason: 'parallel-joined', inputs: stepInputs, outputs: {}, durationMs: Date.now() - startedAt, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: undefined, failed: false, error: undefined, cancelled: false, continueOnError: planned.continueOnError };
+            this.emit(run, 'step_finished', 'finished', `${step.name} finished.`, step, planned.iteration);
+            return { result: { id: step.id, name: step.name, state: 'finished', inputs: stepInputs, outputs, durationMs: Date.now() - startedAt, transportTiming: { requestStartedAt: transportStartedAt, responseReceivedAt: new Date().toISOString(), durationMs: Date.now() - startedAt }, invocationId, invocationPath: planned.path, kind: step.kind ?? 'action', iteration: planned.iteration }, output: outputs, failed: false, error: undefined, cancelled: false, continueOnError: planned.continueOnError };
+        }));
+        const settled = join === 'first' && winnerPath ? outcomes.filter(outcome => outcome.result.invocationPath?.join('.') === winnerPath) : outcomes;
+        this.emit(run, 'waiting', 'waiting', `Parallel group ${groupId} joined after ${join === 'first' ? 'the first branch' : 'all branches'} settled.`, undefined, undefined, { groupId, completed: settled.length, total: group.length, join });
+        const mergedOutputs = mergeParallelOutputs(settled, groupId, group[0].parallelMerge ?? (join === 'first' ? 'first' : 'collect'), group[0].parallelMergeBindings);
+        return { results: outcomes.map(outcome => outcome.result), outputs: settled.flatMap(outcome => outcome.output ? [{ id: outcome.result.id, outputs: outcome.output }] : []), mergedOutputs, failed: settled.flatMap(outcome => outcome.failed ? [outcome.result.id] : []), errors: settled.flatMap(outcome => outcome.error ? [{ continueOnError: outcome.continueOnError, error: outcome.error }] : []), cancelled: settled.some(outcome => outcome.cancelled) };
+    }
+    orderSteps(planned) {
+        const byId = new Map();
+        for (const item of planned) {
+            const existing = byId.get(item.step.id);
+            if (existing && existing.path.join('.') === item.path.join('.'))
+                throw new Error(`Graph contains duplicate step id ${item.step.id}.`);
+            if (!existing)
+                byId.set(item.step.id, item);
+        }
+        const ordered = [];
+        const remaining = [...planned];
+        while (remaining.length) {
+            const nextIndex = remaining.findIndex(item => (item.step.dependsOn ?? []).every(dependency => byId.has(dependency) && ordered.some(done => done.step.id === dependency)));
+            if (nextIndex < 0) {
+                const missing = remaining.flatMap(item => item.step.dependsOn ?? []).find(dependency => !byId.has(dependency));
+                throw new Error(missing ? `Graph dependency ${missing} is missing.` : 'Graph contains a dependency cycle.');
+            }
+            ordered.push(remaining.splice(nextIndex, 1)[0]);
+        }
+        return ordered;
+    }
+    normalizeResults(results, definitions, prefix = []) {
+        if (definitions.every(definition => !definition.children?.length)) {
+            const paths = new Set(definitions.map(definition => [...prefix, definition.id].join('.')));
+            return results.filter(result => result.invocationPath && paths.has(result.invocationPath.join('.')));
+        }
+        return definitions.flatMap(definition => {
+            const path = [...prefix, definition.id];
+            if ((definition.control?.type === 'branch' || definition.control?.type === 'parallel') && definition.control.branches?.length) {
+                const branches = definition.control.branches.flatMap(branch => {
+                    const branchPath = [...prefix, `${definition.id}.${branch.id}`];
+                    const branchChildren = this.normalizeResults(results, branch.children, branchPath);
+                    return branchChildren.length ? [{ id: branch.id, name: branch.name ?? branch.id, kind: 'control-block', state: branchChildren.every(child => child.state === 'finished') ? 'finished' : 'failed', inputs: {}, outputs: branchChildren.at(-1)?.outputs ?? {}, durationMs: branchChildren.reduce((total, child) => total + child.durationMs, 0), invocationPath: branchPath, children: branchChildren }] : [];
+                });
+                const merge = definition.control.merge ?? (definition.control.join === 'first' ? 'first' : 'collect');
+                const mergedOutputs = mergeBranchResultOutputs(branches, definition.control.mergeBindings, merge);
+                return [{ id: definition.id, name: definition.name, kind: definition.kind ?? 'control-block', state: branches.every(branch => branch.state === 'finished') ? 'finished' : 'failed', terminalReason: branches.every(branch => branch.state === 'finished') ? definition.control.type === 'parallel' ? 'parallel-joined' : 'completed' : 'continued-after-failure', inputs: {}, outputs: mergedOutputs, durationMs: branches.reduce((total, branch) => total + branch.durationMs, 0), invocationPath: path, children: branches }];
+            }
+            if (definition.children?.length) {
+                const iterationGroups = definition.control?.type === 'repeat'
+                    ? [...new Set(results.map(result => result.invocationPath?.slice(prefix.length, prefix.length + 1)[0]).filter(value => value?.startsWith(`${definition.id}[`)))]
+                    : [];
+                const children = iterationGroups.length
+                    ? iterationGroups.map((iterationPath, index) => ({ id: iterationPath, name: `Iteration ${index + 1}`, kind: 'control-block', state: 'finished', inputs: {}, outputs: {}, durationMs: 0, invocationPath: [...prefix, iterationPath], iteration: { loopId: definition.id, current: index + 1, total: iterationGroups.length }, children: this.normalizeResults(results, definition.children, [...prefix, iterationPath]) }))
+                    : this.normalizeResults(results, definition.children, path);
+                const durationMs = children.reduce((total, child) => total + child.durationMs, 0);
+                const last = children.at(-1);
+                return [{ id: definition.id, name: definition.name, kind: definition.kind ?? 'operation', state: children.every(child => child.state === 'finished') ? 'finished' : 'failed', terminalReason: children.every(child => child.state === 'finished') ? 'completed' : 'continued-after-failure', inputs: {}, outputs: last?.outputs ?? {}, durationMs, invocationId: `${results[0]?.invocationId?.split(':')[0] ?? 'run'}:${path.join('.')}`, invocationPath: path, children }];
+            }
+            return results.filter(result => result.invocationPath?.join('.') === path.join('.'));
+        });
+    }
+    resolveInputs(step, invocationInputs, stepOutputs) {
+        const resolved = { ...step.staticInputs };
+        if (!step.bindings)
+            return { ...invocationInputs, ...resolved };
+        for (const [name, reference] of Object.entries(step.bindings)) {
+            const match = /^\$(inputs|steps)\.([^.]+)(?:\.(.+))?$/.exec(reference);
+            if (!match)
+                return undefined;
+            const source = match[1] === 'inputs'
+                ? invocationInputs[match[2]]
+                : match[3] ? stepOutputs[match[2]]?.[match[3]] : undefined;
+            if (source === undefined || source === null)
+                return undefined;
+            resolved[name] = source;
+        }
+        return resolved;
+    }
+    emit(run, type, state, message, step, iteration, parallel, control) { run.events.push({ requestId: run.request.requestId, sequence: run.events.length + 1, type, state, stepId: step?.id, stepName: step?.name, message, timestamp: new Date().toISOString(), ...(iteration ? { iteration } : {}), ...(parallel ? { parallel } : {}), ...(control ? { control: { ...control, ...(step?.id ? { stepId: step.id } : {}) } } : {}) }); run.listeners.splice(0).forEach(resolve => resolve()); }
+    finish(run, result) { const terminalReason = result.terminalReason ?? (result.error?.code === 'TIMEOUT' ? 'timeout' : result.state === 'completed' ? 'completed' : result.state === 'cancelled' ? 'cancelled' : 'failed'); run.controlState = result.state === 'completed' ? 'completed' : result.state === 'cancelled' ? 'stopped' : 'failed'; const wallDurationMs = Math.max(0, Date.now() - run.startedMs); const pausedDurationMs = run.pausedStartedMs ? run.pausedDurationMs + Date.now() - run.pausedStartedMs : run.pausedDurationMs; run.result = { ...result, artifactHash: result.artifactHash ?? hashExecutionPackage(run.request.executionPackage), terminalReason, executionTiming: result.executionTiming ?? { wallDurationMs, pausedDurationMs, activeDurationMs: Math.max(0, wallDurationMs - pausedDurationMs) } }; this.emit(run, 'run_finished', result.state, result.error?.message ?? `Run ${result.state}.`); run.resultResolve(run.result); }
+    async waitForSafeBoundary(run, step, path) { const breakpointKey = path.join('.'); const breakpointHit = run.debugSession.breakpoints.includes(step.id) && !run.hitBreakpoints.has(breakpointKey); const stepBoundary = run.stepRequested; if (breakpointHit) {
+        run.hitBreakpoints.add(breakpointKey);
+        run.controlState = 'paused';
+        this.emit(run, 'waiting', 'waiting', `Breakpoint reached before ${step.name}.`, step, undefined, undefined, { type: 'breakpoint-reached' });
+        this.emit(run, 'waiting', 'waiting', `Execution paused before ${step.name}.`, step, undefined, undefined, { type: 'paused' });
+    }
+    else if (run.pauseRequested) {
+        run.controlState = 'paused';
+        this.emit(run, 'waiting', 'waiting', `Execution paused before ${step.name}.`, step, undefined, undefined, { type: 'paused' });
+    }
+    else if (stepBoundary) {
+        run.stepRequested = false;
+        run.controlState = 'paused';
+        this.emit(run, 'waiting', 'waiting', `Step completed; execution paused before ${step.name}.`, step, undefined, undefined, { type: 'step-completed' });
+        this.emit(run, 'waiting', 'waiting', `Execution paused before ${step.name}.`, step, undefined, undefined, { type: 'paused' });
+    }
+    else {
+        if (run.controlState === 'resuming')
+            run.controlState = 'running';
+        return !run.cancelled;
+    } run.pausedStartedMs = Date.now(); await new Promise(resolve => run.controlWaiters.push(resolve)); if (run.pausedStartedMs) {
+        run.pausedDurationMs += Date.now() - run.pausedStartedMs;
+        run.pausedStartedMs = undefined;
+    } if (run.cancelled)
+        return false; run.controlState = 'running'; return true; }
+    async pauseAfterStopAfter(run, step) { if (run.debugSession.stopAfterStepId !== step.id)
+        return !run.cancelled; run.debugSession.stopAfterStepId = undefined; run.controlState = 'paused'; this.emit(run, 'waiting', 'waiting', `Stop After reached after ${step.name}.`, step, undefined, undefined, { type: 'stop-after-reached' }); this.emit(run, 'waiting', 'waiting', `Execution paused after ${step.name}.`, step, undefined, undefined, { type: 'paused' }); run.pausedStartedMs = Date.now(); await new Promise(resolve => run.controlWaiters.push(resolve)); if (run.pausedStartedMs) {
+        run.pausedDurationMs += Date.now() - run.pausedStartedMs;
+        run.pausedStartedMs = undefined;
+    } if (run.cancelled)
+        return false; run.controlState = 'running'; return true; }
+    finishCancelled(run, startedAt, steps) { if (run.timedOut) {
+        const error = { code: 'TIMEOUT', message: `Run exceeded its ${run.request.options?.timeoutMs}ms timeout.` };
+        this.finish(run, { requestId: run.request.requestId, state: 'failed', target: run.request.executionPackage.target, environment: run.request.environment, startedAt, finishedAt: new Date().toISOString(), steps, error });
+    }
+    else
+        this.finish(run, { requestId: run.request.requestId, state: 'cancelled', target: run.request.executionPackage.target, environment: run.request.environment, startedAt, finishedAt: new Date().toISOString(), steps }); }
+    pause(run, ms) { return new Promise(resolve => { const started = Date.now(); const timer = globalThis.setInterval(() => { if (run.cancelled) {
+        globalThis.clearInterval(timer);
+        resolve(false);
+    }
+    else if (run.timeoutAt !== undefined && Date.now() >= run.timeoutAt) {
+        run.timedOut = true;
+        run.abortController.abort();
+        globalThis.clearInterval(timer);
+        resolve(false);
+    }
+    else if (Date.now() - started >= ms) {
+        globalThis.clearInterval(timer);
+        resolve(true);
+    } }, 25); }); }
+}
+function walkSteps(steps) { return steps.flatMap(step => [step, ...(step.children ? walkSteps(step.children) : [])]); }
+function unsupportedControlSettings(step) {
+    const control = step.control;
+    if (!control)
+        return [];
+    const issues = [];
+    const unsupported = (field, supportedFor) => issues.push({ code: 'UNSUPPORTED_CONTROL_SETTING', message: `Control Block ${step.name} sets ${field}, which is supported only for ${supportedFor} controls.` });
+    if (control.type !== 'repeat' && control.iterations !== undefined)
+        unsupported('iterations', 'repeat');
+    if (control.type !== 'repeat' && control.durationMs !== undefined)
+        unsupported('durationMs', 'repeat');
+    if (control.type !== 'repeat' && control.iterationDelayMs !== undefined)
+        unsupported('iterationDelayMs', 'repeat');
+    if (control.type !== 'condition' && control.type !== 'repeat' && control.condition !== undefined)
+        unsupported('condition', 'condition or repeat');
+    if (control.type !== 'branch' && control.type !== 'parallel' && control.branches !== undefined)
+        unsupported('branches', 'branch or parallel');
+    if (control.type !== 'parallel' && control.join !== undefined)
+        unsupported('join', 'parallel');
+    if (control.type !== 'parallel' && control.merge !== undefined)
+        unsupported('merge', 'parallel');
+    if (control.type !== 'parallel' && control.mergeBindings !== undefined)
+        unsupported('mergeBindings', 'parallel');
+    return issues;
+}
+function conditionMatches(condition, inputs, stepOutputs = {}) {
+    if (typeof condition === 'boolean')
+        return condition;
+    const inputMatch = /^\$inputs\.([^.]+)$/.exec(condition.binding);
+    const stepMatch = /^\$steps\.([^.]+)\.(.+)$/.exec(condition.binding);
+    const value = inputMatch ? inputs[inputMatch[1]] : stepMatch ? stepOutputs[stepMatch[1]]?.[stepMatch[2]] : undefined;
+    if (condition.exists !== undefined)
+        return condition.exists ? value !== undefined && value !== null && value !== '' : value === undefined || value === null || value === '';
+    if (Object.prototype.hasOwnProperty.call(condition, 'equals'))
+        return value === condition.equals;
+    if (Object.prototype.hasOwnProperty.call(condition, 'notEquals'))
+        return value !== condition.notEquals;
+    return Boolean(value);
+}
+function mergeParallelOutputs(outcomes, groupId, policy, bindings) {
+    if (bindings)
+        return Object.fromEntries(Object.entries(bindings).flatMap(([name, source]) => {
+            const match = /^([^.]+)\.(.+)$/.exec(source);
+            if (!match)
+                return [];
+            const outcome = outcomes.find(item => item.result.invocationPath?.includes(`${groupId}.${match[1]}`));
+            return outcome?.output && Object.prototype.hasOwnProperty.call(outcome.output, match[2]) ? [[name, outcome.output[match[2]]]] : [];
+        }));
+    if (policy === 'first')
+        return { ...outcomes[0]?.output };
+    if (policy === 'last')
+        return { ...outcomes.at(-1)?.output };
+    return Object.fromEntries(outcomes.flatMap(outcome => {
+        const path = outcome.result.invocationPath ?? [];
+        const branchIndex = path.indexOf(groupId);
+        const branchId = branchIndex >= 0 ? path[branchIndex + 1] ?? outcome.result.id : outcome.result.id;
+        return Object.entries(outcome.output ?? {}).map(([name, value]) => [`${branchId}.${name}`, value]);
+    }));
+}
+function mergeBranchResultOutputs(branches, bindings, policy) {
+    if (bindings)
+        return Object.fromEntries(Object.entries(bindings).flatMap(([name, source]) => { const match = /^([^.]+)\.(.+)$/.exec(source); const branch = match ? branches.find(item => item.id === match[1]) : undefined; return branch && match && Object.prototype.hasOwnProperty.call(branch.outputs, match[2]) ? [[name, branch.outputs[match[2]]]] : []; }));
+    if (policy === 'first')
+        return { ...branches[0]?.outputs };
+    if (policy === 'last')
+        return { ...branches.at(-1)?.outputs };
+    return Object.fromEntries(branches.flatMap(branch => Object.entries(branch.outputs).map(([name, value]) => [`${branch.id}.${name}`, value])));
+}
+function findStepResult(results, stepId, invocationPath) {
+    for (const result of results) {
+        if (result.id === stepId && (!invocationPath || result.invocationPath?.join('.') === invocationPath.join('.')))
+            return result;
+        const nested = result.children && findStepResult(result.children, stepId, invocationPath);
+        if (nested)
+            return nested;
+    }
+    const operationChildren = resultsUnderPath(results, invocationPath ?? [stepId]);
+    if (operationChildren.length) {
+        const synthetic = { id: stepId, name: stepId, state: operationChildren.every(child => child.state === 'finished') ? 'finished' : 'failed', inputs: {}, outputs: operationChildren.at(-1)?.outputs ?? {}, durationMs: operationChildren.reduce((total, child) => total + child.durationMs, 0), invocationPath: invocationPath ?? [stepId], kind: 'operation', children: operationChildren };
+        results.splice(0, results.length, synthetic);
+        return synthetic;
+    }
+    return undefined;
+}
+function resultsUnderPath(results, prefix) { return results.filter(result => result.invocationPath?.slice(0, prefix.length).join('.') === prefix.join('.')); }
+function flattenStepResults(results) { return results.flatMap(result => [result, ...(result.children ? flattenStepResults(result.children) : [])]); }
+function findExecutionStep(steps, stepId, invocationPath, prefix = []) {
+    for (const step of steps) {
+        const path = [...prefix, step.id];
+        if (step.id === stepId && (!invocationPath || path.join('.') === invocationPath.join('.')))
+            return step;
+        const nested = step.children && findExecutionStep(step.children, stepId, invocationPath, path);
+        if (nested)
+            return nested;
+        const branches = step.control?.branches?.flatMap(branch => findExecutionStep(branch.children, stepId, invocationPath, [...prefix, `${step.id}.${branch.id}`]) ?? []) ?? [];
+        if (branches[0])
+            return branches[0];
+    }
+    return undefined;
+}
+function isAdapterError(value) { return typeof value === 'object' && value !== null && 'code' in value && typeof value.code === 'string'; }