@qaick/executor 0.1.0-alpha.2 → 0.1.0

package/dist/declared-inputs.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutableInput } from '@qaick/contract';
+/** Shared invocation semantics. Never coerce supplied arguments or rewrite declarations. */
+export declare function resolveDeclaredInputs(declarations?: readonly ExecutableInput[], arguments_?: Record<string, unknown>): {
+    inputs: {
+        [x: string]: unknown;
+    };
+    issues: {
+        code: string;
+        message: string;
+    }[];
+};

package/dist/declared-inputs.js

@@ -0,0 +1,32 @@
+/** Shared invocation semantics. Never coerce supplied arguments or rewrite declarations. */
+export function resolveDeclaredInputs(declarations = [], arguments_ = {}) {
+    const inputs = { ...arguments_ };
+    const issues = [];
+    if (!Array.isArray(declarations))
+        return { inputs, issues: [{ code: 'INVALID_INPUT', message: 'Declared inputs must be an array.' }] };
+    const seen = new Set();
+    for (const declaration of declarations) {
+        if (!declaration || typeof declaration.name !== 'string' || !declaration.name || seen.has(declaration.name) || !['string', 'number', 'boolean', 'json'].includes(declaration.type) || typeof declaration.required !== 'boolean') {
+            issues.push({ code: 'INVALID_INPUT', message: 'Invalid or duplicate declared input.' });
+            continue;
+        }
+        seen.add(declaration.name);
+        const supplied = Object.hasOwn(arguments_, declaration.name);
+        const value = supplied ? arguments_[declaration.name] : declaration.defaultValue;
+        if (value === undefined) {
+            delete inputs[declaration.name];
+            if (declaration.required)
+                issues.push({ code: 'MISSING_INPUT', message: `Required input ${declaration.name} is missing.` });
+            continue;
+        }
+        const validType = declaration.type === 'number' ? typeof value === 'number' && Number.isFinite(value)
+            : declaration.type === 'json' ? typeof value === 'object' && value !== null
+                : typeof value === declaration.type;
+        if (!validType || (declaration.required && value === '')) {
+            issues.push({ code: 'INVALID_INPUT', message: `Input ${declaration.name}: expected ${declaration.type}${declaration.required ? ' (required)' : ''}.` });
+            continue;
+        }
+        inputs[declaration.name] = value;
+    }
+    return { inputs, issues };
+}

package/dist/executor.js

@@ -1,3 +1,4 @@
+import { resolveDeclaredInputs } from './declared-inputs.js';
 const MAX_TIMEOUT_MS = 300_000;
 export function createExecutor(configuration = {}) {
     return new DefaultExecutor(configuration);
@@ -131,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;
@@ -180,7 +188,9 @@ export class DefaultExecutor {
             timeout = setTimeout(() => { run.timedOut = true; run.abort.abort(); }, timeoutMs);
         this.emit(run, 'run_started', 'created', 'Execution accepted.');
         this.emit(run, 'preflight_started', 'preflighting', 'Validating execution package.');
-        const issues = preflight(run.request.executionPackage, run.request.inputs, run.request.runtimeValues ?? {});
+        const arguments_ = resolveDeclaredInputs(run.request.executionPackage.inputDeclarations, run.request.inputs);
+        run.request = { ...run.request, inputs: arguments_.inputs };
+        const issues = [...arguments_.issues, ...preflight(run.request.executionPackage, arguments_.inputs, run.request.runtimeValues ?? {})];
         if (issues.length > 0 || run.request.options?.dryRun) {
             const result = this.baseResult(run, startedAt, issues.length > 0 ? 'failed' : 'completed', undefined, issues);
             if (timeout)
@@ -211,7 +221,11 @@ export class DefaultExecutor {
         for (const flow of pkg.flows ?? []) {
             if (run.cancelled || run.abort.signal.aborted)
                 throw new Error('Execution cancelled.');
-            const child = await this.executeFlow(run, flow.steps, inputs, [flow.id], startedAt, { kind: 'flow', id: flow.id, name: flow.name });
+            const arguments_ = resolveDeclaredInputs(flow.inputDeclarations, inputs);
+            const issues = [...arguments_.issues, ...preflight({ ...pkg, target: { kind: 'flow', id: flow.id, name: flow.name }, requiredInputs: flow.requiredInputs }, arguments_.inputs, run.request.runtimeValues ?? {})];
+            if (issues.length)
+                return this.baseResult(run, startedAt, 'failed', undefined, issues, children);
+            const child = await this.executeFlow(run, flow.steps, arguments_.inputs, [flow.id], startedAt, { kind: 'flow', id: flow.id, name: flow.name });
             children.push(child);
             if (child.state !== 'completed')
                 return this.baseResult(run, startedAt, child.state, child.error, undefined, children);
@@ -231,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);
@@ -269,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;
@@ -297,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')
@@ -309,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)
@@ -318,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(); });
@@ -335,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);
@@ -434,8 +478,9 @@ function preflight(pkg, inputs, runtimeValues) {
     const issues = [];
     if (!pkg.packageId || !pkg.target?.id)
         issues.push({ code: 'INVALID_PACKAGE', message: 'Execution package identity is incomplete.' });
+    const flowInputNames = new Set(pkg.target.kind === 'project' ? (pkg.flows ?? []).flatMap(flow => Array.isArray(flow.inputDeclarations) ? flow.inputDeclarations.flatMap(input => typeof input?.name === 'string' ? [input.name] : []) : []) : []);
     for (const name of pkg.requiredInputs ?? [])
-        if (inputs[name] === undefined)
+        if (inputs[name] === undefined && !flowInputNames.has(name))
             issues.push({ code: 'MISSING_INPUT', message: `Required input '${name}' is missing.` });
     for (const name of pkg.runtimeRequirements ?? [])
         if (runtimeValues[name] === undefined)

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './types.js';
 export * from './executor.js';
 export * from './in-memory-action-executor.js';
 export * from './migrated-executor.js';
+export { resolveDeclaredInputs } from './declared-inputs.js';

package/dist/index.js

@@ -2,3 +2,4 @@ export * from './types.js';
 export * from './executor.js';
 export * from './in-memory-action-executor.js';
 export * from './migrated-executor.js';
+export { resolveDeclaredInputs } from './declared-inputs.js';

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/dist/migrated-project-engine.js

@@ -90,7 +90,7 @@ export class MigratedProjectRunnerEngine {
             }
             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 };
+            const childPackage = { ...request.executionPackage, target: { kind: 'flow', id: flow.id, name: flow.name }, steps: flow.steps, flows: undefined, requiredInputs: flow.requiredInputs, inputDeclarations: flow.inputDeclarations };
             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);

package/dist/migrated-runner-engine.js

@@ -1,3 +1,4 @@
+import { resolveDeclaredInputs } from './declared-inputs.js';
 import { InMemoryActionAdapter } from './migrated-adapter.js';
 import { hashExecutionPackage } from './migrated-artifact-hash.js';
 import { RUNNER_PACKAGE_SCHEMA_VERSION } from './migrated-types.js';
@@ -119,7 +120,7 @@ export class MigratedRunnerEngine {
         return new Promise(resolve => { const previous = run.resultResolve; run.resultResolve = result => { previous(result); resolve(result); }; });
     }
     async execute(run, resultPromise) {
-        const { request } = run;
+        let { request } = run;
         const startedAt = new Date().toISOString();
         run.controlState = 'running';
         this.emit(run, 'run_started', 'created', 'Run accepted.');
@@ -133,7 +134,10 @@ export class MigratedRunnerEngine {
             await resultPromise;
             return;
         }
-        const validationIssues = this.validateAll(request.executionPackage, request.inputs, request.runtimeValues ?? {});
+        const arguments_ = resolveDeclaredInputs(request.executionPackage.inputDeclarations, request.inputs);
+        run.request = { ...request, inputs: arguments_.inputs };
+        request = run.request;
+        const validationIssues = [...arguments_.issues, ...this.validateAll(request.executionPackage, arguments_.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.` } } : {}) };

package/dist/migrated-types.d.ts

@@ -1,7 +1,7 @@
 /** Compatibility import for Runner modules. The canonical contract is the published @qaick/contract package. */
 export * from '@qaick/contract';
 /** The exact published contract package consumed by this Runner release. */
-export declare const RUNNER_CONTRACT_VERSION: "0.2.10";
+export declare const RUNNER_CONTRACT_VERSION: "0.2.12";
 export type ExecutionControlState = 'idle' | 'running' | 'pause-requested' | 'paused' | 'resuming' | 'stopped' | 'failed' | 'completed';
 export interface RunnerDebugSession {
     breakpoints: string[];

package/dist/migrated-types.js

@@ -1,4 +1,4 @@
 /** Compatibility import for Runner modules. The canonical contract is the published @qaick/contract package. */
 export * from '@qaick/contract';
 /** The exact published contract package consumed by this Runner release. */
-export const RUNNER_CONTRACT_VERSION = '0.2.10';
+export const RUNNER_CONTRACT_VERSION = '0.2.12';

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "@qaick/executor",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0",
   "description": "Host-neutral QAick action execution primitives.",
-  "files": ["dist", "README.md"],
-  "engines": { "node": ">=20" },
-  "publishConfig": { "access": "public", "tag": "alpha" },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vladmus/QAICK_Executor.git"
@@ -26,7 +34,7 @@
     "prepublishOnly": "npm run typecheck && npm test && npm run build"
   },
   "dependencies": {
-    "@qaick/contract": "0.2.11"
+    "@qaick/contract": "0.2.13"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",