@qaick/executor 0.1.0-alpha.1

package/dist/migrated-artifact-hash.js

@@ -0,0 +1,19 @@
+/** Stable, dependency-free content identity for the normalized execution package. */
+export function hashExecutionPackage(pack) {
+    const serialized = stableStringify(pack);
+    let hash = 0xcbf29ce484222325n;
+    for (let index = 0; index < serialized.length; index += 1) {
+        hash ^= BigInt(serialized.charCodeAt(index));
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return `fnv1a64:${hash.toString(16).padStart(16, '0')}`;
+}
+function stableStringify(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'undefined';
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}

package/dist/migrated-executor.d.ts

@@ -0,0 +1,22 @@
+import type { ActionExecutor, Executor, ExecutorConfiguration, ExecutorEvent, ExecutorRequest, ExecutorResult, ExecutorRun, ControlCommand, ExecutionControlState } from './types.js';
+export declare function createMigratedExecutor(configuration?: ExecutorConfiguration): Executor;
+/**
+ * Compatibility facade over the extracted Runner engine. The facade owns the
+ * package-neutral Action Executor registration while the execution algorithm
+ * remains the migrated Runner implementation.
+ */
+export declare class MigratedExecutor implements Executor {
+    private readonly adapters;
+    private readonly engine;
+    constructor(configuration?: ExecutorConfiguration);
+    registerActionExecutor(executor: ActionExecutor): void;
+    execute(request: ExecutorRequest): Promise<ExecutorRun>;
+    cancel(requestId: string): Promise<void>;
+    control(requestId: string, command: ControlCommand): Promise<void>;
+    controlState(requestId: string): ExecutionControlState | undefined;
+    events(requestId: string): AsyncIterable<ExecutorEvent>;
+    result(requestId: string): Promise<ExecutorResult>;
+    retryAction(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    retryOperation(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    runFromHere(requestId: string, stepId: string, invocationPath?: string[]): Promise<ExecutorRun | undefined>;
+}

package/dist/migrated-executor.js

@@ -0,0 +1,61 @@
+import { MigratedRunnerEngine } from './migrated-runner-engine.js';
+import { MigratedProjectRunnerEngine } from './migrated-project-engine.js';
+export function createMigratedExecutor(configuration = {}) {
+    return new MigratedExecutor(configuration);
+}
+/**
+ * Compatibility facade over the extracted Runner engine. The facade owns the
+ * package-neutral Action Executor registration while the execution algorithm
+ * remains the migrated Runner implementation.
+ */
+export class MigratedExecutor {
+    adapters;
+    engine;
+    constructor(configuration = {}) {
+        this.adapters = (configuration.actionExecutors ?? []).map(toActionAdapter);
+        this.engine = new MigratedProjectRunnerEngine(new MigratedRunnerEngine(this.adapters));
+    }
+    registerActionExecutor(executor) { this.adapters.push(toActionAdapter(executor)); }
+    async execute(request) {
+        const runnerRequest = request;
+        await this.engine.submit(runnerRequest);
+        return { requestId: request.requestId, result: this.result(request.requestId) };
+    }
+    async cancel(requestId) { await this.engine.cancel(requestId); }
+    async control(requestId, command) {
+        if (command.type === 'pause')
+            return this.engine.pauseExecution(requestId);
+        if (command.type === 'resume')
+            return this.engine.resumeExecution(requestId);
+        if (command.type === 'step')
+            return this.engine.stepExecution(requestId);
+        if (command.type === 'stop')
+            return this.engine.cancel(requestId);
+        if (command.type === 'stop-after')
+            return;
+    }
+    controlState(requestId) { return this.engine.controlState(requestId); }
+    async *events(requestId) { yield* this.engine.events(requestId); }
+    async result(requestId) { return this.engine.result(requestId); }
+    async retryAction(requestId, stepId, invocationPath) { await this.engine.retryAction(requestId, stepId, invocationPath); }
+    async retryOperation(requestId, stepId, invocationPath) { await this.engine.retryOperation(requestId, stepId, invocationPath); }
+    async runFromHere(requestId, stepId, invocationPath) {
+        const accepted = await this.engine.runFromHere(requestId, stepId, invocationPath);
+        return accepted ? { requestId: accepted.requestId, result: this.result(accepted.requestId) } : undefined;
+    }
+}
+function toActionAdapter(executor) {
+    return {
+        supports: action => executor.supports(action),
+        execute: async (context) => {
+            const result = await executor.execute({
+                ...context,
+                runtimeValues: context.runtimeValues ?? {},
+            });
+            return isActionResult(result) ? result.outputs : result;
+        },
+    };
+}
+function isActionResult(value) {
+    return typeof value === 'object' && value !== null && 'outputs' in value && typeof value.outputs === 'object' && value.outputs !== null;
+}

package/dist/migrated-project-engine.d.ts

@@ -0,0 +1,21 @@
+import { MigratedRunnerEngine } from './migrated-runner-engine.js';
+import type { ExecutionControlState, ExecutionEvent, ExecutionResult, RunnerEngine, RunnerRequest, RunAccepted } from './migrated-types.js';
+export declare class MigratedProjectRunnerEngine implements RunnerEngine {
+    private readonly flowEngine;
+    private readonly runs;
+    constructor(flowEngine?: MigratedRunnerEngine);
+    submit(request: RunnerRequest): Promise<RunAccepted>;
+    cancel(requestId: string): Promise<void>;
+    pauseExecution(requestId: string): Promise<void>;
+    resumeExecution(requestId: string): Promise<void>;
+    stepExecution(requestId: string): Promise<void>;
+    retryAction(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    retryOperation(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    runFromHere(requestId: string, stepId: string, invocationPath?: string[]): Promise<RunAccepted | undefined>;
+    controlState(requestId: string): ExecutionControlState | undefined;
+    events(requestId: string): AsyncIterable<ExecutionEvent>;
+    result(requestId: string): Promise<ExecutionResult>;
+    private executeProject;
+    private emit;
+    private finish;
+}

package/dist/migrated-project-engine.js

@@ -0,0 +1,118 @@
+import { MigratedRunnerEngine } from './migrated-runner-engine.js';
+import { hashExecutionPackage } from './migrated-artifact-hash.js';
+export class MigratedProjectRunnerEngine {
+    flowEngine;
+    runs = new Map();
+    constructor(flowEngine = new MigratedRunnerEngine()) { this.flowEngine = flowEngine; }
+    async submit(request) {
+        if (request.executionPackage.target.kind !== 'project')
+            return this.flowEngine.submit(request);
+        let resolve;
+        const run = { request, events: [], listeners: [], resolve, cancelled: false };
+        const resultPromise = new Promise(promiseResolve => { resolve = promiseResolve; run.resolve = promiseResolve; });
+        this.runs.set(request.requestId, run);
+        void this.executeProject(run, resultPromise);
+        return { requestId: request.requestId };
+    }
+    async cancel(requestId) {
+        const run = this.runs.get(requestId);
+        if (run) {
+            run.cancelled = true;
+            await this.flowEngine.cancel(run.activeRequestId ?? requestId);
+            run.listeners.splice(0).forEach(resolve => resolve());
+        }
+        else
+            await this.flowEngine.cancel(requestId);
+    }
+    async pauseExecution(requestId) { const run = this.runs.get(requestId); if (run)
+        await this.flowEngine.pauseExecution(run.activeRequestId ?? requestId);
+    else
+        await this.flowEngine.pauseExecution(requestId); }
+    async resumeExecution(requestId) { const run = this.runs.get(requestId); if (run)
+        await this.flowEngine.resumeExecution(run.activeRequestId ?? requestId);
+    else
+        await this.flowEngine.resumeExecution(requestId); }
+    async stepExecution(requestId) { const run = this.runs.get(requestId); if (run)
+        await this.flowEngine.stepExecution(run.activeRequestId ?? requestId);
+    else
+        await this.flowEngine.stepExecution(requestId); }
+    async retryAction(requestId, stepId, invocationPath) { const run = this.runs.get(requestId); if (run)
+        await this.flowEngine.retryAction(run.activeRequestId ?? requestId, stepId, invocationPath);
+    else
+        await this.flowEngine.retryAction(requestId, stepId, invocationPath); }
+    async retryOperation(requestId, stepId, invocationPath) { const run = this.runs.get(requestId); if (run)
+        await this.flowEngine.retryOperation(run.activeRequestId ?? requestId, stepId, invocationPath);
+    else
+        await this.flowEngine.retryOperation(requestId, stepId, invocationPath); }
+    async runFromHere(requestId, stepId, invocationPath) { const run = this.runs.get(requestId); return this.flowEngine.runFromHere(run?.activeRequestId ?? requestId, stepId, invocationPath); }
+    controlState(requestId) { const run = this.runs.get(requestId); return this.flowEngine.controlState(run?.activeRequestId ?? requestId); }
+    async *events(requestId) {
+        const project = this.runs.get(requestId);
+        if (!project) {
+            yield* this.flowEngine.events(requestId);
+            return;
+        }
+        let index = 0;
+        while (true) {
+            while (index < project.events.length)
+                yield project.events[index++];
+            if (project.result)
+                return;
+            await new Promise(resolve => project.listeners.push(resolve));
+        }
+    }
+    async result(requestId) {
+        const project = this.runs.get(requestId);
+        if (!project)
+            return this.flowEngine.result(requestId);
+        if (project.result)
+            return project.result;
+        return new Promise(resolve => { const previous = project.resolve; project.resolve = result => { previous(result); resolve(result); }; });
+    }
+    async executeProject(run, resultPromise) {
+        const { request } = run;
+        const startedAt = new Date().toISOString();
+        const flows = request.executionPackage.flows ?? [];
+        this.emit(run, 'run_started', 'created', 'Project run accepted.');
+        this.emit(run, 'preflight_started', 'preflighting', `Validating ${flows.length} Project Flows.`);
+        const invalidFlow = flows.length === 0 || flows.find(flow => !request.executionPackage.definitions.some(definition => definition.kind === 'flow' && definition.id === flow.id));
+        if (invalidFlow) {
+            const error = { code: 'INVALID_PROJECT', message: 'Project Flow definitions are missing or unresolved.' };
+            this.finish(run, { requestId: request.requestId, state: 'failed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], error });
+            return;
+        }
+        const children = [];
+        let inputs = { ...request.inputs };
+        for (const flow of flows) {
+            if (run.cancelled) {
+                this.finish(run, { requestId: request.requestId, state: 'cancelled', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], children });
+                return;
+            }
+            const childRequestId = `${request.requestId}:${flow.id}`;
+            run.activeRequestId = childRequestId;
+            const childPackage = { ...request.executionPackage, target: { kind: 'flow', id: flow.id, name: flow.name }, steps: flow.steps, flows: undefined, requiredInputs: flow.requiredInputs };
+            await this.flowEngine.submit({ requestId: childRequestId, executionPackage: childPackage, inputs, environment: request.environment, runtimeValues: request.runtimeValues, options: request.options, debugSession: request.debugSession });
+            for await (const event of this.flowEngine.events(childRequestId))
+                this.emit(run, event.type, event.state, `[${flow.name}] ${event.message}`, event.stepId ? { stepId: event.stepId, stepName: event.stepName } : undefined, event.parallel, event.control);
+            const childResult = await this.flowEngine.result(childRequestId);
+            children.push(childResult);
+            const lastStep = childResult.steps.at(-1);
+            if (childResult.state !== 'completed') {
+                const result = { requestId: request.requestId, state: childResult.state, target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], children, error: childResult.error, issues: children.flatMap(child => child.issues ?? []) };
+                this.finish(run, result);
+                return;
+            }
+            const outputBindings = flow.outputBindings ?? {};
+            const mappedOutputs = Object.fromEntries(Object.entries(outputBindings).flatMap(([name, reference]) => {
+                const match = /^\$outputs\.(.+)$/.exec(reference);
+                return match && lastStep?.outputs[match[1]] !== undefined ? [[name, lastStep.outputs[match[1]]]] : [];
+            }));
+            inputs = { ...inputs, ...(Object.keys(outputBindings).length ? mappedOutputs : lastStep?.outputs) };
+        }
+        const result = { requestId: request.requestId, state: 'completed', target: request.executionPackage.target, environment: request.environment, startedAt, finishedAt: new Date().toISOString(), steps: [], children, issues: children.flatMap(child => child.issues ?? []) };
+        this.finish(run, result);
+        await resultPromise;
+    }
+    emit(run, type, state, message, step, parallel, control) { run.events.push({ requestId: run.request.requestId, sequence: run.events.length + 1, type, state, stepId: step?.stepId, stepName: step?.stepName, message, timestamp: new Date().toISOString(), ...(parallel ? { parallel } : {}), ...(control ? { control } : {}) }); 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.result = { ...result, artifactHash: result.artifactHash ?? hashExecutionPackage(run.request.executionPackage), terminalReason }; this.emit(run, 'run_finished', result.state, result.error?.message ?? `Project run ${result.state}.`); run.resolve(run.result); }
+}

package/dist/migrated-runner-engine.d.ts

@@ -0,0 +1,33 @@
+import type { ActionAdapter, ExecutionControlState, ExecutionEvent, ExecutionResult, RunnerDebugSession, RunnerEngine, RunnerRequest, RunAccepted } from './migrated-types.js';
+export declare class MigratedRunnerEngine implements RunnerEngine {
+    private readonly adapters;
+    private readonly runs;
+    constructor(adapters?: ActionAdapter[]);
+    submit(request: RunnerRequest): Promise<RunAccepted>;
+    cancel(requestId: string): Promise<void>;
+    pauseExecution(requestId: string): Promise<void>;
+    resumeExecution(requestId: string): Promise<void>;
+    stepExecution(requestId: string): Promise<void>;
+    retryAction(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    retryOperation(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    runFromHere(requestId: string, stepId: string, invocationPath?: string[]): Promise<RunAccepted | undefined>;
+    controlState(requestId: string): ExecutionControlState | undefined;
+    debugSession(requestId: string): RunnerDebugSession | undefined;
+    events(requestId: string): AsyncIterable<ExecutionEvent>;
+    result(requestId: string): Promise<ExecutionResult>;
+    private execute;
+    private validateAll;
+    private validateBrowserWarnings;
+    private flattenSteps;
+    private flattenStepsWithParallel;
+    private executeParallelGroup;
+    private orderSteps;
+    private normalizeResults;
+    private resolveInputs;
+    private emit;
+    private finish;
+    private waitForSafeBoundary;
+    private pauseAfterStopAfter;
+    private finishCancelled;
+    private pause;
+}