@qaick/executor 0.1.0-alpha.3 → 0.1.0

package/dist/executor.js

@@ -132,11 +132,18 @@ export class DefaultExecutor {
         const definition = findDefinition(run.request.executionPackage.steps, stepId, invocationPath);
         if (!located || !definition?.children?.length || definition.control || definition.kind !== 'operation')
             return;
-        const nested = await this.executeFlow(run, definition.children, located.inputs, [...(located.invocationPath ?? []).slice(0, -1), definition.id], new Date().toISOString());
+        const arguments_ = resolveDeclaredInputs(definition.inputDeclarations, located.inputs);
+        if (arguments_.issues.length)
+            return;
+        const childScope = { ...run.request.inputs, ...arguments_.inputs };
+        const nested = await this.executeFlow(run, definition.children, childScope, [...(located.invocationPath ?? []).slice(0, -1), definition.id], new Date().toISOString());
+        const outputs = definition.outputBindings && nested.state === 'completed'
+            ? { ...definition.staticOutputs, ...resolveBindings(definition.outputBindings, childScope, new Map(nested.steps.map(child => [child.id, child.outputs]))) }
+            : nested.steps.at(-1)?.outputs ?? {};
         const previous = located.attempts ?? [];
-        located.attempts = [...previous, { attempt: previous.length + 1, kind: 'interactive', state: nested.state === 'completed' ? 'finished' : 'failed', startedAt: nested.startedAt, finishedAt: nested.finishedAt, inputs: located.inputs, outputs: nested.steps.at(-1)?.outputs ?? {}, durationMs: nested.steps.reduce((sum, child) => sum + child.durationMs, 0), children: nested.steps, ...(nested.error ? { error: nested.error } : {}) }];
+        located.attempts = [...previous, { attempt: previous.length + 1, kind: 'interactive', state: nested.state === 'completed' ? 'finished' : 'failed', startedAt: nested.startedAt, finishedAt: nested.finishedAt, inputs: located.inputs, outputs, durationMs: nested.steps.reduce((sum, child) => sum + child.durationMs, 0), children: nested.steps, ...(nested.error ? { error: nested.error } : {}) }];
         located.children = nested.steps;
-        located.outputs = nested.steps.at(-1)?.outputs ?? {};
+        located.outputs = outputs;
         located.state = nested.state === 'completed' ? 'finished' : nested.state === 'cancelled' ? 'cancelled' : 'failed';
         located.terminalReason = nested.terminalReason ?? (located.state === 'finished' ? 'completed' : 'failed');
         located.error = nested.error;
@@ -238,7 +245,7 @@ export class DefaultExecutor {
         const results = [];
         let state = 'completed';
         let error;
-        for (const step of orderSteps(steps)) {
+        for (const step of run.request.executionPackage.ordering === 'routine' ? steps : orderSteps(steps)) {
             if (run.cancelled || signal.aborted)
                 throw new Error('Execution cancelled.');
             await this.boundary(run, step, [...path, step.id], signal);
@@ -276,8 +283,17 @@ export class DefaultExecutor {
                 return { ...base, ...controlResult, inputs, durationMs: Date.now() - startedMs };
             }
             if (step.kind === 'operation' && step.children) {
-                const nested = await this.executeFlow(run, step.children, { ...scope, ...inputs }, [...path, step.id], new Date().toISOString(), run.request.executionPackage.target, signal);
-                const outputs = nested.steps.at(-1)?.outputs ?? {};
+                const arguments_ = resolveDeclaredInputs(step.inputDeclarations, inputs);
+                if (arguments_.issues.length)
+                    throw failure('BINDING_RESOLUTION_ERROR', arguments_.issues.map(issue => issue.message).join(' '));
+                const childScope = { ...scope, ...arguments_.inputs };
+                for (const declaration of step.inputDeclarations ?? [])
+                    if (!Object.hasOwn(arguments_.inputs, declaration.name))
+                        delete childScope[declaration.name];
+                const nested = await this.executeFlow(run, step.children, childScope, [...path, step.id], new Date().toISOString(), run.request.executionPackage.target, signal);
+                const outputs = step.outputBindings && nested.state === 'completed'
+                    ? { ...step.staticOutputs, ...resolveBindings(step.outputBindings, childScope, new Map(nested.steps.map(child => [child.id, child.outputs]))) }
+                    : nested.steps.at(-1)?.outputs ?? {};
                 const result = { ...base, state: nested.state === 'completed' ? 'finished' : nested.state, inputs, outputs, durationMs: Date.now() - startedMs, children: nested.steps, terminalReason: nested.terminalReason ?? (nested.state === 'completed' ? 'completed' : 'failed'), error: nested.error };
                 this.emit(run, 'step_finished', result.state, `${step.name} ${result.state}.`, step);
                 return result;
@@ -304,9 +320,12 @@ export class DefaultExecutor {
         if (control.condition !== undefined && !evaluateCondition(control.condition, { ...scope, ...inputs }, outputs))
             return { state: 'skipped', outputs: {}, terminalReason: 'condition-skipped' };
         if (control.type === 'repeat') {
-            const total = control.iterations ?? 1;
+            const total = run.request.executionPackage.ordering === 'routine' ? Math.max(1, Math.min(control.iterations ?? (control.durationMs !== undefined ? 32 : 1), 32)) : control.iterations ?? 1;
+            const loopStarted = Date.now();
             const children = [];
             for (let current = 1; current <= total; current++) {
+                if (run.request.executionPackage.ordering === 'routine' && control.durationMs !== undefined && Date.now() - loopStarted >= control.durationMs)
+                    break;
                 const child = await this.executeFlow(run, step.children ?? [], { ...scope, ...inputs }, [...path, step.id, String(current)], new Date().toISOString(), run.request.executionPackage.target, signal);
                 children.push(...child.steps.map(item => ({ ...item, iteration: { loopId: step.id, current, total } })));
                 if (child.state !== 'completed' && control.onError !== 'continue')
@@ -316,6 +335,18 @@ export class DefaultExecutor {
             }
             return { state: 'finished', outputs: children.at(-1)?.outputs ?? {}, children, terminalReason: 'completed' };
         }
+        if (control.type === 'branch' && run.request.executionPackage.ordering === 'routine') {
+            const children = [];
+            for (const branch of control.branches ?? []) {
+                if (!evaluateCondition(branch.condition, { ...scope, ...inputs }, outputs))
+                    continue;
+                const nested = await this.executeFlow(run, branch.children, { ...scope, ...inputs }, [...path, step.id, branch.id], new Date().toISOString(), run.request.executionPackage.target, signal);
+                children.push(...nested.steps);
+                if (nested.state !== 'completed' && control.onError !== 'continue')
+                    return { state: nested.state, outputs: nested.steps.at(-1)?.outputs ?? {}, children, terminalReason: nested.terminalReason, error: nested.error };
+            }
+            return { state: children.length ? 'finished' : 'skipped', outputs: children.at(-1)?.outputs ?? {}, children, terminalReason: children.length ? 'completed' : 'branch-skipped' };
+        }
         if (control.type === 'branch') {
             const branch = control.branches?.find(candidate => evaluateCondition(candidate.condition, { ...scope, ...inputs }, outputs));
             if (!branch)
@@ -325,13 +356,18 @@ export class DefaultExecutor {
         }
         if (control.type === 'parallel') {
             const branches = control.branches ?? [];
+            const join = run.request.executionPackage.ordering === 'routine' ? 'all' : control.join;
             const selected = branches.filter(branch => evaluateCondition(branch.condition, { ...scope, ...inputs }, outputs));
             const controllers = selected.map(() => new AbortController());
+            const abortBranches = () => controllers.forEach(controller => controller.abort());
+            signal.addEventListener('abort', abortBranches, { once: true });
+            if (signal.aborted)
+                abortBranches();
             let winnerIndex;
             const branchRuns = await Promise.all(selected.map(async (branch, index) => {
                 try {
                     const result = await this.executeFlow(run, branch.children, { ...scope, ...inputs }, [...path, step.id, branch.id], new Date().toISOString(), run.request.executionPackage.target, controllers[index].signal);
-                    if (control.join === 'first' && result.state === 'completed' && winnerIndex === undefined) {
+                    if (join === 'first' && result.state === 'completed' && winnerIndex === undefined) {
                         winnerIndex = index;
                         controllers.forEach((controller, candidate) => { if (candidate !== index)
                             controller.abort(); });
@@ -342,12 +378,13 @@ export class DefaultExecutor {
                     return { branch, result: this.baseResult(run, new Date().toISOString(), controllers[index].signal.aborted ? 'cancelled' : 'failed', this.failure(cause, run, controllers[index].signal)) };
                 }
             }));
+            signal.removeEventListener('abort', abortBranches);
             const nested = branchRuns.map(item => item.result);
             const children = nested.flatMap(item => item.steps);
-            const considered = control.join === 'first' && winnerIndex !== undefined ? [branchRuns[winnerIndex]] : branchRuns;
+            const considered = join === 'first' && winnerIndex !== undefined ? [branchRuns[winnerIndex]] : branchRuns;
             const failed = considered.find(item => item.result.state !== 'completed');
             const branchOutputs = considered.map(({ branch, result }) => ({ id: branch.id, outputs: result.steps.at(-1)?.outputs ?? {} }));
-            const mergedOutputs = mergeBranchOutputs(branchOutputs, control.mergeBindings, control.merge ?? (control.join === 'first' ? 'first' : 'collect'));
+            const mergedOutputs = mergeBranchOutputs(branchOutputs, control.mergeBindings, control.merge ?? (join === 'first' ? 'first' : 'collect'));
             return { state: failed ? invocationState(failed.result.state) : 'finished', outputs: mergedOutputs, children, terminalReason: failed?.result.terminalReason ?? 'parallel-joined', error: failed?.result.error };
         }
         const nested = await this.executeFlow(run, step.children ?? [], { ...scope, ...inputs }, [...path, step.id], new Date().toISOString(), run.request.executionPackage.target, signal);

package/dist/migrated-executor.d.ts

@@ -6,6 +6,8 @@ export declare function createMigratedExecutor(configuration?: ExecutorConfigura
  * remains the migrated Runner implementation.
  */
 export declare class MigratedExecutor implements Executor {
+    private readonly routineRuns;
+    private readonly routine;
     private readonly adapters;
     private readonly engine;
     constructor(configuration?: ExecutorConfiguration);

package/dist/migrated-executor.js

@@ -1,3 +1,4 @@
+import { createExecutor } from './executor.js';
 import { MigratedRunnerEngine } from './migrated-runner-engine.js';
 import { MigratedProjectRunnerEngine } from './migrated-project-engine.js';
 export function createMigratedExecutor(configuration = {}) {
@@ -9,20 +10,30 @@ export function createMigratedExecutor(configuration = {}) {
  * remains the migrated Runner implementation.
  */
 export class MigratedExecutor {
+    routineRuns = new Set();
+    routine;
     adapters;
     engine;
     constructor(configuration = {}) {
+        this.routine = createExecutor(configuration);
         this.adapters = (configuration.actionExecutors ?? []).map(toActionAdapter);
         this.engine = new MigratedProjectRunnerEngine(new MigratedRunnerEngine(this.adapters));
     }
-    registerActionExecutor(executor) { this.adapters.push(toActionAdapter(executor)); }
+    registerActionExecutor(executor) { this.routine.registerActionExecutor(executor); this.adapters.push(toActionAdapter(executor)); }
     async execute(request) {
+        if (request.executionPackage.ordering === 'routine') {
+            this.routineRuns.add(request.requestId);
+            return this.routine.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 cancel(requestId) { if (this.routineRuns.has(requestId))
+        return this.routine.cancel(requestId); await this.engine.cancel(requestId); }
     async control(requestId, command) {
+        if (this.routineRuns.has(requestId))
+            return this.routine.control(requestId, command);
         if (command.type === 'pause')
             return this.engine.pauseExecution(requestId);
         if (command.type === 'resume')
@@ -34,12 +45,18 @@ export class MigratedExecutor {
         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); }
+    controlState(requestId) { return this.routineRuns.has(requestId) ? this.routine.controlState(requestId) : this.engine.controlState(requestId); }
+    async *events(requestId) { yield* (this.routineRuns.has(requestId) ? this.routine.events(requestId) : this.engine.events(requestId)); }
+    async result(requestId) { return (this.routineRuns.has(requestId) ? this.routine.result(requestId) : this.engine.result(requestId)); }
+    async retryAction(requestId, stepId, invocationPath) { await (this.routineRuns.has(requestId) ? this.routine.retryAction(requestId, stepId, invocationPath) : this.engine.retryAction(requestId, stepId, invocationPath)); }
+    async retryOperation(requestId, stepId, invocationPath) { await (this.routineRuns.has(requestId) ? this.routine.retryOperation(requestId, stepId, invocationPath) : this.engine.retryOperation(requestId, stepId, invocationPath)); }
     async runFromHere(requestId, stepId, invocationPath) {
+        if (this.routineRuns.has(requestId)) {
+            const targeted = await this.routine.runFromHere(requestId, stepId, invocationPath);
+            if (targeted)
+                this.routineRuns.add(targeted.requestId);
+            return targeted;
+        }
         const accepted = await this.engine.runFromHere(requestId, stepId, invocationPath);
         return accepted ? { requestId: accepted.requestId, result: this.result(accepted.requestId) } : undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qaick/executor",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0",
   "description": "Host-neutral QAick action execution primitives.",
   "files": [
     "dist",
@@ -11,7 +11,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "alpha"
+    "tag": "latest"
   },
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
     "prepublishOnly": "npm run typecheck && npm test && npm run build"
   },
   "dependencies": {
-    "@qaick/contract": "0.2.12"
+    "@qaick/contract": "0.2.13"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",