@gfdelarue/testkit 0.3.0

package/dist/app/run/engine-execution-failures.d.ts

@@ -0,0 +1,41 @@
+import { type EngineFailureClassification } from "../../engines/api/index.js";
+import type { PersistedArtifactReference } from "../../evidence/index.js";
+import type { EngineTaskExecutionOutcome } from "./engine-execution.js";
+import type { RuntimeNodeSetupCleanupOwner } from "./setup/runtime-node-setup-protocol.js";
+export type EngineExecutionRuntimeImpact = "fail-graph" | "invalidate-lease" | "none";
+export interface EngineExecutionBridgeDisposition {
+    readonly classification: EngineFailureClassification | undefined;
+    readonly notifyRuntimeError: boolean;
+    readonly runtimeImpact: EngineExecutionRuntimeImpact;
+    readonly status: "cancelled" | "failed" | "not_run";
+}
+export interface EngineExecutionCleanupFailure {
+    readonly error: Error;
+    readonly owner: RuntimeNodeSetupCleanupOwner;
+    readonly taskId: string;
+}
+export declare const ENGINE_REPORTER_CALLBACK_CANCELLED_CODE = "TESTKIT_ENGINE_REPORTER_CALLBACK_CANCELLED";
+export declare class EngineExecutionBridgeError extends Error {
+    readonly artifactReferencesByTaskId: ReadonlyMap<string, readonly PersistedArtifactReference[]>;
+    readonly completedOutcomesByTaskId: ReadonlyMap<string, EngineTaskExecutionOutcome>;
+    readonly disposition: EngineExecutionBridgeDisposition;
+    readonly failingTaskId: null | string;
+    readonly cause: unknown;
+    constructor(message: string, cause: unknown, disposition: Readonly<EngineExecutionBridgeDisposition>, artifactReferencesByTaskId: ReadonlyMap<string, readonly PersistedArtifactReference[]>, completedOutcomesByTaskId?: ReadonlyMap<string, EngineTaskExecutionOutcome>, failingTaskId?: null | string);
+}
+export declare class EngineExecutionReporterCallbackError extends Error {
+    readonly cancelled: boolean;
+    readonly cause: unknown;
+    constructor(phase: "taskFinished" | "taskStarted", cause: unknown);
+}
+export declare function executeManagedEngineRequest<Request, Result>(manager: Readonly<{
+    execute(request: Readonly<Request>): Promise<Result>;
+}>, request: Readonly<Request>): Promise<Result>;
+export declare function buildBridgeError(operationErrors: readonly Error[], cleanupFailures: readonly Readonly<EngineExecutionCleanupFailure>[], disposition: Readonly<EngineExecutionBridgeDisposition>, artifactReferencesByTaskId: ReadonlyMap<string, readonly PersistedArtifactReference[]>, completedOutcomesByTaskId: ReadonlyMap<string, EngineTaskExecutionOutcome>, activeTaskId: null | string): EngineExecutionBridgeError;
+export declare function resolveBridgeDisposition(operationErrors: readonly Error[], cleanupFailures: readonly Readonly<EngineExecutionCleanupFailure>[], observedInfraOperationFailure: boolean, activeFailureDisposition: Readonly<EngineExecutionBridgeDisposition>): EngineExecutionBridgeDisposition;
+export declare function managerFailureBridgeDisposition(parentSignal: AbortSignal, invocationSignal: AbortSignal, error: unknown): EngineExecutionBridgeDisposition;
+export declare function runtimeNodeSetupBridgeDisposition(error: unknown): EngineExecutionBridgeDisposition;
+export declare function cancelledBridgeDisposition(): EngineExecutionBridgeDisposition;
+export declare function infraBridgeDisposition(runtimeImpact?: EngineExecutionRuntimeImpact): EngineExecutionBridgeDisposition;
+export declare function reporterBridgeDisposition(runtimeImpact?: EngineExecutionRuntimeImpact): EngineExecutionBridgeDisposition;
+export declare function productBridgeDisposition(runtimeImpact?: EngineExecutionRuntimeImpact): EngineExecutionBridgeDisposition;

package/dist/app/run/engine-execution-failures.js

@@ -0,0 +1 @@
+import{isEngineTaskDeadlineExceededReason as g}from"../../engines/api/index.js";import{classifyRuntimeNodeSetupFailure as p,getRuntimeNodeSetupCleanupFailures as m}from"./setup/runtime-node-setup.js";export const ENGINE_REPORTER_CALLBACK_CANCELLED_CODE="TESTKIT_ENGINE_REPORTER_CALLBACK_CANCELLED";export class EngineExecutionBridgeError extends Error{artifactReferencesByTaskId;completedOutcomesByTaskId;disposition;failingTaskId;cause;constructor(n,t,i,r,o=new Map,a=null){super(n,{cause:t}),this.name="EngineExecutionBridgeError",this.cause=t,this.disposition=Object.freeze({...i}),this.failingTaskId=a,this.artifactReferencesByTaskId=r,this.completedOutcomesByTaskId=o}}export class EngineExecutionReporterCallbackError extends Error{cancelled;cause;constructor(n,t){const i=E(t);super(`Engine reporter ${n} callback failed: ${i.message}`,{cause:t}),this.name="EngineExecutionReporterCallbackError",this.cancelled=x(i)===ENGINE_REPORTER_CALLBACK_CANCELLED_CODE,this.cause=t}}export async function executeManagedEngineRequest(e,n){return await e.execute(n)}export function buildBridgeError(e,n,t,i,r,o){const a=n.map(s=>s.error),c=[...e,...a],u=e.map(s=>s.message).join("; "),f=a.map(s=>s.message).join("; "),l=e.length===0?`Engine node setup cleanup failed: ${f}`:a.length===0?u:`${u}; node setup cleanup also failed: ${f}`,d=c.length===1?c[0]:new AggregateError(c,"Engine execution bridge failed");return new EngineExecutionBridgeError(l,d,t,i,r,n[0]?.taskId??o)}export function resolveBridgeDisposition(e,n,t,i){return n.length>0?i.classification==="infra"&&i.runtimeImpact==="fail-graph"?infraBridgeDisposition("fail-graph"):n.some(r=>r.owner==="testkit")?infraBridgeDisposition("invalidate-lease"):e.length>0&&e.every(r=>r instanceof EngineExecutionReporterCallbackError)?e.every(r=>r instanceof EngineExecutionReporterCallbackError&&r.cancelled)?productBridgeDisposition("invalidate-lease"):reporterBridgeDisposition("invalidate-lease"):t||e.length>0&&i.classification==="infra"?infraBridgeDisposition(i.runtimeImpact==="fail-graph"?"fail-graph":"invalidate-lease"):productBridgeDisposition("invalidate-lease"):e.length>0&&e.every(r=>r instanceof EngineExecutionReporterCallbackError)?e.every(r=>r instanceof EngineExecutionReporterCallbackError&&r.cancelled)?cancelledBridgeDisposition():reporterBridgeDisposition(i.runtimeImpact):t&&i.classification!=="infra"?infraBridgeDisposition("none"):{...i}}export function managerFailureBridgeDisposition(e,n,t){return!n.aborted||t!==n.reason?infraBridgeDisposition("none"):e.aborted&&t===e.reason?cancelledBridgeDisposition():g(n.reason)?productBridgeDisposition():infraBridgeDisposition("none")}export function runtimeNodeSetupBridgeDisposition(e){const n=p(e),t=m(e).length>0?"invalidate-lease":"none";return n==="cancelled"?cancelledBridgeDisposition():n==="infra"?infraBridgeDisposition("invalidate-lease"):productBridgeDisposition(t)}export function cancelledBridgeDisposition(){return{classification:void 0,notifyRuntimeError:!1,runtimeImpact:"none",status:"cancelled"}}export function infraBridgeDisposition(e="none"){return{classification:"infra",notifyRuntimeError:!0,runtimeImpact:e,status:"not_run"}}export function reporterBridgeDisposition(e="none"){return{classification:"infra",notifyRuntimeError:!1,runtimeImpact:e,status:"not_run"}}export function productBridgeDisposition(e="none"){return{classification:"product",notifyRuntimeError:!1,runtimeImpact:e,status:"failed"}}function E(e){return e instanceof Error?e:new Error(String(e))}function x(e){return e.code}

package/dist/app/run/engine-execution-observer.d.ts

@@ -0,0 +1,21 @@
+import type { EngineExecutionObserver, EngineTaskOutcome } from "../../engines/api/index.js";
+import type { PersistedArtifactReference } from "../../evidence/index.js";
+import { type EvidenceLedger } from "./engine-evidence-persistence.js";
+import type { EngineExecutableTask, EngineTaskExecutionOutcome } from "./engine-execution.js";
+import type { ScheduledTask } from "./scheduler/index.js";
+interface CreateEngineExecutionObserverOptions {
+    readonly artifactReferencesByTaskId: ReadonlyMap<string, PersistedArtifactReference[]>;
+    readonly completedOutcomesByTaskId: Map<string, EngineTaskExecutionOutcome>;
+    readonly errors: Error[];
+    readonly executableTask: EngineExecutableTask;
+    readonly invocationEvidenceLedger: EvidenceLedger;
+    readonly productDir: string;
+    readonly taskBatchIndex: number;
+    readonly taskEvidenceLedgers: ReadonlyMap<string, EvidenceLedger>;
+    readonly tasks: readonly ScheduledTask[];
+    readonly tasksById: ReadonlyMap<string, ScheduledTask>;
+    readonly workspaceArtifactDirectory: string;
+}
+type MapObservedOutcome = (outcome: Readonly<EngineTaskOutcome>, task: ScheduledTask, artifacts: PersistedArtifactReference[], executableTask: EngineExecutableTask, batchIndex: number) => EngineTaskExecutionOutcome;
+export declare function createEngineExecutionObserver({ artifactReferencesByTaskId, completedOutcomesByTaskId, errors, executableTask, invocationEvidenceLedger, productDir, taskBatchIndex, taskEvidenceLedgers, tasks, tasksById, workspaceArtifactDirectory, }: Readonly<CreateEngineExecutionObserverOptions>, mapOutcome: MapObservedOutcome): EngineExecutionObserver;
+export {};

package/dist/app/run/engine-execution-observer.js

@@ -0,0 +1 @@
+import{contextualError as o,persistTrackedEngineEvidence as l,requireTaskArtifacts as v,requireTaskEvidenceLedger as f}from"./engine-evidence-persistence.js";export function createEngineExecutionObserver({artifactReferencesByTaskId:t,completedOutcomesByTaskId:g,errors:i,executableTask:u,invocationEvidenceLedger:E,productDir:s,taskBatchIndex:h,taskEvidenceLedgers:c,tasks:k,tasksById:a,workspaceArtifactDirectory:d},p){const b=k[0];return{evidenceRecorded(e,r){try{const n=e===null?b:a.get(e);if(!n){i.push(new Error(`Engine observer recorded evidence for unknown task ${e??"null"}`));return}const w=v(t,String(n.id)),x=e===null?E:f(c,e);l(r,{artifactRoot:d,errors:i,ledger:x,mode:"observed",productDir:s,references:w,scope:e===null?"invocation":"task",task:n})}catch(n){i.push(o("Engine evidence observer failed",n))}},taskFinished(e){try{const r=a.get(e.taskId);if(!r){i.push(new Error(`Engine observer finished unknown task ${e.taskId}`));return}const n=v(t,e.taskId);l(e.evidence,{artifactRoot:d,errors:i,ledger:f(c,e.taskId),mode:"reconcile",productDir:s,references:n,scope:"task",task:r}),g.set(e.taskId,p(e,r,n,u,h))}catch(r){i.push(o("Engine task-finished observer failed",r))}},taskStarted(){}}}

package/dist/app/run/engine-execution-reporting.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_ENGINE_REPORTER_CALLBACK_TIMEOUT_MS = 5000;
+export interface EngineReporterCallbackBoundary {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs: number;
+}
+export declare class EngineReporterCallbackTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(label: string, timeoutMs: number);
+}
+export declare class EngineReporterCallbackCancelledError extends Error {
+    readonly code = "TESTKIT_ENGINE_REPORTER_CALLBACK_CANCELLED";
+    readonly cause: unknown;
+    constructor(label: string, cause: unknown);
+}
+export declare function invokeBoundedReporterCallback(label: string, callback: () => unknown, boundary: Readonly<EngineReporterCallbackBoundary>): Promise<void>;
+export declare function invokeEngineReporterCallback(phase: "taskFinished" | "taskStarted", callback: () => unknown, boundary: Readonly<EngineReporterCallbackBoundary>): Promise<void>;
+export declare function captureEngineReporterCallback(errors: Error[], phase: "taskFinished" | "taskStarted", callback: () => unknown, boundary: Readonly<EngineReporterCallbackBoundary>): Promise<void>;

package/dist/app/run/engine-execution-reporting.js

@@ -0,0 +1 @@
+import{ENGINE_REPORTER_CALLBACK_CANCELLED_CODE as c,EngineExecutionReporterCallbackError as l}from"./engine-execution-failures.js";export const DEFAULT_ENGINE_REPORTER_CALLBACK_TIMEOUT_MS=5e3;export class EngineReporterCallbackTimeoutError extends Error{timeoutMs;constructor(n,e){super(`${n} exceeded ${e.toString()} milliseconds`),this.name="EngineReporterCallbackTimeoutError",this.timeoutMs=e}}export class EngineReporterCallbackCancelledError extends Error{code=c;cause;constructor(n,e){const t=e instanceof Error?e:new Error(String(e));super(`${n} was cancelled: ${t.message}`,{cause:e}),this.name="EngineReporterCallbackCancelledError",this.cause=e}}export async function invokeBoundedReporterCallback(r,n,e){const t=Promise.resolve(n());let o,i;const a=new Promise((E,s)=>{e.signal?.aborted?s(new EngineReporterCallbackCancelledError(r,e.signal.reason)):e.signal!==void 0&&(i=()=>{s(new EngineReporterCallbackCancelledError(r,e.signal?.reason))},e.signal.addEventListener("abort",i,{once:!0})),o=setTimeout(()=>{s(new EngineReporterCallbackTimeoutError(r,e.timeoutMs))},e.timeoutMs)});try{await Promise.race([t,a])}finally{o!==void 0&&clearTimeout(o),i!==void 0&&e.signal!==void 0&&e.signal.removeEventListener("abort",i)}}export async function invokeEngineReporterCallback(r,n,e){try{await invokeBoundedReporterCallback(`Engine reporter ${r} callback`,n,e)}catch(t){throw new l(r,t)}}export async function captureEngineReporterCallback(r,n,e,t){try{await invokeEngineReporterCallback(n,e,t)}catch(o){r.push(o instanceof Error?o:new Error(String(o)))}}

package/dist/app/run/engine-execution.d.ts

@@ -0,0 +1,60 @@
+import { type EngineExecutionResult, type EngineTaskOutcome } from "../../engines/api/index.js";
+import { type EngineId } from "../../domain/identifiers.js";
+import { type TestOutcomeStatus } from "../../domain/test-outcomes.js";
+import type { ResolvedEngineExecutionSession } from "../../engines/manager.js";
+import { type PersistedArtifactReference } from "../../evidence/index.js";
+export { EngineExecutionBridgeError, type EngineExecutionBridgeDisposition, type EngineExecutionRuntimeImpact, } from "./engine-execution-failures.js";
+import { type EndpointReadinessResult } from "./endpoint-readiness.js";
+import { type NormalizedCheckDetail, type TaskFailureDetail } from "./failure-details.js";
+import type { RuntimeTaskReporter } from "./runtime-task-types.js";
+import type { ScheduledTask } from "./scheduler/index.js";
+import type { TaskBatch } from "./task-batches.js";
+import type { ExecutionEnvironmentLease } from "../../steps/index.js";
+import type { ReadyEnvironment } from "../../environment/ready-environment.js";
+export type EngineExecutableTask = ScheduledTask | TaskBatch<ScheduledTask>;
+export interface EngineExecutionManager {
+    withEngine<Result>(engineId: EngineId, signal: AbortSignal, operation: (session: ResolvedEngineExecutionSession) => Result | PromiseLike<Result>): Promise<Result>;
+}
+export interface EngineExecutionLifecycle {
+    isStopRequested(): boolean;
+    readonly runId: string;
+    readonly signal: AbortSignal;
+}
+export interface EngineExecutionLease extends ExecutionEnvironmentLease {
+    readonly leaseDir: string;
+    readonly leaseId: string;
+}
+export interface EngineTaskExecutionOutcome {
+    artifacts: PersistedArtifactReference[];
+    blockedByRuntime: boolean;
+    checkDetails: NormalizedCheckDetail[];
+    durationMs: number;
+    error: null | string;
+    failureDetails: TaskFailureDetail[];
+    finishedAt: number;
+    infraFailed: boolean;
+    reason: null | string;
+    runtimeBatch?: {
+        fileCount: number;
+        files: string[];
+        id: string;
+        index: number;
+    };
+    startedAt: number;
+    status: TestOutcomeStatus;
+    task: ScheduledTask;
+}
+export interface EngineTaskExecutionResult {
+    outcomes: EngineTaskExecutionOutcome[];
+}
+export interface EngineExecutionReporter extends RuntimeTaskReporter<ScheduledTask> {
+    taskFinished?(task: Readonly<ScheduledTask>, outcome: Readonly<EngineTaskExecutionOutcome>): unknown;
+}
+export declare function executeEngineTask(manager: EngineExecutionManager, environment: ReadyEnvironment, executableTask: EngineExecutableTask, lifecycle: EngineExecutionLifecycle, reporter?: null | EngineExecutionReporter): Promise<EngineTaskExecutionResult>;
+export declare function mapEngineOutcomes(tasks: readonly ScheduledTask[], result: Readonly<EngineExecutionResult>): Array<{
+    outcome: EngineTaskOutcome;
+    task: ScheduledTask;
+}>;
+export declare function buildEndpointReadinessOutcomes(tasks: readonly ScheduledTask[], executableTask: EngineExecutableTask, readiness: Extract<EndpointReadinessResult, {
+    ok: false;
+}>, cancelled: boolean, startedAt: number, finishedAt: number): EngineTaskExecutionOutcome[];

package/dist/app/run/engine-execution.js

@@ -0,0 +1 @@
+import U from"node:fs";import F from"node:path";import{EngineTaskDeadlineExceededError as Me}from"../../engines/api/index.js";import"../../domain/identifiers.js";import"../../domain/test-outcomes.js";import{resolveEngineProfile as Ie}from"../../engines/catalog.js";import{BUILT_IN_ENGINE_ORCHESTRATION as be}from"./engine-orchestration.js";import{persistTaskArtifacts as Oe}from"../../evidence/index.js";import{createEvidenceLedger as se,persistTrackedEngineEvidence as ae,requireTaskArtifacts as Ne,requireTaskEvidenceLedger as _e}from"./engine-evidence-persistence.js";import{applyConsumerNodeSetupCleanupFailures as ce,cleanupPreparedNodeSetups as ue}from"./engine-execution-cleanup.js";import{buildBridgeError as Re,EngineExecutionBridgeError as Fe,executeManagedEngineRequest as Ae,infraBridgeDisposition as q,managerFailureBridgeDisposition as Be,productBridgeDisposition as z,reporterBridgeDisposition as G,resolveBridgeDisposition as de,runtimeNodeSetupBridgeDisposition as Ce}from"./engine-execution-failures.js";import{captureEngineReporterCallback as fe,DEFAULT_ENGINE_REPORTER_CALLBACK_TIMEOUT_MS as $e,invokeEngineReporterCallback as le}from"./engine-execution-reporting.js";import{createEngineExecutionObserver as xe}from"./engine-execution-observer.js";export{EngineExecutionBridgeError}from"./engine-execution-failures.js";import{waitForEndpointReadinessPreflight as Pe}from"./endpoint-readiness.js";import{collectCheckDetailsFromRuntimeArtifacts as Le,collectFailureDetailsFromRuntimeArtifacts as je}from"./failure-details.js";import{buildRuntimeFixtureManifest as Je}from"./runtime-fixtures.js";import{MAX_RUNTIME_NODE_SETUP_CLEANUP_TIMEOUT_MS as Ue,runRuntimeNodeSetup as qe}from"./setup/runtime-node-setup.js";export async function executeEngineTask(e,t,n,r,s=null){const i=t,u={signal:r.signal,timeoutMs:$e},m="batchTasks"in n?n.batchTasks:[n],w=m[0],S=t.services.get(w.targetName);if(!S)throw new Error(`Runtime instance is missing target config "${w.targetName}"`);const d=S.config;we(d.productDir,"product directory"),we(i.leaseDir,"runtime lease directory");const D=Ie(w.testType,w.engineId),M=be.resolve(D),O=Xe(d.testkit.execution.fileTimeoutSeconds),ke=Date.now(),V=pe(ke,O),B=Ge(t),N=Object.hasOwn(B,w.serviceName)?B[w.serviceName]:null;if(M.endpointReadinessOwner==="orchestrator-http"){if(N===null)throw new Error(`Service "${d.name}" requires local.baseUrl for ${D.id} suites`);const C=Date.now(),v=H(r.signal,V);let y;try{y=await Pe({baseUrl:N,serviceName:d.name,lifecycle:r,signal:v.signal,options:Ye(Qe(V))})}finally{v.dispose()}if(!y.ok){const I=r.isStopRequested()||r.signal.aborted,k=Date.now(),c=buildEndpointReadinessOutcomes(m,n,y,I,C,k),a=[];let g=null;for(const E of c){const l=a.length;await fe(a,"taskStarted",()=>s?.taskStarted?.(E.task,d),u),g===null&&a.length>l&&(g=String(E.task.id)),await fe(a,"taskFinished",()=>s?.taskFinished?.(E.task,E),u),g===null&&a.length>l&&(g=String(E.task.id))}if(a.length>0){const E=a.length===1?a[0]:new AggregateError(a,"Engine readiness reporting failed");throw new Fe(`${y.reason}; ${a.map(l=>l.message).join("; ")}`,E,de(a,[],!1,I?{classification:void 0,notifyRuntimeError:!1,runtimeImpact:"none",status:"cancelled"}:G("fail-graph")),new Map(m.map(l=>[String(l.id),[]])),new Map(c.map(l=>[String(l.task.id),l])),g)}return{outcomes:c}}}return e.withEngine(D.engineId,r.signal,async C=>{const v=He(i,d.productDir);U.mkdirSync(v.temporaryDirectory,{recursive:!0}),U.mkdirSync(v.artifactDirectory,{recursive:!0});const y=new Map(m.map(p=>[String(p.id),[]])),I=new Map(m.map(p=>[String(p.id),se()])),k=new Map,c=[];let a=z(),g=!1;const E=[],l=[],W=[];let X=null;const Q=new Set,$=async(p,o)=>{const f=String(p.id);Q.has(f)||(Q.add(f),await le("taskFinished",()=>s?.taskFinished?.(p,o),u))};try{for(const[p,o]of m.entries()){a=G();const f=String(o.id);X=f,await le("taskStarted",()=>s?.taskStarted?.(o,d),u),a=z();const Z=M.buildRuntimeEnvironment({baseUrl:N,database:S.database,targetConfig:d,task:o}),_=pe(Date.now(),O),ee=H(r.signal,_);let b;try{b=await qe({cleanupTimeoutMs:Math.min(O,Ue),deadlineMs:_,targetConfig:d,task:o,lease:i,runtimeEnv:Z,signal:ee.signal})}catch(h){throw a=Ce(h),h}finally{ee.dispose()}E.push({cleanup:b.cleanup,taskId:f}),a=q();for(const h of b.artifacts){const T=Oe(d.productDir,o,[h]);y.get(String(o.id))?.push(...T)}a=z();const R={baseUrl:N,lease:i,profile:D,runtimeEnvironment:Z,targetConfig:d,task:o},te=M.resolveConfiguration(R),ve={...te===void 0?{}:{configuration:te},environment:M.buildEnvironment(R),fixtures:nt(Je(d.productDir,o.file),`fixture manifest for ${o.file}`),setupData:he(b.setupData,`node setup data for ${o.file}`),supportModules:M.resolveSupportModules(R)},ye=ze(R);a=q();const De=c.length,ne=se(),Te=xe({artifactReferencesByTaskId:y,completedOutcomesByTaskId:k,errors:c,executableTask:n,invocationEvidenceLedger:ne,productDir:d.productDir,taskBatchIndex:p,taskEvidenceLedgers:I,tasks:[o],tasksById:new Map([[f,o]]),workspaceArtifactDirectory:v.artifactDirectory},ge),x=H(r.signal,_);try{const h={invocationId:Ve(r,i,o),observer:Te,profile:D,signal:x.signal,target:{endpoints:B,inputs:Ke()},tasks:[{deadlineMs:_,id:f,file:o.file,serviceName:o.serviceName,suiteName:o.suiteName,testType:o.testType,timeoutMs:O,inputs:ve,orchestration:ye}],workspace:v};let T;try{T=await Ae(C,h)}catch(oe){throw a=Be(r.signal,x.signal,oe),oe}const re=mapEngineOutcomes([o],T)[0],j=Ne(y,f),Se=_e(I,f);ae(re.outcome.evidence,{artifactRoot:v.artifactDirectory,errors:c,ledger:Se,mode:"reconcile",productDir:d.productDir,references:j,scope:"task",task:o});const J=ge(re.outcome,o,j,n,p);k.set(f,J),J.infraFailed&&J.blockedByRuntime&&(a=q("fail-graph"));const ie=et(T);tt(ie)&&ae(ie,{artifactRoot:v.artifactDirectory,errors:c,ledger:ne,mode:"reconcile",productDir:d.productDir,references:j,scope:"invocation",task:o})}finally{x.dispose()}c.length>De&&(g=!0),E.pop();const P=await ue([{cleanup:b.cleanup,taskId:f}]);if(P.length>0){l.push(...P),ce(k,P);const h=k.get(f);if(h!==void 0)try{await $(o,h)}catch(T){c.push(A(T))}break}if(c.length>0)break;const L=k.get(f);if(L===void 0){c.push(new Error(`Engine task ${f} completed without a mapped outcome`)),g=!0;break}W.push(L),a=G();try{await $(o,L)}catch(h){c.push(A(h)),g=!0;break}}}catch(p){const o=c.length;c.push(A(p)),(o>0||a.classification==="infra")&&(g=!0)}const Y=await ue(E);l.push(...Y),ce(k,Y);for(const p of m){const o=k.get(String(p.id));if(o!==void 0)try{await $(p,o)}catch(f){c.push(A(f))}}if(c.length>0||l.length>0)throw Re(c,l,de(c,l,g,a),y,k,X);return{outcomes:W}})}function ze(e){const t=e.targetConfig.testkit.mode;if(t!==void 0&&(typeof t!="string"||t.trim().length===0))throw new Error("Testkit execution mode must be a non-empty string");const n=e.targetConfig.runtimeId;return{lease:{directory:e.lease.leaseDir,id:String(e.lease.leaseId)},mode:t??"test",...n==null?{}:{runtimeId:String(n)}}}export function mapEngineOutcomes(e,t){const n=new Map(e.map(i=>[String(i.id),i])),r=new Map;for(const i of t.outcomes){const u=n.get(i.taskId);if(!u)throw new Error(`Engine manager returned an outcome for unknown task ${i.taskId}`);if(r.has(i.taskId))throw new Error(`Engine manager returned duplicate outcomes for task ${i.taskId}`);r.set(i.taskId,{task:u,outcome:i})}const s=e.map(i=>String(i.id)).filter(i=>!r.has(i));if(s.length>0)throw new Error(`Engine manager did not return outcomes for task(s): ${s.join(", ")}`);return e.map(i=>{const u=r.get(String(i.id));if(!u)throw new Error("Engine outcome mapping invariant failed");return u})}export function buildEndpointReadinessOutcomes(e,t,n,r,s,i){const u=Math.max(0,i-s);return e.map((m,w)=>({task:m,status:r?"cancelled":"not_run",error:null,reason:n.reason,infraFailed:!r,blockedByRuntime:!r,durationMs:w===0?u:0,startedAt:s,finishedAt:i,artifacts:[],failureDetails:r?[]:[...n.failureDetails],checkDetails:[],...Ee(t,m)}))}function Ge(e){return Object.freeze(Object.fromEntries([...e.services.values()].flatMap(({config:t,baseUrl:n})=>typeof n=="string"&&n.length>0?[[t.name,n]]:[])))}function He(e,t){const n=F.join(e.leaseDir,"engine-execution");return{rootDirectory:t,temporaryDirectory:F.join(n,"temporary"),artifactDirectory:F.join(n,"artifacts")}}function Ke(){return{environment:{},fixtures:{},supportModules:{}}}function Ve(e,t,n){return[e.runId,t.leaseId,We(n)].join(":")}function We(e){return"batchId"in e?e.batchId:String(e.id)}function Xe(e){const t=e*1e3;if(!Number.isSafeInteger(t)||t<=0)throw new Error("Engine task timeout must be a positive safe integer");return t}function pe(e,t){const n=e+t;if(!Number.isSafeInteger(n)||n<=e)throw new Error("Engine task deadline must be a positive safe integer");return n}function Qe(e){return Math.max(1,e-Date.now())}function Ye(e){const t=me(process.env.TESTKIT_HTTP_ENDPOINT_PREFLIGHT_TIMEOUT_MS,3e4),n=me(process.env.TESTKIT_HTTP_ENDPOINT_PREFLIGHT_ATTEMPT_TIMEOUT_MS,5e3);return{timeoutMs:Math.min(t,e),attemptTimeoutMs:Math.min(n,e)}}function me(e,t){const n=Number(e);return Number.isInteger(n)&&n>0?n:t}function H(e,t){const n=new AbortController;let r=null;const s=()=>{n.abort(e.reason)},i=()=>{const u=t-Date.now();if(u<=0){n.abort(new Me(t));return}r=setTimeout(i,Math.min(u,2147483647)),r.unref()};return e.aborted?s():(e.addEventListener("abort",s,{once:!0}),i()),{signal:n.signal,dispose(){r!==null&&clearTimeout(r),e.removeEventListener("abort",s)}}}function ge(e,t,n,r,s){const i=je(e.evidence.artifacts),u=i.some(D=>t.engineId==="node-vitest"&&D.kind==="vitest-test"),m=[...e.failure&&!u?[Ze(e.failure)]:[],...i],w=Le(e.evidence.artifacts),S=e.status==="not_run",d=S||e.failure?.classification==="infra";return{task:t,status:e.status,error:e.status==="failed"?e.failure?.message??"Engine task failed without a message":null,reason:e.status==="failed"||e.status==="passed"?null:e.failure?.message??`Engine task ${e.status}`,infraFailed:d,blockedByRuntime:S,durationMs:e.durationMs,startedAt:e.startedAtMs,finishedAt:e.finishedAtMs,artifacts:n,failureDetails:m,checkDetails:w,...Ee(r,t,s)}}function Ee(e,t,n){if(!("batchTasks"in e))return{};const r=n??e.batchTasks.findIndex(s=>s.id===t.id&&s.file===t.file);if(r<0)throw new Error(`Task ${String(t.id)} is missing from its engine batch`);return{runtimeBatch:{id:e.batchId,index:r,fileCount:e.batchTasks.length,files:e.batchTasks.map(s=>s.file)}}}function Ze(e){const t=e.code??"ENGINE_TASK_FAILED",n={code:t,details:e.details===void 0?null:rt(e.details)};return{kind:"engine-failure",key:t,title:t,...e.classification===void 0?{}:{classification:e.classification},count:1,message:e.message,actual:n,...e.stack===void 0?{}:{stack:e.stack}}}function et(e){return{artifacts:K(e.evidence.artifacts,e.outcomes.flatMap(t=>t.evidence.artifacts)),logs:K(e.evidence.logs,e.outcomes.flatMap(t=>t.evidence.logs)),metrics:K(e.evidence.metrics,e.outcomes.flatMap(t=>t.evidence.metrics)),...e.evidence.native===void 0?{}:{native:e.evidence.native}}}function K(e,t){const n=new Map;for(const r of t){const s=JSON.stringify(r);n.set(s,(n.get(s)??0)+1)}return e.filter(r=>{const s=JSON.stringify(r),i=n.get(s)??0;return i===0?!0:(n.set(s,i-1),!1)})}function tt(e){return e.artifacts.length>0||e.logs.length>0||e.metrics.length>0||e.native!==void 0}function nt(e,t){const n=he(e,t);if(n===null||Array.isArray(n)||typeof n!="object")throw new TypeError(`${t} must contain a JSON object`);return n}function he(e,t){try{const n=JSON.stringify(e);if(typeof n!="string")throw new TypeError(`${t} must be JSON-serializable`);return JSON.parse(n)}catch(n){throw new TypeError(`${t} must be JSON-serializable`,{cause:n})}}function rt(e){return JSON.parse(JSON.stringify(e))}function we(e,t){if(!F.isAbsolute(e))throw new Error(`Engine execution ${t} must be absolute`);if(!U.statSync(e).isDirectory())throw new Error(`Engine execution ${t} must be a directory`)}function A(e){return e instanceof Error?e:new Error(String(e))}

package/dist/app/run/engine-orchestration.d.ts

@@ -0,0 +1,49 @@
+import { type EngineExecutionInputs, type EngineJsonObject, type RunnerProfileDescriptor } from "../../engines/api/index.js";
+import { type EngineId, type RunnerProfileId } from "../../domain/identifiers.js";
+import type { DatabaseInfo } from "../../database/index.js";
+import type { ScheduledTask } from "./scheduler/index.js";
+import { type ExecutionEnvironmentConfig, type ExecutionEnvironmentLease } from "../../steps/index.js";
+import type { EndpointReadinessOwner } from "../../engines/definitions.js";
+export type { EndpointReadinessOwner } from "../../engines/definitions.js";
+export interface EngineOrchestrationTargetConfig extends ExecutionEnvironmentConfig {
+    readonly engineConfigurations?: Readonly<Partial<Record<EngineId, EngineJsonObject>>>;
+    readonly stateDir: string;
+    readonly testkit: ExecutionEnvironmentConfig["testkit"] & {
+        readonly local?: (NonNullable<ExecutionEnvironmentConfig["testkit"]["local"]> & {
+            readonly baseUrl?: null | string;
+            readonly cwd?: string;
+        }) | null;
+    };
+}
+export interface EngineOrchestrationLease extends ExecutionEnvironmentLease {
+    readonly leaseDir: string;
+    readonly leaseId: number | string;
+}
+export interface EngineInputPreparationContext {
+    readonly baseUrl: null | string;
+    readonly lease: EngineOrchestrationLease;
+    readonly profile: RunnerProfileDescriptor;
+    readonly runtimeEnvironment: Readonly<Record<string, string>>;
+    readonly targetConfig: EngineOrchestrationTargetConfig;
+    readonly task: ScheduledTask;
+}
+export interface EngineRuntimePreparationContext {
+    readonly baseUrl: null | string;
+    readonly database: Readonly<DatabaseInfo> | null;
+    readonly targetConfig: EngineOrchestrationTargetConfig;
+    readonly task: ScheduledTask;
+}
+export interface EngineOrchestrationIntegration {
+    buildEnvironment(context: Readonly<EngineInputPreparationContext>): Readonly<Record<string, string>>;
+    buildRuntimeEnvironment(context: Readonly<EngineRuntimePreparationContext>): Readonly<Record<string, string>>;
+    readonly endpointReadinessOwner: EndpointReadinessOwner;
+    readonly engineId: EngineId;
+    readonly profileId: RunnerProfileId;
+    resolveConfiguration(context: Readonly<EngineInputPreparationContext>): EngineExecutionInputs["configuration"];
+    resolveSupportModules(context: Readonly<EngineInputPreparationContext>): EngineExecutionInputs["supportModules"];
+}
+export interface EngineOrchestrationRegistry {
+    readonly integrations: readonly EngineOrchestrationIntegration[];
+    resolve(profile: Readonly<RunnerProfileDescriptor>): EngineOrchestrationIntegration;
+}
+export declare const BUILT_IN_ENGINE_ORCHESTRATION: EngineOrchestrationRegistry;

package/dist/app/run/engine-orchestration.js

@@ -0,0 +1 @@
+import{BUILT_IN_RUNNER_PROFILES as a}from"../../engines/definitions.js";import u from"node:fs";import f from"node:path";import"../../engines/api/index.js";import"../../domain/identifiers.js";import{findConfigFile as c,resolveServiceCwd as g}from"../../config/loader/index.js";import{buildPlaywrightUiConfig as l}from"./playwright-configuration.js";import{buildTaskExecutionEnv as d}from"../../steps/index.js";import{findPlaywrightConfigFile as m}from"../../engines/playwright/runtime/config-file.js";const E=Object.freeze(["tsconfig.json","tsconfig.build.json"]),o=Object.freeze(a.map(n=>Object.freeze({engineId:n.engineId,profileId:n.id,endpointReadinessOwner:n.endpointReadinessOwner,buildEnvironment:w,buildRuntimeEnvironment:n.capabilities.databaseRuntime==="required"?p:S,resolveConfiguration:n.engineId==="k6"?y:n.engineId==="playwright"?I:U,resolveSupportModules:n.engineId==="node-vitest"?C:n.engineId==="playwright"?b:_})));export const BUILT_IN_ENGINE_ORCHESTRATION=Object.freeze({integrations:o,resolve(n){const e=o.find(r=>r.profileId===n.id&&r.engineId===n.engineId);if(!e)throw new Error(`No engine orchestration integration for ${n.engineId}/${n.id}`);return e}});function p(n){const e=n.database?.url;if(!e)throw new Error(`Service "${n.targetConfig.name}" requires a database for k6-dal suites`);return{DATABASE_URL:e}}function C(n){const e=c(n.targetConfig.productDir),r=T(n.targetConfig.productDir,E);return{...e===null?{}:{testkitConfig:e},...r===null?{}:{tsconfig:r}}}function b(n){const e=m(g(n.targetConfig.productDir,n.targetConfig.testkit.local?.cwd));return s(e===null?{}:{playwrightConfig:e})}function S(n){return n.baseUrl===null?{}:{BASE_URL:n.baseUrl}}function w(n){const e=s(d(n.targetConfig,n.lease,h(n),null,{includeTestkitControls:!1,inheritProcessEnv:!1}));return O(e,n.targetConfig.name)}function O(n,e){const r=`TESTKIT_${e.toUpperCase().replace(/[^A-Z0-9]+/g,"_")}_SCHEMA_SOURCE_DATABASE_URL`,t=new Set(["TESTKIT_SCHEMA_SOURCE_DATABASE_URL",r]);return Object.fromEntries(Object.entries(n).filter(([i])=>!t.has(i.toUpperCase())))}function h(n){return Object.fromEntries(Object.entries(n.runtimeEnvironment).filter(([e])=>e.toUpperCase()!=="BASE_URL"))}function y(n){return n.targetConfig.engineConfigurations?.k6}function I(n){if(n.baseUrl===null)throw new Error(`Service "${n.targetConfig.name}" requires local.baseUrl for Playwright suites`);return R(l(n.targetConfig,n.baseUrl,n.lease),`Playwright configuration for ${n.task.file}`)}function R(n,e){try{const r=JSON.stringify(n);if(typeof r!="string")throw new TypeError(`${e} must be JSON-serializable`);const t=JSON.parse(r);if(t===null||Array.isArray(t)||typeof t!="object")throw new TypeError(`${e} must contain a JSON object`);return t}catch(r){throw new TypeError(`${e} must be a JSON object`,{cause:r})}}function U(){}function _(){return{}}function T(n,e){for(const r of e){const t=f.join(n,r);try{if(u.statSync(t).isFile())return t}catch(i){if(v(i,"ENOENT"))continue;throw new Error(`Could not inspect optional support module ${t}`,{cause:i})}}return null}function s(n){return Object.fromEntries(Object.entries(n).filter(e=>typeof e[1]=="string"))}function v(n,e){return typeof n=="object"&&n!==null&&Reflect.get(n,"code")===e}

package/dist/app/run/failure-details.d.ts

@@ -0,0 +1,36 @@
+import type { ReportingFailureDetail } from "../../evidence/index.js";
+export interface FailureDetailJsonRecord {
+    [key: string]: FailureDetailJsonValue;
+}
+export type FailureDetailJsonValue = boolean | FailureDetailJsonRecord | FailureDetailJsonValue[] | null | number | string;
+export interface NormalizedFailureDetail extends ReportingFailureDetail {
+    actual?: FailureDetailJsonValue;
+    checkName?: string;
+    classification?: string;
+    count: number;
+    expected?: FailureDetailJsonValue;
+    groupPath?: string[];
+    key: string;
+    kind: string;
+    location?: FailureDetailJsonRecord;
+    message?: string;
+    phase?: string;
+    request?: FailureDetailJsonRecord;
+    response?: FailureDetailJsonRecord;
+    stack?: string;
+    suitePath?: string[];
+    title: string;
+    traceId?: string;
+}
+export type TaskFailureDetail = NormalizedFailureDetail;
+export interface NormalizedCheckDetail {
+    fails: number;
+    name: string;
+    passed: boolean;
+    passes: number;
+    path: string[];
+}
+export declare function normalizeFailureDetail(detail: unknown): NormalizedFailureDetail | null;
+export declare function mergeFailureDetails(details: readonly NormalizedFailureDetail[]): NormalizedFailureDetail[];
+export declare function collectFailureDetailsFromRuntimeArtifacts(artifacts: unknown): NormalizedFailureDetail[];
+export declare function collectCheckDetailsFromRuntimeArtifacts(artifacts: unknown): NormalizedCheckDetail[];

package/dist/app/run/failure-details.js

@@ -0,0 +1 @@
+export function normalizeFailureDetail(e){const t=a(e);if(!t)return null;const n=s(t.kind),r=typeof t.key=="string"&&t.key.trim().length>0?t.key:null,o=s(t.title);if(!n||!r||!o)return null;const i={kind:n,key:r,title:o,count:V(t.count)??1},c=s(t.classification);c&&(i.classification=c);const u=Array.isArray(t.groupPath)?t.groupPath.filter(F=>typeof F=="string"):[];u.length>0&&(i.groupPath=u);const f=s(t.checkName);f&&(i.checkName=f);const l=x(t.suitePath);l.length>0&&(i.suitePath=l);const m=s(t.phase);m&&(i.phase=m);const h=s(t.message);h&&(i.message=h),t.expected!==void 0&&(i.expected=d(t.expected)),t.actual!==void 0&&(i.actual=d(t.actual));const g=s(t.traceId);g&&(i.traceId=g);const k=p(t.request);k&&(i.request=k);const A=p(t.response);A&&(i.response=A);const z=p(t.location);z&&(i.location=z);const N=s(t.stack);return N&&(i.stack=N),i}export function mergeFailureDetails(e){const t=new Map;for(const n of e){const r=`${n.kind}::${n.key}`,o=t.get(r);if(!o){t.set(r,{...n});continue}o.count+=n.count,!o.message&&n.message&&(o.message=n.message)}return[...t.values()].sort((n,r)=>n.kind.localeCompare(r.kind)||n.key.localeCompare(r.key))}export function collectFailureDetailsFromRuntimeArtifacts(e){const t=[];for(const n of Array.isArray(e)?e:[]){const r=a(n);if(!r||r.kind!=="testkit.failure-details")continue;const o=a(r.data);if(!o)continue;const i=s(o.phase);for(const c of Array.isArray(o.failures)?o.failures:[]){const u=a(c);if(!u)continue;const f=normalizeFailureDetail({...u,phase:u.phase||i||null});f&&t.push(f)}}return mergeFailureDetails(t)}export function collectCheckDetailsFromRuntimeArtifacts(e){const t=[];for(const n of Array.isArray(e)?e:[]){const r=a(n);if(!r||r.kind!=="testkit.checks")continue;const o=a(r.data);if(o)for(const i of Array.isArray(o.checks)?o.checks:[]){const c=a(i);if(!c)continue;const u=s(c.name)??"unnamed",f=b(c.passes),l=b(c.fails);t.push({name:u,path:x(c.path),passes:f,fails:l,passed:f>0&&l===0})}}return t}function a(e){return S(e)?e:null}function S(e){return e!==null&&typeof e=="object"&&!Array.isArray(e)}function x(e){if(!Array.isArray(e))return[];const t=[];for(const n of e){const r=s(n);r&&t.push(r)}return t}function s(e){if(typeof e!="string")return null;const t=e.trim();return t.length>0?t:null}function V(e){return typeof e!="number"||!Number.isInteger(e)||e<=0?null:e}function b(e){try{return Math.max(0,Number(e)||0)}catch{return 0}}function p(e){if(!a(e))return null;const t=d(e);return P(t)?t:null}function d(e){try{const t=JSON.stringify(e);if(typeof t!="string")return String(e);const n=JSON.parse(t);return y(n)?n:String(e)}catch{return String(e)}}function y(e){return e===null||typeof e=="boolean"||typeof e=="number"||typeof e=="string"?!0:Array.isArray(e)?e.every(y):P(e)}function P(e){const t=a(e);return t!==null&&Object.values(t).every(y)}

package/dist/app/run/live-run.d.ts

@@ -0,0 +1,27 @@
+import { type ServiceTracker } from "./results.js";
+import { type BuildLiveRunArtifactOptions, type ReportingRecord } from "../../evidence/index.js";
+import type { RunLogRegistry } from "../../evidence/logs.js";
+import type { OperationTimingRegistry } from "../../evidence/operation-timings.js";
+import type { SetupOperationRegistry } from "../../evidence/setup-progress.js";
+interface LiveRunServiceConfig {
+    name: string;
+}
+type LiveRunWorkerState = Pick<BuildLiveRunArtifactOptions, "runtimeInstanceCount" | "runtimeStats" | "workerCount">;
+interface LiveRunSelection extends Pick<BuildLiveRunArtifactOptions, "fileNames" | "serviceFilter" | "suiteSelectors" | "typeValues"> {
+    planning?: null | ReportingRecord;
+}
+interface LiveRunReporter {
+    warning?(message: string): unknown;
+}
+export interface CreateLiveSnapshotWriterOptions extends Pick<BuildLiveRunArtifactOptions, "archiveConfig" | "declaredEnvironmentKeys" | "execution" | "metadata" | "productDir" | "runId" | "startedAt"> {
+    configs: readonly LiveRunServiceConfig[];
+    logRegistry: Pick<RunLogRegistry, "listServiceLogs" | "listSetupLogs">;
+    operationTimingRegistry?: null | OperationTimingRegistry;
+    reporter?: LiveRunReporter | null;
+    selection: LiveRunSelection;
+    setupRegistry: Pick<SetupOperationRegistry, "listOperations">;
+    trackers: ReadonlyMap<string, ServiceTracker>;
+    workerState: LiveRunWorkerState;
+}
+export declare function createLiveSnapshotWriter({ productDir, runId, configs, trackers, startedAt, execution, workerState, selection, archiveConfig, declaredEnvironmentKeys, metadata, logRegistry, setupRegistry, operationTimingRegistry, reporter, }: CreateLiveSnapshotWriterOptions): () => void;
+export {};

package/dist/app/run/live-run.js

@@ -0,0 +1 @@
+import{finalizeServiceResult as S,summarizeDbBackend as w}from"./results.js";import{buildLiveRunArtifact as b}from"../../evidence/reporting.js";import{writeLiveRunArtifact as C}from"../../evidence/index.js";export function createLiveSnapshotWriter({productDir:e,runId:s,configs:o,trackers:l,startedAt:r,execution:p,workerState:n,selection:t,archiveConfig:m=null,declaredEnvironmentKeys:c=[],metadata:f,logRegistry:a,setupRegistry:g,operationTimingRegistry:v=null,reporter:y=null}){return()=>{const u=Date.now(),L=o.map(i=>S(l.get(i.name),r,u));try{C(e,b({productDir:e,runId:s,results:L,startedAt:r,updatedAt:u,execution:p,workerCount:n.workerCount,runtimeInstanceCount:n.runtimeInstanceCount,runtimeStats:n.runtimeStats,typeValues:t.typeValues,suiteSelectors:t.suiteSelectors,fileNames:t.fileNames,serviceFilter:t.serviceFilter,planning:t.planning||null,archiveConfig:m,declaredEnvironmentKeys:c,metadata:f,summarizeDbBackend:w,serviceLogs:a.listServiceLogs(),setupLogs:a.listSetupLogs(),setupOperations:g.listOperations(),operationTimings:v?.listOperations()||[]}))}catch(i){y?.warning?.(`Live run artifact update skipped: ${O(d(i))}`)}}}function d(e){return(typeof e=="object"&&e!==null||typeof e=="function")&&Reflect.get(e,"message")||e}function O(e){if(typeof e=="symbol")throw new TypeError("Cannot convert a Symbol value to a string");return String(e)}

package/dist/app/run/operation-progress.d.ts

@@ -0,0 +1,13 @@
+import type { ReportingOperationTimingInput } from "../../evidence/index.js";
+export interface OperationProgressInput extends ReportingOperationTimingInput {
+    id: string;
+    status: string;
+}
+export interface OperationProgressReporter {
+    operationFinished?(operation: OperationProgressInput): void;
+    operationProgress?(operation: OperationProgressInput): void;
+    operationStarted?(operation: OperationProgressInput): void;
+}
+export type OperationReporterBridge = (operations?: readonly OperationProgressInput[]) => void;
+export declare function createOperationReporterBridge(reporter?: OperationProgressReporter | null): OperationReporterBridge;
+export declare function operationProgressSignature(operation?: ReportingOperationTimingInput): string | undefined;

package/dist/app/run/operation-progress.js

@@ -0,0 +1 @@
+export function createOperationReporterBridge(t=null){const n=new Map;return function(a=[]){if(t)for(const s of a){const e=n.get(s.id)||null,i=operationProgressSignature(s);if(!e){n.set(s.id,{status:s.status,signature:i}),s.status==="running"?t.operationStarted?.(s):t.operationFinished?.(s);continue}e.signature!==i&&s.status==="running"&&t.operationProgress?.(s),e.status==="running"&&s.status!=="running"&&t.operationFinished?.(s),n.set(s.id,{status:s.status,signature:i})}}}export function operationProgressSignature(t={}){const n=JSON.stringify({status:t.status||"",summary:t.summary||"",message:t.message||"",error:t.error||"",metadata:t.metadata||{},logRefs:t.logRefs||[]});return typeof n=="string"?n:void 0}

package/dist/app/run/orchestrator.d.ts

@@ -0,0 +1,68 @@
+import { type CollectedSuite, type CollectSuitesOptions, type PlanningServicePlan } from "./planning.js";
+import { type FinalizedServiceResult } from "./results.js";
+import { type RunEventListener } from "./run-events.js";
+import type { NormalizedServiceConfig, NormalizedSuiteConfig } from "../../config/loader/index.js";
+import { type RuntimeManagerRuntimeOptions } from "../../environment/run-environment.js";
+import { type WorkerReporter, type WorkerResult } from "./worker-loop.js";
+import { type CreateLiveSnapshotWriterOptions } from "./live-run.js";
+import { type FinalizedRunArtifacts, type FinalizeRunArtifactsOptions } from "./run-finalization.js";
+import { type OperationProgressReporter } from "./operation-progress.js";
+import { type SerializedError } from "../../kernel/error-serialization.js";
+import type { NormalizedExecutionConfig } from "../../config/loader/execution-model.js";
+import type { SuiteSelector } from "../../domain/suite-selection.js";
+type NormalizedServicePlanBase = Omit<PlanningServicePlan<NormalizedServiceConfig>, "runtimeKey" | "skipped" | "suites"> & {
+    execution: NormalizedExecutionConfig;
+};
+export interface ExecutableServicePlan extends NormalizedServicePlanBase {
+    runtimeKey: string;
+    skipped: false;
+    suites: readonly CollectedSuite<NormalizedSuiteConfig>[];
+}
+export interface SkippedServicePlan extends NormalizedServicePlanBase {
+    runtimeConfigs: readonly [];
+    runtimeKey: null;
+    runtimeNames: readonly [];
+    skipped: true;
+    suites: readonly [];
+}
+export type ServicePlan = ExecutableServicePlan | SkippedServicePlan;
+export interface PlannedSkip {
+    engineId: CollectedSuite["engineId"];
+    file: string;
+    profileId: CollectedSuite["profileId"];
+    reason: string;
+    serviceName: string;
+    testType: CollectedSuite["testType"];
+}
+interface OrchestratorReporter {
+    plannedSkip?(entry: Readonly<PlannedSkip>): void;
+    serviceSkipped?(config: Readonly<NormalizedServiceConfig>, reason: string): void;
+    setServicePlans?(plans: readonly ServicePlan[]): void;
+    setTotalFileCount?(count: number): void;
+}
+type RuntimeManagerReporter = NonNullable<RuntimeManagerRuntimeOptions["reporter"]>;
+type LiveRunReporter = NonNullable<CreateLiveSnapshotWriterOptions["reporter"]>;
+type RunFinalizationReporter = NonNullable<FinalizeRunArtifactsOptions<FinalizedServiceResult>["reporter"]>;
+export type RunReporter = OrchestratorReporter & OperationProgressReporter & RuntimeManagerReporter & WorkerReporter & LiveRunReporter & RunFinalizationReporter;
+export interface RunOptions extends CollectSuitesOptions {
+    serviceFilter?: null | string;
+    allowEmpty?: boolean;
+    debug?: boolean;
+    fileNames?: readonly string[];
+    fileTimeoutSeconds?: null | number;
+    onEvent?: null | RunEventListener;
+    skipSchemaSourceVerify?: boolean;
+    taskConcurrency?: null | number;
+}
+export interface RunResult {
+    exitCode: number;
+    failure?: SerializedError;
+    results: FinalizedServiceResult[];
+    runArtifact: FinalizedRunArtifacts["runArtifact"];
+}
+export declare function runAll(configs: readonly NormalizedServiceConfig[], typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], opts: Readonly<RunOptions>, allConfigs?: readonly NormalizedServiceConfig[]): Promise<RunResult>;
+export declare function workerResultErrorsForOrchestrator(result: PromiseSettledResult<WorkerResult>): string[];
+export declare function resolveRunGateFailure(results: readonly FinalizedServiceResult[], allowEmpty?: boolean): null | string;
+export declare function resolveRunExecutionConfig(config: NormalizedServiceConfig | undefined, opts: Readonly<Pick<RunOptions, "fileTimeoutSeconds" | "taskConcurrency">>): NormalizedExecutionConfig;
+export declare function collectServicePlans(configs: readonly NormalizedServiceConfig[], configMap: ReadonlyMap<string, NormalizedServiceConfig>, typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], opts: Readonly<RunOptions>, execution: Readonly<NormalizedExecutionConfig>, reporter?: null | RunReporter): ServicePlan[];
+export {};

package/dist/app/run/orchestrator.js

@@ -0,0 +1 @@
+import{resolveRuntimeConfigs as re}from"../../config/loader/dependencies.js";import{buildRuntimeGraphs as ne,claimNextTask as ie,collectSuites as ae}from"./planning.js";import{buildRunPlanningMetadata as se,buildScheduledQueue as oe}from"./scheduler/index.js";import{addTrackerError as B,buildServiceTrackers as ue,finalizeServiceResult as _,recordGraphError as le,recordTaskOutcome as ce,summarizeDbBackend as me}from"./results.js";import{loadTimings as fe,saveTimings as de,writeRunArtifact as pe}from"../../evidence/index.js";import{createRunLogRegistry as ge}from"../../evidence/logs.js";import{createOperationTimingRegistry as ke,timeOperation as L}from"../../evidence/operation-timings.js";import{createRunReporterFromListener as he}from"./run-events.js";import{createSetupOperationRegistry as Se}from"../../evidence/setup-progress.js";import{createLocalRunEnvironment as ve}from"../../environment/run-environment.js";import{readPackageMetadata as Re,safeHostname as ye,safeUsername as Ce}from"../../process/host/metadata.js";import{collectGitMetadata as we}from"../../repo/metadata.js";import{resolveExecutionConfig as Fe}from"../../config/loader/decode-execution.js";import"../../environment/run-environment.js";import{createEngineManager as Ae}from"../../engines/factory.js";import{createWorker as xe,runWorker as Ie}from"./worker-loop.js";import{ensureRequestedFilesMatch as Ee}from"./run-guards.js";import{createLiveSnapshotWriter as Te}from"./live-run.js";import{finalizeRunArtifacts as be}from"./run-finalization.js";import{buildRunArtifact as ze}from"../../evidence/reporting.js";import{createOperationReporterBridge as Me}from"./operation-progress.js";import{formatError as $,serializeError as J}from"../../kernel/error-serialization.js";export async function runAll(e,l,k,t,g=e){const a=e[0]?.productDir||process.cwd(),C=ve(a),m=Ae(a),x=new Map(g.map(n=>[n.name,n])),f=Date.now(),b=e[0]?.artifacts??null,d=[...new Set(e.flatMap(n=>Object.keys(n.testkit.serviceEnv)))].sort(),z={git:await we(a),host:{hostname:ye(),username:Ce()},testkitVersion:Re().version},h=t.onEvent?he(t.onEvent,{debug:t.debug}):null,w=ge(a),S={workerCount:0,runtimeInstanceCount:0,runtimeStats:[]},Q=t.fileNames||[];Ee(e,l,k,Q);const q=resolveRunExecutionConfig(e[0],t),N=collectServicePlans(e,x,l,k,t,q,h);h?.setServicePlans?.(N);const F=ue(N,f),Y=k.map(n=>({...n})),D={typeValues:l,suiteSelectors:Y,fileNames:Q,serviceFilter:t.serviceFilter||null,planning:null};let p=()=>{};const Z=Me(h),A=ke({onChange:n=>{Z(n),p()}}),P=Se({logRegistry:w,onChange:()=>{p()}}),O=N.filter(n=>!n.skipped);let o;const r=await C.start({keepAlive:!0,resetResultsBeforePublish:!0});p=Te({productDir:a,runId:r.runId,configs:e,trackers:F,startedAt:f,execution:q,workerState:S,selection:D,archiveConfig:b,declaredEnvironmentKeys:d,metadata:z,logRegistry:w,setupRegistry:P,operationTimingRegistry:A,reporter:h});const M={artifacts:null},ee=async(n,c)=>(r.beginFinalization(),await r.finish(n,u=>{const i=c(u);return M.artifacts={runArtifact:i.runArtifact},i},"normal"));let v,I;const U=(n,c,s)=>({productDir:a,runId:r.runId,results:n,startedAt:f,finishedAt:c,execution:q,workerCount:S.workerCount,runtimeInstanceCount:S.runtimeInstanceCount,runtimeStats:S.runtimeStats,selection:D,archiveConfig:b,declaredEnvironmentKeys:d,metadata:z,logRegistry:w,setupRegistry:P,operationTimingRegistry:A,reporter:h,runInterruptReason:r.getInterruptReason(),runStatus:s,publishRunFinalization:ee});p();let R=null;try{try{if(O.length>0){const s=fe(a),{graphs:u,queue:i}=await L(A,{name:"testkit.plan",kind:"planning",summary:"plan test execution",scope:{serviceCount:O.length}},()=>{const E=ne(O),y=oe(O,E,{timings:s});return{graphs:E,queue:y}});D.planning=se(i,u),p(),h?.setTotalFileCount?.(i.length),S.workerCount=Math.max(1,Math.min(q.taskConcurrency,i.length)),S.runtimeInstanceCount=u.reduce((E,y)=>E+y.instanceCount,0);const V=Array.from({length:S.workerCount},(E,y)=>xe(y+1,a));r.provision(u,{reporter:h,logRegistry:w,setupRegistry:P,operationTimingRegistry:A,skipSchemaSourceVerify:t.skipSchemaSourceVerify});const H=[];try{const y=(await L(A,{name:"testkit.execute",kind:"execution",summary:"execute local worker queue",scope:{workerCount:V.length,taskCount:i.length}},async()=>Promise.allSettled(V.map(j=>Ie(j,i,r,m,F,H,ie,(T,G,K,W)=>{ce(T,G,K,W),p()},(T,G,K,W,te)=>{le(T,G,K,W,te),p()},h))))).flatMap(workerResultErrorsForOrchestrator);for(const j of y)for(const T of F.values())T.skipped||B(T,j);y.length>0&&p(),S.runtimeStats=r.getStats(),p()}finally{await L(A,{name:"testkit.cleanup",kind:"cleanup",summary:"stop managed runtimes and services"},()=>r.cleanupAll())}de(a,s,H)}}catch(s){R=J(s);const u=R.message||$(s);for(const i of F.values())i.skipped||B(i,u);p()}o=R===null?0:r.isStopRequested()?130:1,I=Date.now(),v=e.map(s=>_(F.get(s.name),f,I));const n=resolveRunGateFailure(v,t.allowEmpty===!0);await L(A,{name:"testkit.collect",kind:"collection",summary:"close and collect run logs"},()=>w.closeAll());const c=await be(U(v,I,r.isStopRequested()?"interrupted":R===null&&n===null?null:"failed"));return R!==null&&(o=1),v.some(s=>s.failed||s.infraFailed)&&(o=1),n!==null&&(o=1),c.shouldFailArchivePublication&&(o=1),c.shouldFailArchiveCleanup&&(o=1),(c.runArtifact.run.status==="interrupted"||r.isStopRequested()||r.committedFinalization?.artifactStatus==="interrupted")&&(o=Math.max(o,130)),{runArtifact:c.runArtifact,results:v,exitCode:o,...R===null?{}:{failure:R}}}catch(n){const c=J(n),s=c.message||$(n);for(const i of F.values())i.skipped||B(i,s);p(),r.beginFinalization(),o=r.isStopRequested()||r.committedFinalization?.artifactStatus==="interrupted"?130:1,I=Date.now(),v=e.map(i=>_(F.get(i.name),f,I)),await X(w);let u=M.artifacts;if(u===null)try{u=await qe(U(v,I,r.isStopRequested()?"interrupted":"failed"),r,M,c)}catch{if(M.artifacts===null)throw n;u=M.artifacts}return(u.runArtifact.run.status==="interrupted"||r.isStopRequested()||r.committedFinalization?.artifactStatus==="interrupted")&&(o=Math.max(o,130)),{runArtifact:u.runArtifact,results:v,exitCode:o,failure:R??c}}finally{r.dispose(),await X(w)}}async function qe(e,l,k,t){return l.finish("failed",g=>{const a=g.artifactStatus==="interrupted"?g:{artifactStatus:"failed",interruptReason:null},C=e.declaredEnvironmentKeys??[],m=ze({productDir:e.productDir,runId:e.runId,results:e.results,startedAt:e.startedAt,finishedAt:e.finishedAt,execution:e.execution,workerCount:e.workerCount,runtimeInstanceCount:e.runtimeInstanceCount,runtimeStats:e.runtimeStats,typeValues:e.selection.typeValues,suiteSelectors:e.selection.suiteSelectors,fileNames:e.selection.fileNames,serviceFilter:e.selection.serviceFilter,planning:e.selection.planning??null,archiveConfig:e.archiveConfig,declaredEnvironmentKeys:C,metadata:e.metadata,summarizeDbBackend:me,serviceLogs:e.logRegistry.listServiceLogs(),setupLogs:e.logRegistry.listSetupLogs(),setupOperations:e.setupRegistry.listOperations(),operationTimings:e.operationTimingRegistry?.listOperations()??[],runInterruptReason:a.interruptReason,runStatus:a.artifactStatus});m.finalizationFailure={...t};const f={runArtifact:pe(e.productDir,m,{archiveConfig:e.archiveConfig,declaredEnvironmentKeys:C})};return k.artifacts=f,f},"recovery")}async function X(e){try{await e.closeAll()}catch{}}export function workerResultErrorsForOrchestrator(e){return e.status==="rejected"?[$(e.reason)]:[...new Set(e.value.unpersistedErrors)]}export function resolveRunGateFailure(e,l=!1){return e.some(t=>t.failed)?"test failure":e.some(t=>t.infraFailed)?"test infrastructure failure":e.some(t=>t.notRunFileCount>0)?"one or more required test files did not run":e.some(t=>t.skippedFileCount>0)?"one or more selected test files were skipped":e.reduce((t,g)=>t+g.completedFileCount,0)===0&&!l?"no runnable test files executed":null}export function resolveRunExecutionConfig(e,l){return Fe({cli:{fileTimeoutSeconds:l.fileTimeoutSeconds,taskConcurrency:l.taskConcurrency},repo:e?{fileTimeoutSeconds:e.testkit.execution.fileTimeoutSeconds,taskConcurrency:e.testkit.execution.taskConcurrency}:void 0})}export function collectServicePlans(e,l,k,t,g,a,C=null){return e.map(m=>{const x=ae(m,k,t,g.fileNames||[],g);if(x.length===0)return C?.serviceSkipped?.(m,`no matching files (types=${k.join(",")||"all"} suites=${t.map(d=>d.raw).join(",")||"all"} files=${(g.fileNames||[]).join(",")||"all"})`),{config:m,execution:a,skipped:!0,suites:[],runtimeConfigs:[],runtimeNames:[],runtimeKey:null};for(const d of x)for(const z of d.skippedFiles)C?.plannedSkip?.({serviceName:m.name,testType:d.testType,engineId:d.engineId,profileId:d.profileId,file:z.path,reason:z.reason});const f=re(m,l),b=f.map(d=>d.name).sort();return{config:m,execution:a,skipped:!1,suites:x,runtimeConfigs:f,runtimeNames:b,runtimeKey:b.join("|")}})}

package/dist/app/run/planning-types.d.ts

@@ -0,0 +1,68 @@
+import type { SuiteSelector } from "../../domain/suite-selection.js";
+import type { EngineId, PublicTestType, RunnerProfileId } from "../../domain/identifiers.js";
+import type { DatabaseMaterializationInput } from "../../config/loader/index.js";
+import type { DatabaseBinding } from "../../config/loader/execution-model.js";
+export interface PlanningTask {
+    engineId: EngineId;
+    profileId: RunnerProfileId;
+    testType: PublicTestType;
+}
+export interface PlanningSuiteConfig {
+    engineId: EngineId;
+    files: readonly string[];
+    name: string;
+    profileId: RunnerProfileId;
+    testType: PublicTestType;
+    testkit?: {
+        weight?: null | number;
+    } | null;
+}
+export interface PlanningSkipSuiteRule {
+    reason: string;
+    selector: SuiteSelector;
+}
+export interface PlanningFileMetadata {
+    skipReason?: null | string;
+}
+export interface PlanningSkipConfig {
+    fileReasonByPath?: ReadonlyMap<string, string>;
+    suites?: readonly PlanningSkipSuiteRule[];
+}
+export interface PlanningServiceTestkitConfig {
+    database?: (DatabaseMaterializationInput & {
+        binding?: DatabaseBinding;
+    }) | null;
+    dependsOn?: readonly string[];
+    fileMetadataByPath?: ReadonlyMap<string, PlanningFileMetadata>;
+    runtime: {
+        instances: number;
+        maxConcurrentTasks: number;
+    };
+    skip?: PlanningSkipConfig | null;
+}
+export interface PlanningServiceConfig<Suite extends PlanningSuiteConfig = PlanningSuiteConfig> {
+    name: string;
+    suites: Readonly<Partial<Record<PublicTestType, readonly Suite[] | undefined>>>;
+    testkit: PlanningServiceTestkitConfig;
+}
+export type CollectedSuite<Suite extends PlanningSuiteConfig = PlanningSuiteConfig> = Omit<Suite, "files"> & {
+    files: readonly string[];
+    orderIndex: number;
+    skippedFiles: Array<{
+        path: string;
+        reason: string;
+    }>;
+    sortKey: string;
+    totalFileCount: number;
+    weight: number;
+};
+export interface PlanningServicePlan<Config extends PlanningServiceConfig = PlanningServiceConfig> {
+    assignedGraphKey?: string;
+    config: Config;
+    runtimeConfigs: readonly Config[];
+    runtimeKey: string;
+    runtimeNames: readonly string[];
+    skipped?: boolean;
+    suites?: readonly PlanningSuiteConfig[];
+}
+export type { RuntimeGraph } from "../../environment/planning-types.js";

package/dist/app/run/planning-types.js

@@ -0,0 +1 @@
+export{};

package/dist/app/run/planning.d.ts

@@ -0,0 +1,15 @@
+import type { RuntimeGraph } from "../../environment/planning-types.js";
+import type { PlanningTask, PlanningSuiteConfig, PlanningServiceConfig, CollectedSuite, PlanningServicePlan } from "./planning-types.js";
+import { type SuiteSelector } from "../../domain/suite-selection.js";
+import { type PublicTestType } from "../../domain/identifiers.js";
+export interface CollectSuitesOptions {
+    ignoreSkipRules?: boolean;
+}
+export declare function taskNeedsLocalRuntime(task: Readonly<PlanningTask>): boolean;
+export declare function collectSuites<Suite extends PlanningSuiteConfig>(config: PlanningServiceConfig<Suite>, typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], fileNames?: readonly string[], opts?: Readonly<CollectSuitesOptions>): CollectedSuite<Suite>[];
+export declare function orderedTypes(types: readonly string[]): PublicTestType[];
+export declare function claimNextTask<Task extends {
+    graphKey?: unknown;
+}>(queue: Task[], preferredGraphKey: unknown, isRunnable?: (task: Task) => boolean): Task | null;
+export type { PlanningTask, PlanningSuiteConfig, PlanningSkipSuiteRule, PlanningFileMetadata, PlanningSkipConfig, PlanningServiceTestkitConfig, PlanningServiceConfig, CollectedSuite, PlanningServicePlan, RuntimeGraph, } from "./planning-types.js";
+export declare function buildRuntimeGraphs<Config extends PlanningServiceConfig>(servicePlans: readonly PlanningServicePlan<Config>[]): RuntimeGraph<Config>[];

package/dist/app/run/planning.js

@@ -0,0 +1 @@
+import{runtimePlanning as x}from"../../environment/runtime-planning.js";import{matchesSelectedTypes as y,matchesSuiteSelectors as k}from"../../domain/suite-selection.js";import{isPublicTestType as w}from"../../domain/identifiers.js";import{resolveEngineProfile as R}from"../../engines/catalog.js";const S=["ui","e2e","int","contract","data","dal","load"];export function taskNeedsLocalRuntime(e){return g(e).capabilities.applicationRuntime==="required"}export function collectSuites(e,t,s,o=[],c={}){const n=new Set(o.map(h)),u=[];let d=0;for(const r of orderedTypes(Object.keys(e.suites)))for(const i of e.suites[r]||[]){if(i.testType!==r)throw new Error(`Suite ${e.name}/${r}:${i.name} declares conflicting test type ${i.testType}`);const p=g(i),l=n.size===0?i.files:i.files.filter(f=>n.has(h(f)));if(!y(r,t)||!k(r,i.name,s)||l.length===0)continue;const{files:a,skippedFiles:m}=P(e,r,i.name,l,c);u.push({...i,files:a,skippedFiles:m,orderIndex:d,sortKey:`${r}:${i.name}`,weight:i.testkit?.weight||(p.capabilities.taskBatching==="compatible"?Math.max(2,Math.max(1,a.length)):Math.max(1,a.length)),totalFileCount:l.length}),d+=1}return u}export function orderedTypes(e){const t=e.filter(o=>!w(o));if(t.length>0)throw new Error(`Unknown test types in suite collection: ${t.join(", ")}`);const s=[];for(const o of S)e.includes(o)&&s.push(o);return s}export function claimNextTask(e,t,s=()=>!0){if(e.length===0)return null;const o=[],c=[];for(let n=0;n<e.length;n+=1)t&&e[n].graphKey===t?o.push(n):c.push(n);for(const n of[...o,...c])if(s(e[n]))return e.splice(n,1)[0];return null}function P(e,t,s,o,c={}){if(c.ignoreSkipRules)return{files:o,skippedFiles:[]};const n=e.testkit.skip,u=e.testkit.fileMetadataByPath||null;if(!n&&!u)return{files:o,skippedFiles:[]};const r=(n?.suites||[]).filter(l=>k(t,s,[l.selector]))[0]?.reason||null,i=[],p=[];for(const l of o){const a=h(l),f=(e.testkit.fileMetadataByPath?.get(a)||null)?.skipReason||n?.fileReasonByPath?.get(a)||r;if(f){p.push({path:a,reason:f});continue}i.push(l)}return{files:i,skippedFiles:p}}function g(e){const t=R(e.testType,e.engineId);if(t.id!==e.profileId)throw new Error(`Execution identity ${e.testType}/${e.engineId}/${e.profileId} conflicts with catalog profile ${t.id}`);return t}function h(e){return String(e).split("\\").join("/")}export function buildRuntimeGraphs(e){const t=e.filter(s=>!s.skipped);for(const s of t)s.assignedGraphKey=s.runtimeKey;return x.buildRuntimeGraphs(t)}

package/dist/app/run/playwright-configuration.d.ts

@@ -0,0 +1,2 @@
+import { buildTemplateContext, type ExecutionEnvironmentConfig } from "../../steps/index.js";
+export declare function buildPlaywrightUiConfig(config: Readonly<ExecutionEnvironmentConfig>, baseUrl: string, lease: Readonly<Parameters<typeof buildTemplateContext>[1]>): unknown;

package/dist/app/run/playwright-configuration.js

@@ -0,0 +1 @@
+import{buildTemplateContext as l,finalizeSerializable as s}from"../../steps/index.js";export function buildPlaywrightUiConfig(t,e,n){const i=l(t,n),r=t.testkit.ui?s(t.testkit.ui,i):null,o=c(r)?{...r}:{};return a(e)&&(o.allowRemote=!0),o}function a(t){try{const e=new URL(t);return!u(e.hostname)}catch{return!1}}function u(t){const e=t.toLowerCase();return e==="localhost"||e==="::1"||e==="0.0.0.0"||e==="127.0.0.1"||e.endsWith(".localhost")||e.startsWith("127.")}function c(t){return t!==null&&typeof t=="object"&&!Array.isArray(t)}

package/dist/app/run/request.d.ts

@@ -0,0 +1,30 @@
+export interface RunRequestInput {
+    dir?: string;
+    service?: string;
+    taskConcurrency?: string;
+    workers?: string;
+    fileTimeoutSeconds?: string;
+    type?: readonly string[];
+    suite?: readonly string[];
+    file?: readonly string[];
+    allowEmpty: boolean;
+    ignoreSkipRules: boolean;
+    skipSchemaSourceVerify: boolean;
+}
+export declare function buildRunRequest(input: Readonly<RunRequestInput>, positionalType?: null | string, cwd?: string, invocationCwd?: string): Promise<{
+    allConfigs: import("../../config/loader/load.js").NormalizedServiceConfig[];
+    configs: import("../../config/loader/load.js").NormalizedServiceConfig[];
+    productDir: string;
+    typeValues: string[];
+    suiteSelectors: import("../../domain/suite-selection.js").SuiteSelector[];
+    runOptions: {
+        allowEmpty: boolean;
+        fileNames: string[];
+        taskConcurrency: number | null;
+        fileTimeoutSeconds: number | null;
+        serviceFilter: string | null;
+        ignoreSkipRules: boolean;
+        skipSchemaSourceVerify: boolean;
+    };
+}>;
+export type RunRequest = Awaited<ReturnType<typeof buildRunRequest>>;

package/dist/app/run/request.js

@@ -0,0 +1 @@
+import{loadManagedConfigs as u}from"../../config/loader/managed-configs.js";import{parseFileTimeoutOption as d}from"../../domain/file-timeout.js";import{parseSuiteOption as y,parseTypeOption as S}from"../../domain/suite-selection.js";import{resolveRequestedFiles as k}from"../file-selection.js";import{parseTaskConcurrencyOptions as w}from"../../config/loader/decode-execution.js";export async function buildRunRequest(e,s=null,i=process.cwd(),c=process.cwd()){const{allConfigs:o,configs:l}=await u({dir:e.dir,service:e.service}),t=w(e.taskConcurrency,e.workers),n=e.fileTimeoutSeconds==null?null:d(e.fileTimeoutSeconds),a=S(e.type,s),m=y(e.suite),f=e.file??[],r=o[0]?.productDir||i,p=k(f,r,c);return{allConfigs:o,configs:l,productDir:r,typeValues:a,suiteSelectors:m,runOptions:{allowEmpty:e.allowEmpty,fileNames:p,taskConcurrency:t,fileTimeoutSeconds:n,serviceFilter:e.service||null,ignoreSkipRules:e.ignoreSkipRules,skipSchemaSourceVerify:e.skipSchemaSourceVerify}}}