@gfdelarue/testkit 0.3.0

package/dist/app/run/scheduler/observations.d.ts

@@ -0,0 +1,20 @@
+import type { TestOutcomeStatus } from "../../../domain/test-outcomes.js";
+import type { TimingUpdate } from "../../../evidence/index.js";
+import type { ScheduledTask } from "./index.js";
+export type TimingObservationTask = Pick<ScheduledTask, "estimateConfidence" | "estimatedDurationMs" | "estimateSource" | "timingKey">;
+export interface TimingObservation extends TimingUpdate {
+    estimate: {
+        confidence: ScheduledTask["estimateConfidence"];
+        durationMs: number;
+        source: ScheduledTask["estimateSource"];
+    };
+    finishedAt: null | number;
+    startedAt: null | number;
+    status: TestOutcomeStatus;
+}
+export declare function buildTimingObservation(task: Readonly<TimingObservationTask>, outcome: Readonly<{
+    durationMs?: number;
+    finishedAt?: number;
+    startedAt?: number;
+    status: TestOutcomeStatus;
+}>): TimingObservation | null;

package/dist/app/run/scheduler/observations.js

@@ -0,0 +1 @@
+export function buildTimingObservation(n,t){const{status:i}=t;if(i==="skipped"||i==="not_run")return null;const e=t.durationMs??0;return e<=0?null:{key:n.timingKey,durationMs:e,status:i,startedAt:t.startedAt??null,finishedAt:t.finishedAt??null,estimate:{durationMs:n.estimatedDurationMs,source:n.estimateSource,confidence:n.estimateConfidence}}}

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

@@ -0,0 +1,10 @@
+import type { SuiteSelector } from "../../domain/suite-selection.js";
+export interface SelectionSuite {
+    files: readonly string[];
+}
+export interface SelectionSuiteCollectionOptions {
+    ignoreSkipRules: true;
+}
+export type SelectionSuiteCollector<Config> = (config: Config, typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], fileNames: readonly string[], options: SelectionSuiteCollectionOptions) => readonly SelectionSuite[];
+export declare function findUnmatchedRequestedFiles<Config>(configs: readonly Config[], typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], fileNames: readonly string[], collectSuites: SelectionSuiteCollector<Config>, normalizePathSeparators: (filePath: string) => string): string[];
+export declare function isFullRunSelection(typeValues: readonly string[], suiteSelectors: readonly unknown[], fileNames: readonly string[], serviceFilter: null | string): boolean;

package/dist/app/run/selection.js

@@ -0,0 +1 @@
+export function findUnmatchedRequestedFiles(e,n,t,o,s,l){const f=new Set;for(const i of e){const c=s(i,n,t,[],{ignoreSkipRules:!0});for(const u of c)for(const r of u.files)f.add(l(r))}return[...new Set(o.map(l))].filter(i=>!f.has(i))}export function isFullRunSelection(e,n,t,o){return e.length===1&&e[0]==="all"&&n.length===0&&t.length===0&&o===null}

package/dist/app/run/setup/runtime-node-setup-errors.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeNodeSetupCleanupOwner } from "./runtime-node-setup-protocol.js";
+export type RuntimeNodeSetupFailureKind = "cancelled" | "deadline" | "infra" | "product";
+export interface RuntimeNodeSetupCleanupFailure {
+    readonly error: Error;
+    readonly owner: RuntimeNodeSetupCleanupOwner;
+}
+export declare function createSetupFailure(kind: RuntimeNodeSetupFailureKind, message: string, cause?: unknown): Error;
+export declare function withSetupCleanupFailures(error: Error, cleanupFailures: readonly RuntimeNodeSetupCleanupFailure[]): Error;
+export declare function createSetupCleanupError(cleanupFailures: readonly RuntimeNodeSetupCleanupFailure[]): Error;
+export declare function createSetupCleanupTimeoutError(timeoutMs: number, owner: RuntimeNodeSetupCleanupOwner): Error;
+export declare function createUnacknowledgedSetupCleanupError(abortAcknowledged: boolean): Error;
+export declare function classifyRuntimeNodeSetupFailure(error: unknown): RuntimeNodeSetupFailureKind;
+export declare function getRuntimeNodeSetupCleanupFailures(error: unknown): readonly RuntimeNodeSetupCleanupFailure[];

package/dist/app/run/setup/runtime-node-setup-errors.js

@@ -0,0 +1 @@
+const u=new WeakMap,o=new WeakSet;export function createSetupFailure(n,e,t){const r=new Error(e,{cause:t});return u.set(r,{primary:r,kind:n,cleanupFailures:[]}),r}export function withSetupCleanupFailures(n,e){if(e.length===0)return n;const t=u.get(n),r=t?.primary??n,i=[...t?.cleanupFailures??[],...e],a=new AggregateError([r,...i.map(({error:c})=>c)],`${r.message}; runtime node setup cleanup also failed`,{cause:r});return u.set(a,{primary:r,kind:t?.kind??"product",cleanupFailures:i}),a}export function createSetupCleanupError(n){const e=new AggregateError(n.map(({error:t})=>t),"Runtime node setup cleanup failed");return u.set(e,{primary:e,kind:"product",cleanupFailures:[...n]}),e}export function createSetupCleanupTimeoutError(n,e){const t=createSetupFailure(e==="consumer"?"product":"infra",`Runtime node setup ${e} cleanup exceeded ${n.toString()} milliseconds`);return u.set(t,{primary:t,kind:e==="consumer"?"product":"infra",cleanupFailures:[{error:t,owner:e}]}),t}export function createUnacknowledgedSetupCleanupError(n){const e=createSetupFailure("infra",n?"Runtime node setup worker acknowledged abort but was forcibly terminated without acknowledging cleanup completion":"Runtime node setup worker was forcibly terminated without acknowledging abort or cleanup completion");return o.add(e),u.set(e,{primary:e,kind:"infra",cleanupFailures:[{error:e,owner:"testkit"}]}),e}export function classifyRuntimeNodeSetupFailure(n){const e=typeof n=="object"&&n!==null?u.get(n):void 0;if(!e)return"product";const{kind:t,cleanupFailures:r}=e;return r.length>0&&r.every(({error:i})=>o.has(i))&&(t==="cancelled"||t==="deadline")?t:r.some(({owner:i})=>i==="testkit")?"infra":t==="cancelled"&&r.length>0?"product":t}export function getRuntimeNodeSetupCleanupFailures(n){return(typeof n=="object"&&n!==null?u.get(n)?.cleanupFailures:void 0)??[]}

package/dist/app/run/setup/runtime-node-setup-protocol.d.ts

@@ -0,0 +1,85 @@
+import type { EngineJsonValue } from "../../../engines/api/index.js";
+import type { RuntimeNodeSetupFailureKind } from "./runtime-node-setup-errors.js";
+export declare const MAX_RUNTIME_NODE_SETUP_DATA_BYTES: number;
+export declare const MAX_RUNTIME_NODE_SETUP_SIDECARS = 16;
+export type RuntimeNodeSetupCleanupOwner = "consumer" | "testkit";
+export interface RuntimeNodeSetupSerializedError {
+    message: string;
+    name: string;
+    stack?: string;
+}
+export interface RuntimeNodeSetupSerializedCleanupFailure {
+    error: RuntimeNodeSetupSerializedError;
+    owner: RuntimeNodeSetupCleanupOwner;
+}
+export interface RuntimeNodeSetupCleanupFailureInput {
+    error: unknown;
+    owner: RuntimeNodeSetupCleanupOwner;
+}
+export interface RuntimeNodeSetupWorkerRequest {
+    deadlineMs: number;
+    leaseDir: null | string;
+    modulePath: string;
+    moduleRelativePath: string;
+    productDir: string;
+    runtimeEnv: Readonly<Record<string, string>>;
+    serviceName: string;
+    sessionId: string;
+    testFile: string;
+}
+export type RuntimeNodeSetupParentMessage = {
+    error: RuntimeNodeSetupSerializedError;
+    sessionId: string;
+    kind: RuntimeNodeSetupFailureKind;
+    type: "abort";
+} | {
+    sessionId: string;
+    type: "cleanup";
+};
+export type RuntimeNodeSetupWorkerMessage = {
+    sessionId: string;
+    type: "abort-acknowledged";
+} | {
+    cleanupFailures: readonly RuntimeNodeSetupSerializedCleanupFailure[];
+    sessionId: string;
+    type: "aborted";
+} | {
+    owners: readonly RuntimeNodeSetupCleanupOwner[];
+    sessionId: string;
+    type: "cleanup-started";
+} | {
+    owner: RuntimeNodeSetupCleanupOwner;
+    remainingCallbacks: number;
+    sessionId: string;
+    type: "cleanup-progress";
+} | {
+    cleanupFailures: readonly RuntimeNodeSetupSerializedCleanupFailure[];
+    sessionId: string;
+    type: "cleanup-complete";
+} | {
+    sessionId: string;
+    setupData: EngineJsonValue;
+    sidecars: readonly RuntimeNodeSetupWorkerSidecarHandle[];
+    type: "ready";
+} | {
+    cleanupFailures: readonly RuntimeNodeSetupSerializedCleanupFailure[];
+    error: RuntimeNodeSetupSerializedError;
+    sessionId: string;
+    kind: RuntimeNodeSetupFailureKind;
+    type: "setup-error";
+};
+export interface RuntimeNodeSetupWorkerSidecarHandle {
+    id: string;
+    requestsUrl: string;
+    resetUrl: string;
+    type: "http-capture";
+    url: string;
+}
+export declare function isRuntimeNodeSetupWorkerRequest(value: unknown): value is RuntimeNodeSetupWorkerRequest;
+export declare function isRuntimeNodeSetupParentMessage(value: unknown): value is RuntimeNodeSetupParentMessage;
+export declare function readRuntimeNodeSetupWorkerMessage(value: unknown): RuntimeNodeSetupWorkerMessage | null;
+export declare function serializeRuntimeNodeSetupError(error: unknown): RuntimeNodeSetupSerializedError;
+export declare function serializeRuntimeNodeSetupCleanupFailures(failures: readonly RuntimeNodeSetupCleanupFailureInput[]): readonly RuntimeNodeSetupSerializedCleanupFailure[];
+export declare function normalizeRuntimeNodeSetupData(input: unknown): EngineJsonValue;
+export declare function normalizeRuntimeNodeSetupSidecarId(value: unknown): string;
+export declare function normalizeRuntimeNodeSetupSidecarPath(value: unknown): string;

package/dist/app/run/setup/runtime-node-setup-protocol.js

@@ -0,0 +1 @@
+export const MAX_RUNTIME_NODE_SETUP_DATA_BYTES=1048576,MAX_RUNTIME_NODE_SETUP_SIDECARS=16;export function isRuntimeNodeSetupWorkerRequest(e){return u(e)&&typeof e.sessionId=="string"&&e.sessionId.length>0&&typeof e.modulePath=="string"}export function isRuntimeNodeSetupParentMessage(e){return k(e)&&(e.type==="cleanup"||e.type==="abort"&&u(e.error)&&N(e.kind))}export function readRuntimeNodeSetupWorkerMessage(e){if(!k(e))return null;switch(e.type){case"abort-acknowledged":break;case"cleanup-started":if(!Array.isArray(e.owners))return null;break;case"cleanup-progress":if(e.owner!=="consumer"&&e.owner!=="testkit"||!Number.isSafeInteger(e.remainingCallbacks))return null;break;case"ready":if(!("setupData"in e)||!Array.isArray(e.sidecars))return null;break;case"setup-error":if(!u(e.error)||!N(e.kind)||!Array.isArray(e.cleanupFailures))return null;break;case"aborted":case"cleanup-complete":if(!Array.isArray(e.cleanupFailures))return null;break;default:return null}return e}function N(e){return e==="cancelled"||e==="deadline"||e==="infra"||e==="product"}function u(e){return e!==null&&typeof e=="object"&&!Array.isArray(e)}function k(e){return u(e)&&typeof e.type=="string"&&typeof e.sessionId=="string"&&e.sessionId.length>0}export function serializeRuntimeNodeSetupError(e){const r=g(e,"message"),o=g(e,"name"),i=g(e,"stack");return{message:typeof r=="string"?r:e===null||typeof e!="object"&&typeof e!="function"?String(e):"Runtime node setup failed",name:typeof o=="string"&&o?o:"Error",...typeof i=="string"?{stack:i}:{}}}export function serializeRuntimeNodeSetupCleanupFailures(e){return e.map(({error:r,owner:o})=>({error:serializeRuntimeNodeSetupError(r),owner:o}))}function g(e,r){const o=new Set;try{for(;u(e)&&!o.has(e);){o.add(e);const i=Object.getOwnPropertyDescriptor(e,r);if(i)return"value"in i?i.value:void 0;e=Object.getPrototypeOf(e)}}catch{}}export function normalizeRuntimeNodeSetupData(e){const r={},o=new Set,i=[{value:e===void 0?{}:e,path:"$",target:r,key:"data"}];let b=0;const a=(p,t)=>{throw new TypeError(`Runtime node setup data at ${p} must be plain JSON: ${t}`)},y=(p,t)=>{b+=p,b>1048576&&a(t,"must encode to no more than 1048576 bytes")};for(;i.length;){const p=i.pop();if(!p)break;if("leave"in p){o.delete(p.leave);continue}const{value:t,path:s,target:h,key:S}=p;if(t===null||typeof t=="string"||typeof t=="boolean"||typeof t=="number"&&Number.isFinite(t)){y(Buffer.byteLength(JSON.stringify(t)),s),Object.defineProperty(h,S,{value:t,enumerable:!0,writable:!0,configurable:!0});continue}typeof t!="object"&&a(s,`unsupported ${typeof t} value`),o.has(t)&&a(s,"circular reference");const c=Array.isArray(t),A=Object.getPrototypeOf(t);!c&&A!==Object.prototype&&A!==null&&a(s,"expected a plain object");const l=Reflect.ownKeys(t).filter(n=>!c||n!=="length");c&&l.length!==t.length&&a(s,"sparse array or extra array properties");const E=c?[]:{};Object.defineProperty(h,S,{value:E,enumerable:!0,writable:!0,configurable:!0}),y(2+Math.max(0,l.length-1),s),o.add(t),i.push({leave:t});const m=[];for(const n of l){typeof n!="string"&&a(s,"symbol key");const f=c?`${s}[${n}]`:/^[A-Za-z_$][\w$]*$/u.test(n)?`${s}.${n}`:`${s}[${JSON.stringify(n)}]`;c&&(!/^(?:0|[1-9]\d*)$/u.test(n)||Number(n)>=t.length)&&a(f,"extra array property");const d=Object.getOwnPropertyDescriptor(t,n);(!d||!("value"in d)||!d.enumerable)&&a(f,"expected an enumerable data property"),c||y(Buffer.byteLength(JSON.stringify(n))+1,f),m.push({value:d.value,path:f,target:E,key:n})}for(let n=m.length-1;n>=0;n-=1)i.push(m[n])}return r.data}export function normalizeRuntimeNodeSetupSidecarId(e){const r=typeof e=="string"&&e.trim()?e.trim():"http-capture";if(!/^[A-Za-z0-9._-]+$/u.test(r))throw new TypeError("Runtime node setup sidecar id must contain only letters, numbers, dot, underscore, or hyphen");return r}export function normalizeRuntimeNodeSetupSidecarPath(e){const r=typeof e=="string"&&e.trim()?e.trim():"/capture";if(!r.startsWith("/")||r.startsWith("//")||/[\\?#]/u.test(r))throw new TypeError("Runtime node setup sidecar path must be an absolute URL path");return r}

package/dist/app/run/setup/runtime-node-setup-worker.d.ts

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

package/dist/app/run/setup/runtime-node-setup-worker.js

@@ -0,0 +1 @@
+import{classifyRuntimeNodeSetupFailure as X,createSetupFailure as w}from"./runtime-node-setup-errors.js";import Y from"node:http";import{pathToFileURL as G}from"node:url";import{parentPort as q,workerData as J}from"node:worker_threads";import{isRuntimeNodeSetupParentMessage as Q,isRuntimeNodeSetupWorkerRequest as W,MAX_RUNTIME_NODE_SETUP_SIDECARS as F,normalizeRuntimeNodeSetupData as K,normalizeRuntimeNodeSetupSidecarId as V,normalizeRuntimeNodeSetupSidecarPath as Z,serializeRuntimeNodeSetupError as $,serializeRuntimeNodeSetupCleanupFailures as ee}from"./runtime-node-setup-protocol.js";const te=1024*1024,ne=100,re=8*1024*1024,oe=8*1024*1024,se=1e3,ae=256,s=we(J),O=Te(),p=new AbortController,B=[],A=new Set,C=[];let E=null,D=0,u="starting",_=null;O.on("message",e=>{ue(e)}),L(),ie();async function ie(){try{const t=await import(`${G(s.modulePath).href}?testkit=${encodeURIComponent(s.sessionId)}`);I();const n=fe(t);if(!n)throw new TypeError(`Runtime node setup "${s.moduleRelativePath}" must export a setup function`);const r=await n(ce()),o=me(r);o&&B.push({callback:o,owner:"consumer"}),I();const c=K(ye(r));b(),u="ready",d({sessionId:s.sessionId,setupData:c,sidecars:C.map(f=>({...f})),type:"ready"})}catch(e){const t=X(e),n=await P();u="cleaned",b(),d({cleanupFailures:n,error:$(e),kind:t,sessionId:s.sessionId,type:"setup-error"})}}async function ue(e){if(!Q(e)||e.sessionId!==s.sessionId){await x(w("infra","Runtime node setup worker received an invalid parent message"));return}if(e.type==="abort"){if(p.abort(w(e.kind,e.error.message)),d({sessionId:s.sessionId,type:"abort-acknowledged"}),u==="ready"){u="cleaning";const n=await P();u="cleaned",b(),d({cleanupFailures:n,sessionId:s.sessionId,type:"aborted"})}return}if(u==="cleaned"){d({cleanupFailures:[],sessionId:s.sessionId,type:"cleanup-complete"});return}if(u!=="ready"){await x(w("infra",`Runtime node setup cleanup is invalid during phase "${u}"`));return}u="cleaning";const t=await P();u="cleaned",b(),d({cleanupFailures:t,sessionId:s.sessionId,type:"cleanup-complete"})}async function x(e){p.abort(e);const t=await P();u="cleaned",b(),d({cleanupFailures:t,error:$(e),kind:"infra",sessionId:s.sessionId,type:"setup-error"})}function ce(){return{deadlineMs:s.deadlineMs,env:{...s.runtimeEnv},leaseDir:s.leaseDir,productDir:s.productDir,serviceName:s.serviceName,sidecars:{httpCapture(e={}){if(I(),C.length+D>=F)return Promise.reject(new RangeError(`Runtime node setup may create at most ${F.toString()} sidecars`));D+=1;const t=de(e).then(n=>(B.push({callback:n.cleanup,owner:"testkit"}),C.push(n.handle),I(),n.handle)).finally(()=>{D-=1,A.delete(t)});return A.add(t),t}},signal:p.signal,testFile:s.testFile}}async function de(e){const t=[],n=new Set;let r=0;const o=V(e.id),c=Z(e.path),f=j(e.maxRequests,ne,se,"maxRequests"),m=j(e.maxBodyBytes,te,re,"maxBodyBytes"),T=Se(e.status,204),l="/__testkit__/requests",S="/__testkit__/requests",a=Y.createServer((i,R)=>{if(i.method==="GET"&&i.url===l){g(R,200,{requests:t});return}if(i.method==="DELETE"&&i.url===S){t.splice(0),r=0,g(R,200,{ok:!0});return}pe(i,m).then(h=>{const U={bodyBytes:h.bodyBytes,bodyText:h.retainedBody.toString("utf8"),bodyTruncated:h.bodyBytes>h.retainedBody.length,headers:i.headers,method:i.method??null,path:i.url??null,receivedAt:new Date().toISOString()};for(r+=Buffer.byteLength(U.bodyText),t.push(U);t.length>f||r>oe;){const M=t.shift();if(!M)break;r-=Buffer.byteLength(M.bodyText)}g(R,T,{ok:!0})}).catch(h=>{g(R,500,{error:be(h)})})});a.maxConnections=ae,a.requestTimeout=3e4,a.headersTimeout=3e4,a.keepAliveTimeout=1e3,a.on("connection",i=>{n.add(i),i.once("close",()=>n.delete(i))}),await le(a);const y=a.address();if(y===null||typeof y=="string")throw await H(a,n),new Error("Runtime node HTTP capture did not bind a TCP port");const k=`http://127.0.0.1:${y.port.toString()}`,z={id:o,requestsUrl:`${k}${l}`,resetUrl:`${k}${S}`,type:"http-capture",url:`${k}${c}`};return{cleanup:()=>H(a,n),handle:z}}function le(e){return new Promise((t,n)=>{const r=o=>{n(o)};e.once("error",r),e.listen(0,"127.0.0.1",()=>{e.off("error",r),t()})})}function H(e,t){if(!e.listening){for(const n of t)n.destroy();return Promise.resolve()}return new Promise((n,r)=>{e.close(o=>{o?r(o):n()}),e.closeIdleConnections(),e.closeAllConnections();for(const o of t)o.destroy()})}function pe(e,t){return new Promise((n,r)=>{const o=[];let c=0,f=0,m=!1;const T=l=>{m||(m=!0,r(Re(l)))};e.on("data",l=>{if(m)return;if(typeof l!="string"&&!(l instanceof Uint8Array)){T(new TypeError("HTTP capture received an unsupported body chunk"));return}const S=Buffer.from(l);c=Math.min(Number.MAX_SAFE_INTEGER,c+S.length);const a=t-f;if(a>0){const y=S.subarray(0,a);o.push(y),f+=y.length}}),e.once("aborted",()=>{T(new Error("HTTP request was aborted"))}),e.once("error",T),e.once("end",()=>{m||(m=!0,n({bodyBytes:c,retainedBody:Buffer.concat(o,f)}))})})}function g(e,t,n){e.destroyed||e.writableEnded||(e.writeHead(t,{"content-type":"application/json"}),e.end(JSON.stringify(n)))}function fe(e){if(!N(e))return null;const t=e.setup??e.default;return typeof t=="function"?t:null}function me(e){if(!N(e))return null;const t=v(e,"cleanup");return typeof t=="function"?t:null}function ye(e){return N(e)&&("data"in e||"cleanup"in e)?Object.hasOwn(e,"data")?v(e,"data"):{}:e??{}}function v(e,t){let n=e;for(;n!==null;){const r=Object.getOwnPropertyDescriptor(n,t);if(r){if(!("value"in r))throw new TypeError(`Runtime node setup data at $.${t} must be an enumerable data property`);return r.value}n=Object.getPrototypeOf(n)}}function P(){return E!==null||(E=(async()=>{await Promise.allSettled([...A]);const e=[],t=B.splice(0).reverse();d({owners:t.map(({owner:n})=>n),sessionId:s.sessionId,type:"cleanup-started"});for(const[n,{callback:r,owner:o}]of t.entries()){d({owner:o,remainingCallbacks:t.length-n,sessionId:s.sessionId,type:"cleanup-progress"});try{await r()}catch(c){e.push({error:c,owner:o})}}return ee(e)})()),E}function L(){const e=s.deadlineMs-Date.now();if(e<=0){p.abort(he());return}_=setTimeout(L,Math.min(e,2147483647))}function b(){_!==null&&clearTimeout(_),_=null}function he(){return w("deadline",`Runtime node setup exceeded its deadline ${s.deadlineMs.toString()}`)}function I(){if(p.signal.aborted)throw p.signal.reason instanceof Error?p.signal.reason:new Error(String(p.signal.reason))}function d(e){O.postMessage(e)}function we(e){if(!W(e))throw w("infra","Runtime node setup worker received invalid worker data");return e}function Te(){if(q===null)throw w("infra","Runtime node setup worker requires a parent port");return q}function j(e,t,n,r){if(e===void 0)return t;const o=Number(e);if(!Number.isInteger(o)||o<=0||o>n)throw new RangeError(`Runtime node HTTP capture ${r} must be an integer between 1 and ${n.toString()}`);return o}function Se(e,t){if(e===void 0)return t;const n=Number(e);return Number.isInteger(n)&&n>=100&&n<=599?n:t}function N(e){return e!==null&&typeof e=="object"&&!Array.isArray(e)}function be(e){return e instanceof Error?e.message:String(e)}function Re(e){return e instanceof Error?e:new Error(String(e))}

package/dist/app/run/setup/runtime-node-setup.d.ts

@@ -0,0 +1,48 @@
+export { classifyRuntimeNodeSetupFailure, getRuntimeNodeSetupCleanupFailures, type RuntimeNodeSetupCleanupFailure, type RuntimeNodeSetupFailureKind, } from "./runtime-node-setup-errors.js";
+import { type EngineRuntimeArtifactPayload } from "../../../engines/api/index.js";
+import { type RuntimeNodeSetupWorkerSidecarHandle } from "./runtime-node-setup-protocol.js";
+import type { ExecutionEnvironmentLease } from "../../../steps/index.js";
+export declare const MAX_RUNTIME_NODE_SETUP_CLEANUP_TIMEOUT_MS = 60000;
+export interface RuntimeNodeSetupTargetConfig {
+    name: string;
+    productDir: string;
+}
+export interface RuntimeNodeSetupTask {
+    file: string;
+}
+export interface RunRuntimeNodeSetupOptions {
+    cleanupTimeoutMs?: number;
+    deadlineMs: number;
+    lease?: ExecutionEnvironmentLease | null;
+    runtimeEnv?: Readonly<Record<string, string>>;
+    signal: AbortSignal;
+    targetConfig: RuntimeNodeSetupTargetConfig;
+    task: RuntimeNodeSetupTask;
+}
+export interface HttpCaptureSidecarOptions {
+    id?: string;
+    maxBodyBytes?: number;
+    maxRequests?: number;
+    path?: string;
+    status?: number;
+}
+export interface RuntimeNodeSetupSidecars {
+    httpCapture(options?: Readonly<HttpCaptureSidecarOptions>): Promise<RuntimeNodeSetupWorkerSidecarHandle>;
+}
+export interface RuntimeNodeSetupContext {
+    deadlineMs: number;
+    env: Record<string, string>;
+    leaseDir: string | null;
+    productDir: string;
+    serviceName: string;
+    sidecars: RuntimeNodeSetupSidecars;
+    signal: AbortSignal;
+    testFile: string;
+}
+export interface RuntimeNodeSetupResult {
+    artifacts: EngineRuntimeArtifactPayload[];
+    cleanup: () => Promise<void>;
+    setupData: unknown;
+}
+export declare function runRuntimeNodeSetup({ cleanupTimeoutMs, deadlineMs, targetConfig, task, signal, lease, runtimeEnv, }: Readonly<RunRuntimeNodeSetupOptions>): Promise<RuntimeNodeSetupResult>;
+export declare function findRuntimeNodeSetupFile(productDir: string, testFile: string): null | string;

package/dist/app/run/setup/runtime-node-setup.js

@@ -0,0 +1,3 @@
+import{classifyRuntimeNodeSetupFailure as R,createSetupFailure as o,createSetupCleanupError as D,createSetupCleanupTimeoutError as y,createUnacknowledgedSetupCleanupError as b,withSetupCleanupFailures as h}from"./runtime-node-setup-errors.js";export{classifyRuntimeNodeSetupFailure,getRuntimeNodeSetupCleanupFailures}from"./runtime-node-setup-errors.js";import _ from"node:fs";import{randomUUID as F}from"node:crypto";import a from"node:path";import{Worker as j}from"node:worker_threads";import{isEngineTaskDeadlineExceededReason as x}from"../../../engines/api/index.js";import{readRuntimeNodeSetupWorkerMessage as M,serializeRuntimeNodeSetupError as A}from"./runtime-node-setup-protocol.js";const E=100,N=5e3;export const MAX_RUNTIME_NODE_SETUP_CLEANUP_TIMEOUT_MS=6e4;class C{#o;#m;#i;#w;#c=$();#d;#a;#R=!1;#k=null;#r=null;#s=null;#u=0;#h=null;#f=null;#$=!1;#t="starting";#v=!1;#e=null;#g=null;constructor(e,t,r){this.#w=e,this.#d=t,this.#m=e.deadlineMs,this.#i=e.moduleRelativePath,this.#o=r,this.#a=new j(new URL("./runtime-node-setup-worker.js",import.meta.url),{name:"testkit-runtime-node-setup",workerData:e}),this.#a.on("message",s=>{this.#j(s).catch(n=>{this.#T(o("infra",`Runtime node setup worker for "${this.#i}" sent an invalid message`,n))})}),this.#a.once("error",s=>{this.#T(o("infra",`Runtime node setup worker failed for "${this.#i}"`,s))}),this.#a.once("exit",s=>{this.#$||this.#T(o("infra",`Runtime node setup worker for "${this.#i}" exited unexpectedly with code ${s.toString()}`))}),this.#d.addEventListener("abort",this.#S,{once:!0}),this.#_()}start(){return this.#d.aborted?this.#p(m(this.#d.reason,this.#i)):Date.now()>=this.#m&&this.#p(c(this.#m,this.#i)),this.#c.promise}cleanup=()=>{if(this.#r!==null)return this.#r.promise;const e=$();if(this.#r=e,this.#e!==null&&this.#t==="cleaning")return e.promise;if(this.#e!==null||this.#t==="terminated")return this.#L(),e.promise;if(this.#t!=="ready")return this.#E(o("infra",`Runtime node setup cleanup is invalid during phase "${this.#t}"`)),e.promise;this.#t="cleaning",this.#h=setTimeout(()=>{this.#E(this.#O())},this.#o);try{this.#a.postMessage({sessionId:this.#w.sessionId,type:"cleanup"})}catch(t){this.#E(o("infra",`Could not request runtime node setup cleanup for "${this.#i}"`,t))}return e.promise};#S=()=>{this.#p(m(this.#d.reason,this.#i))};async#j(e){const t=M(e);if(t===null||t.sessionId!==this.#w.sessionId){this.#n(`Runtime node setup worker for "${this.#i}" sent an invalid message`);return}switch(t.type){case"abort-acknowledged":this.#x();return;case"cleanup-started":this.#M(t.owners);return;case"cleanup-progress":this.#A(t.owner,t.remainingCallbacks);return;case"ready":this.#N(t);return;case"setup-error":await this.#C(t);return;case"cleanup-complete":await this.#I(t);return;case"aborted":await this.#P(t.cleanupFailures)}}#x(){if(this.#e===null||this.#t==="terminated"){this.#n(`Runtime node setup worker acknowledged an unexpected abort during phase "${this.#t}"`);return}if(this.#R){this.#n("Runtime node setup worker acknowledged abort more than once");return}this.#R=!0,this.#y(this.#s!==null?this.#o:E)}#M(e){if(this.#s!==null||this.#t!=="starting"&&this.#t!=="cleaning"){this.#n(this.#s!==null?"Runtime node setup worker started cleanup more than once":`Runtime node setup worker started cleanup during phase "${this.#t}"`);return}this.#s=[...e],this.#u=0,this.#e!==null&&this.#y(this.#o)}#A(e,t){const r=this.#s?.[this.#u],s=(this.#s?.length??0)-this.#u;if(this.#s===null||this.#t!=="starting"&&this.#t!=="cleaning"||r!==e||s!==t){this.#n(`Runtime node setup worker reported invalid cleanup progress during phase "${this.#t}"`);return}this.#u+=1}#N(e){if(this.#t!=="starting"||this.#e!==null||this.#s!==null){this.#e!==null?this.#p(this.#e):this.#n(this.#s!==null?"Runtime node setup worker became ready after starting cleanup":`Runtime node setup worker became ready during phase "${this.#t}"`);return}const t=e.setupData,r=e.sidecars.map(s=>({...s}));l(this.#f),this.#f=null,this.#t="ready",this.#c.resolve({artifacts:[{name:"node-setup",kind:"testkit.node-setup",summary:`node setup ${this.#i}`,contentType:"application/json",data:{module:this.#i,sidecars:r,setupData:t},emittedAt:new Date().toISOString()}],cleanup:this.cleanup,setupData:t})}async#C(e){if(this.#t!=="starting"){this.#n(`Runtime node setup worker reported setup failure during phase "${this.#t}"`);return}if(!this.#b()){this.#n("Runtime node setup worker reported setup failure before acknowledging cleanup completion");return}const t=p(e.cleanupFailures),r=P(e.error,e.kind,this.#i,t),s=this.#e===null?r:h(this.#e,t);this.#e=s,await this.#l(),this.#c.reject(this.#e)}async#I(e){if(this.#t!=="cleaning"||this.#r===null||!this.#b()){this.#n(`Runtime node setup worker reported cleanup during phase "${this.#t}"`);return}const t=p(e.cleanupFailures);l(this.#h),this.#h=null,t.length>0&&(this.#e=this.#e===null?D(t):h(this.#e,t)),await this.#l(),this.#e!==null?this.#r.reject(this.#e):this.#r.resolve(void 0)}async#P(e){if(!this.#b()){this.#n("Runtime node setup worker reported abort completion before acknowledging cleanup completion");return}const t=p(e),r=h(this.#e??o("infra",`Runtime node setup worker for "${this.#i}" aborted unexpectedly`),t);this.#e=r,await this.#l();const s=this.#e;this.#c.reject(s),this.#r?.reject(s)}#p(e,t=!1){if(this.#t==="terminated")return;if(t){if(this.#v)return;this.#v=!0}if(this.#e!==null){t&&(this.#e=h(this.#e,[{error:e,owner:"testkit"}]));return}const r=this.#t==="ready",s=r||this.#t==="cleaning"?this.#o:E;this.#e=e,r&&(this.#t="cleaning"),this.#F(),l(this.#h),this.#h=null;try{this.#a.postMessage({error:A(e),kind:R(e),sessionId:this.#w.sessionId,type:"abort"})}catch{this.#D();return}this.#y(s)}async#D(){const e=this.#e??o("infra",`Runtime node setup worker for "${this.#i}" was terminated`),t=this.#U();this.#e=h(e,[t]),await this.#l();const r=this.#e;this.#c.reject(r),this.#r?.reject(r)}#y(e){l(this.#k),this.#k=setTimeout(()=>{this.#D()},e)}#U(){if(this.#s!==null){const e=this.#s.at(Math.max(0,this.#u-1))??"testkit";return{error:y(this.#o,e),owner:e}}return{error:b(this.#R),owner:"testkit"}}#O(){return this.#s===null?b(!1):y(this.#o,this.#s.at(Math.max(0,this.#u-1))??"testkit")}#b(){return this.#s!==null&&this.#u===this.#s.length}#n(e){this.#p(o("infra",e),!0)}async#L(){await this.#l();const e=this.#e??o("infra",`Runtime node setup worker for "${this.#i}" is unavailable during cleanup`);this.#r?.reject(e)}async#E(e){this.#e??=e,await this.#l(),this.#r?.reject(this.#e)}#T(e){this.#e===null&&(this.#e=e),this.#l().then(()=>{this.#c.reject(this.#e),this.#r?.reject(this.#e)})}#_(){const e=this.#m-Date.now();if(e<=0){this.#p(c(this.#m,this.#i));return}this.#f=setTimeout(()=>{this.#_()},Math.min(e,2147483647))}#F(){l(this.#f),this.#f=null,this.#d.removeEventListener("abort",this.#S)}#l(){return this.#g!==null?this.#g:(this.#$=!0,this.#t="terminated",this.#F(),l(this.#k),l(this.#h),this.#k=null,this.#h=null,this.#g=this.#a.terminate().then(()=>{}).catch(e=>{const t=o("infra",`Failed to terminate runtime node setup worker for "${this.#i}"`,e);this.#e=this.#e===null?t:h(this.#e,[{error:t,owner:"testkit"}])}),this.#g)}}export async function runRuntimeNodeSetup({cleanupTimeoutMs:i,deadlineMs:e,targetConfig:t,task:r,signal:s,lease:n,runtimeEnv:w={}}){const d=Math.min(i??N,MAX_RUNTIME_NODE_SETUP_CLEANUP_TIMEOUT_MS),u=findRuntimeNodeSetupFile(t.productDir,r.file);if(s.aborted)throw m(s.reason,u?f(t.productDir,u):r.file);if(Date.now()>=e)throw c(e,u?f(t.productDir,u):r.file);if(!u)return I();const k=f(t.productDir,u),v={deadlineMs:e,leaseDir:n?.leaseDir??null,modulePath:u,moduleRelativePath:k,productDir:t.productDir,runtimeEnv:w,serviceName:t.name.trim(),sessionId:F(),testFile:r.file.trim()};let g;try{g=new C(v,s,d)}catch(S){throw o("infra",`Could not start runtime node setup worker for "${k}"`,S)}return g.start()}export function findRuntimeNodeSetupFile(i,e){const t=a.resolve(i),r=a.resolve(t,e),s=a.relative(t,r);if(s===".."||s.startsWith(`..${a.sep}`)||a.isAbsolute(s))throw new Error("Runtime node setup test file must be inside productDir");const n=a.parse(r);return[a.join(n.dir,`${n.name}.setup.mjs`),a.join(n.dir,`${n.name}.setup.js`),a.join(n.dir,"__setup__",`${n.name}.mjs`),a.join(n.dir,"__setup__",`${n.name}.js`)].find(d=>_.existsSync(d))??null}function I(){const i=Promise.resolve();return{artifacts:[],cleanup:()=>i,setupData:{}}}function P(i,e,t,r){const s=T(i),n=o(e,`Runtime node setup "${t}" failed: ${s.message}`,s);return s.stack&&(n.stack=`${n.stack??n.message}
+Remote stack:
+${s.stack}`),h(n,r)}function T(i){const e=new Error(i.message);return e.name=i.name,i.stack&&(e.stack=i.stack),e}function p(i){return i.map(e=>({error:T(e.error),owner:e.owner}))}function m(i,e){return R(i)==="deadline"&&i instanceof Error?i:x(i)?c(i.deadlineMs,e):o("cancelled","Runtime node setup was cancelled",i)}function c(i,e){return o("deadline",`Runtime node setup exceeded its deadline ${i.toString()}${e?` for "${e}"`:""}`)}function f(i,e){return a.relative(i,e).split(a.sep).join("/")}function $(){let i,e;return{promise:new Promise((r,s)=>{i=r,e=s}),resolve:i,reject:e}}function l(i){i!==null&&clearTimeout(i)}

package/dist/app/run/task-batches.d.ts

@@ -0,0 +1,23 @@
+import type { ScheduledTask } from "./scheduler/index.js";
+export declare const DEFAULT_COMPATIBLE_BATCH_MAX_FILES = 25;
+export type BatchableTask = Pick<ScheduledTask, "engineId" | "file" | "graphKey" | "id" | "locks" | "profileId" | "resourceCost" | "runtimeIsolation" | "serviceName" | "suiteKey" | "suiteName" | "targetName" | "testType">;
+export type TaskBatch<Task extends BatchableTask> = Task & {
+    batchFiles: string[];
+    batchId: string;
+    batchTasks: [Task, Task, ...Task[]];
+};
+export interface ClaimCompatibleTaskBatchOptions {
+    maxFiles?: number;
+}
+interface TaskOutcomeCollection<Outcome> {
+    outcomes: readonly Outcome[];
+}
+export declare function claimCompatibleTaskBatch<Task extends BatchableTask>(queue: Task[], anchorTask: Task, options?: Readonly<ClaimCompatibleTaskBatchOptions>): Task[];
+export declare function buildTaskBatch<Task extends BatchableTask>(tasks: readonly Task[]): Task | TaskBatch<Task> | null;
+export declare function expandTaskResultOutcomes<Outcome extends {
+    status: string;
+    outcomes?: never;
+}>(result: null | Outcome | TaskOutcomeCollection<Outcome> | undefined): Outcome[];
+export declare function isBatchableEngineTask(task: Readonly<BatchableTask>): boolean;
+export declare function isCompatibleEngineBatchTask(anchor: Readonly<BatchableTask>, candidate: Readonly<BatchableTask>): boolean;
+export {};

package/dist/app/run/task-batches.js

@@ -0,0 +1 @@
+import{resolveEngineProfile as p}from"../../engines/catalog.js";export const DEFAULT_COMPATIBLE_BATCH_MAX_FILES=25;export function claimCompatibleTaskBatch(e,t,o={}){const r=o.maxFiles??DEFAULT_COMPATIBLE_BATCH_MAX_FILES,i=[t];if(!isBatchableEngineTask(t)||r<=1)return i;for(let n=0;n<e.length&&i.length<r;){const l=e[n];if(!isCompatibleEngineBatchTask(t,l)){n+=1;continue}i.push(l),e.splice(n,1)}return i}export function buildTaskBatch(e){if(e.length<=1)return e[0]??null;const t=e[0];return{...t,batchId:c(e),batchTasks:[t,e[1],...e.slice(2)],batchFiles:e.map(o=>o.file)}}export function expandTaskResultOutcomes(e){return e?e.outcomes!==void 0?[...e.outcomes]:[e]:[]}export function isBatchableEngineTask(e){return p(e.testType,e.engineId).capabilities.taskBatching==="compatible"&&e.runtimeIsolation==="shared"&&e.resourceCost===1&&e.locks.length===0}export function isCompatibleEngineBatchTask(e,t){return!isBatchableEngineTask(e)||!isBatchableEngineTask(t)?!1:t.graphKey===e.graphKey&&t.targetName===e.targetName&&t.serviceName===e.serviceName&&t.testType===e.testType&&t.engineId===e.engineId&&t.profileId===e.profileId}function c(e){return`${e[0].engineId}-batch-${e.map(t=>t.id).join("-")}`}

package/dist/app/run/worker-loop.d.ts

@@ -0,0 +1,57 @@
+import { type EngineExecutionManager } from "./engine-execution.js";
+import type { TaskFailureDetail } from "./failure-details.js";
+import type { TestOutcomeStatus } from "../../domain/test-outcomes.js";
+import type { ProvisionedRun } from "../../environment/run-environment.js";
+import { type claimNextTask as claimScheduledTask } from "./planning.js";
+import type { recordGraphError, recordTaskOutcome, ServiceTrackerMap } from "./results.js";
+import { type TimingObservation } from "./scheduler/observations.js";
+import type { ScheduledTask } from "./scheduler/index.js";
+import type { RuntimeTaskReporter } from "./runtime-task-types.js";
+import { type TaskBatch } from "./task-batches.js";
+export type WorkerExecutableTask = ScheduledTask | TaskBatch<ScheduledTask>;
+export interface WorkerOutcomeTaskIdentity {
+    file: string;
+    id: number | string;
+}
+export interface WorkerOutcomeWithTaskIdentity {
+    task: WorkerOutcomeTaskIdentity;
+}
+export interface ResolvedWorkerOutcome<Task extends WorkerOutcomeTaskIdentity, Outcome extends WorkerOutcomeWithTaskIdentity> {
+    outcome: Outcome;
+    task: Task;
+}
+export interface WorkerReportedOutcome {
+    blockedByRuntime?: boolean;
+    durationMs: number;
+    error: null | string;
+    failureDetails: readonly TaskFailureDetail[];
+    infraFailed?: boolean;
+    reason?: null | string;
+    status: TestOutcomeStatus;
+}
+export interface WorkerReporter extends RuntimeTaskReporter<ScheduledTask> {
+    runtimeError?(task: Readonly<ScheduledTask>, message: string): unknown;
+    taskFinished?(task: Readonly<ScheduledTask>, outcome: Readonly<WorkerReportedOutcome>): unknown;
+}
+export interface WorkerState {
+    currentGraphKey: null | string;
+    graphSwitches: number;
+    productDir: string;
+    taskCount: number;
+    workerId: number;
+}
+export interface WorkerResult {
+    durationMs: number;
+    errors: string[];
+    failed: boolean;
+    graphSwitches: number;
+    taskCount: number;
+    unpersistedErrors: string[];
+    workerId: number;
+}
+export type WorkerTaskClaimer = typeof claimScheduledTask<ScheduledTask>;
+export type WorkerTaskOutcomeRecorder = typeof recordTaskOutcome;
+export type WorkerGraphErrorRecorder = typeof recordGraphError;
+export declare function createWorker(workerId: number, productDir: string): WorkerState;
+export declare function runWorker(worker: WorkerState, queue: ScheduledTask[], run: ProvisionedRun, engineManager: EngineExecutionManager, trackers: ServiceTrackerMap, timingUpdates: TimingObservation[], claimNextTask: WorkerTaskClaimer, recordTaskOutcome: WorkerTaskOutcomeRecorder, recordGraphError: WorkerGraphErrorRecorder, reporter?: null | WorkerReporter): Promise<WorkerResult>;
+export declare function resolveWorkerOutcomeMappings<Task extends WorkerOutcomeTaskIdentity, Outcome extends WorkerOutcomeWithTaskIdentity>(tasks: readonly Task[], outcomes: readonly Outcome[]): Array<ResolvedWorkerOutcome<Task, Outcome>>;

package/dist/app/run/worker-loop.js

@@ -0,0 +1 @@
+import{EngineExecutionBridgeError as I,executeEngineTask as W}from"./engine-execution.js";import{formatError as L}from"../../kernel/error-serialization.js";import{DEFAULT_ENGINE_REPORTER_CALLBACK_TIMEOUT_MS as q,invokeBoundedReporterCallback as P}from"./engine-execution-reporting.js";import{taskNeedsLocalRuntime as j}from"./planning.js";import{drainRuntimeFailedTasks as U}from"./runtime-failures.js";import{buildTimingObservation as z}from"./scheduler/observations.js";import{buildTaskBatch as J,claimCompatibleTaskBatch as H,expandTaskResultOutcomes as Q}from"./task-batches.js";export function createWorker(e,t){return{workerId:e,productDir:t,currentGraphKey:null,graphSwitches:0,taskCount:0}}export async function runWorker(e,t,i,r,n,u,c,h,p,f=null){const _=Date.now(),y=[],G=[];try{for(;!i.isStopRequested();){const d=c(t,e.currentGraphKey,a=>i.canAcquire(a));if(!d){const a=U(t,i);if(a.length>0){const o=Date.now(),s=new Set;for(const m of a)h(n,m.task,{status:"not_run",reason:m.reason,durationMs:0,startedAt:o,finishedAt:o,error:null,infraFailed:m.infraFailed,blockedByRuntime:m.blockedByRuntime,failureDetails:m.failureDetails}),s.has(m.graph.key)||(p(n,m.graph,m.message,o,{classification:"infra"}),s.add(m.graph.key));e.taskCount+=a.length;continue}if(t.length===0)break;await ae(10);continue}let k=null,w=[d],T=d,v=!1,K=null,O="acquire",E=[],b=null;try{w=H(t,d),T=J(w)??d,e.currentGraphKey!==null&&e.currentGraphKey!==d.graphKey&&(e.graphSwitches+=1),e.currentGraphKey=d.graphKey,k=await i.acquire({...T,startApplicationServices:j(T)}),O="execute";const a=await W(r,k,T,i,f);O="mapping";const o=Q(a);E=resolveWorkerOutcomeMappings(w,o),E.some(({outcome:s})=>s.infraFailed&&s.blockedByRuntime)&&(v=!0)}catch(a){const o=O==="acquire"?te(a,i):ee(a);K={disposition:o,error:a},v=k!==null&&o.runtimeImpact!=="none"}finally{b=await Y(i,k,v)}const l=[];let R=null;const F=()=>{if(R!==null)return R;try{R=ie(i,k,d)}catch(a){l.push(C("Runtime failure graph resolution failed",a)),R=X(k,d)}return R};if(K===null){for(const{outcome:o,task:s}of E)await A({operationErrors:l,outcome:o,recordTaskOutcome:h,recordTiming:!0,reporter:f,reportTaskFinished:!1,task:s,timingUpdates:u,trackers:n});e.taskCount+=E.length;const a=E.filter(({outcome:o})=>o.infraFailed&&o.blockedByRuntime);if(a.length>0){const o=a.map(({outcome:s})=>s.reason??s.error??"Runtime readiness failed before engine execution").join("; ");y.push(o),await S(l,"Runtime error reporter failed",()=>f?.runtimeError?.(d,o)),await g(l,"Runtime graph failure recording failed",()=>{i.markGraphFailed(d.graphKey,o)}),await g(l,"Result graph error recording failed",()=>{p(n,F(),o,Date.now(),{classification:"infra"})})}}else{const{disposition:a,error:o}=K,s=L(o),m=V(w,o);a.status!=="cancelled"&&y.push(s),a.notifyRuntimeError&&await S(l,"Runtime error reporter failed",()=>f?.runtimeError?.(m,s)),a.status!=="cancelled"&&(a.runtimeImpact==="fail-graph"&&await g(l,"Runtime graph failure recording failed",()=>{i.markGraphFailed(d.graphKey,s)}),await g(l,"Result graph error recording failed",()=>{p(n,F(),s,Date.now(),{classification:a.classification??"product"})}));const N=Date.now();for(const B of w){const x=o instanceof I&&o.completedOutcomesByTaskId.has(String(B.id)),M=Z(B,T,o,a,s,N);await A({operationErrors:l,outcome:M,recordTaskOutcome:h,recordTiming:x,reporter:f,reportTaskFinished:!x,task:B,timingUpdates:u,trackers:n})}e.taskCount+=w.length}if(b!==null){const a=b.message;y.push(a),await S(l,"Runtime error reporter failed",()=>f?.runtimeError?.(d,a)),b.recovered||await g(l,"Runtime graph failure recording failed",()=>{i.markGraphFailed(d.graphKey,a)}),await g(l,"Result graph error recording failed",()=>{p(n,F(),a,Date.now(),{classification:"infra"})})}if(l.length>0){const a=[...l];for(const s of a)y.push(s.message);const o=a.map(s=>s.message).join("; ");await g(l,"Result graph error recording failed while reporting a Testkit operation failure",()=>{p(n,F(),o,Date.now(),{classification:"infra"})});for(const s of l.slice(a.length))y.push(s.message);l.length>a.length&&G.push(...a.map(s=>s.message),...l.slice(a.length).map(s=>s.message))}}}finally{e.currentGraphKey=null}return{workerId:e.workerId,failed:y.length>0,durationMs:Date.now()-_,taskCount:e.taskCount,graphSwitches:e.graphSwitches,errors:y,unpersistedErrors:G}}async function A({operationErrors:e,outcome:t,recordTaskOutcome:i,recordTiming:r,reporter:n,reportTaskFinished:u,task:c,timingUpdates:h,trackers:p}){await g(e,`Task outcome recording failed for ${c.file}`,()=>{i(p,c,t)}),u&&await S(e,`Task-finished reporter failed for ${c.file}`,()=>n?.taskFinished?.(c,t)),r&&await g(e,`Task timing recording failed for ${c.file}`,()=>{const f=z(c,t);f&&h.push(f)})}async function g(e,t,i){try{await i()}catch(r){e.push(C(t,r))}}async function S(e,t,i){await g(e,t,()=>P(t,i,{timeoutMs:q}))}function C(e,t){const i=$(t);return new Error(`${e}: ${i.message}`,{cause:i})}function V(e,t){const i=e[0];if(!(t instanceof I))return i;if(t.failingTaskId!==null){const r=e.find(n=>String(n.id)===t.failingTaskId);if(r!==void 0)return r}return e.find(r=>!t.completedOutcomesByTaskId.has(String(r.id)))??i}function X(e,t){return{key:e?.graphKey??t.graphKey,targetNames:e?.targetNames??[t.targetName]}}async function Y(e,t,i){if(t===null)return null;try{return await e.release(t.leaseId,{invalidate:i}),null}catch(r){const n=$(r);try{return await e.release(t.leaseId,{invalidate:!0}),{message:`Runtime lease release failed but recovered on idempotent retry: ${n.message}`,recovered:!0}}catch(u){const c=$(u);return{message:`Runtime lease release failed: ${n.message}; idempotent retry also failed: ${c.message}`,recovered:!1}}}}function Z(e,t,i,r,n,u){const c={kind:"engine-invocation",key:"engine_invocation_failed",title:"Engine invocation failed",count:1,...r.classification===void 0?{}:{classification:r.classification},message:n,...i instanceof Error&&i.stack?{stack:i.stack}:{}},h=i instanceof I?i.completedOutcomesByTaskId.get(String(e.id)):void 0;if(h!==void 0)return h;const p=i instanceof I?i.artifactReferencesByTaskId.get(String(e.id))??[]:[];return{task:e,status:r.status,error:r.status==="failed"?n:null,reason:r.status==="failed"?null:n,infraFailed:r.classification==="infra",blockedByRuntime:r.status==="not_run",durationMs:0,startedAt:u,finishedAt:u,artifacts:[...p],failureDetails:r.status==="cancelled"?[]:[c],checkDetails:[],..."batchTasks"in t?{runtimeBatch:{id:t.batchId,index:t.batchTasks.findIndex(f=>f.id===e.id&&f.file===e.file),fileCount:t.batchTasks.length,files:t.batchTasks.map(f=>f.file)}}:{}}}function ee(e){return e instanceof I?e.disposition:{classification:"infra",notifyRuntimeError:!0,runtimeImpact:"none",status:"not_run"}}function te(e,t){return t.signal.aborted&&e===t.signal.reason?{classification:void 0,notifyRuntimeError:!1,runtimeImpact:"none",status:"cancelled"}:{classification:"infra",notifyRuntimeError:!0,runtimeImpact:"fail-graph",status:"not_run"}}export function resolveWorkerOutcomeMappings(e,t){const i=new Map;for(const n of e){const u=D(n);if(i.has(u))throw new Error(`Worker claimed duplicate task ${n.id.toString()} (${n.file})`);i.set(u,n)}const r=new Map;for(const n of t){const u=D(n.task),c=i.get(u);if(!c)throw new Error(`Task runner returned an outcome for unclaimed task ${n.task.id.toString()} (${n.task.file})`);if(r.has(u))throw new Error(`Task runner returned duplicate outcomes for claimed task ${c.id.toString()} (${c.file})`);r.set(u,{outcome:n,task:c})}for(const n of e)if(!r.has(D(n)))throw new Error(`Task runner did not return an outcome for claimed task ${n.id.toString()} (${n.file})`);return[...r.values()]}function D(e){return JSON.stringify([typeof e.id,e.id,e.file])}function ie(e,t,i){return e.getGraph(i.graphKey)??{key:t?.graphKey??i.graphKey,targetNames:t?.targetNames??[i.targetName]}}function ae(e){return new Promise(t=>setTimeout(t,e))}function $(e){return e instanceof Error?e:new Error(String(e))}

package/dist/app/setup/playwright.d.ts

@@ -0,0 +1,22 @@
+import { type PlaywrightInstallation } from "../../engines/installations/playwright.js";
+export declare const PLAYWRIGHT_SETUP_TIMEOUT_MS: number;
+export interface ExecutePlaywrightSetupOptions {
+    readonly ambientEnvironment?: Readonly<NodeJS.ProcessEnv>;
+    readonly configuredRegistry?: string;
+    readonly force: boolean;
+    readonly productRoot: string;
+    readonly signal: AbortSignal;
+    readonly withDeps: boolean;
+}
+export declare class PlaywrightSetupError extends Error {
+    readonly code = "TESTKIT_PLAYWRIGHT_SETUP_FAILED";
+    constructor(problem: string, options?: ErrorOptions);
+}
+export declare function playwrightSetupArguments(cli: string, options: Readonly<{
+    force: boolean;
+    withDeps: boolean;
+}>): readonly string[];
+export declare function executePlaywrightSetup(options: Readonly<ExecutePlaywrightSetupOptions>): Promise<PlaywrightInstallation>;
+export declare function setupPlaywright(options: Readonly<Omit<ExecutePlaywrightSetupOptions, "productRoot"> & {
+    dir?: string;
+}>): Promise<PlaywrightInstallation>;

package/dist/app/setup/playwright.js

@@ -0,0 +1 @@
+import{resolveProductDir as c}from"../../config/loader/index.js";import u from"node:os";import{runManagedProcess as m}from"../../process/index.js";import{currentLinuxLibc as s,currentPlatformTarget as n}from"../../process/host/platform.js";import{RootPackageResolver as d}from"../../engines/installations/package-resolution.js";import{playwrightRegistryEnvironment as g,requireSupportedPlaywrightHost as f,resolvePlaywrightInstallation as h,resolvePlaywrightPackageFamily as p,resolvePlaywrightRegistry as w,throwIfPlaywrightProcessAborted as P}from"../../engines/installations/playwright.js";export const PLAYWRIGHT_SETUP_TIMEOUT_MS=1200*1e3;export class PlaywrightSetupError extends Error{code="TESTKIT_PLAYWRIGHT_SETUP_FAILED";constructor(e,t){super(`Playwright setup failed: ${e}`,t),this.name="PlaywrightSetupError"}}export function playwrightSetupArguments(r,e){return Object.freeze([r,"install","chromium","--no-shell",...e.withDeps?["--with-deps"]:[],...e.force?["--force"]:[]])}export async function executePlaywrightSetup(r){r.signal.throwIfAborted(),f({linuxLibc:s(),target:n()});const e=Object.freeze({...r.ambientEnvironment??process.env}),t=r.configuredRegistry??e.PLAYWRIGHT_BROWSERS_PATH,a=p(new d),l=w({ambientEnvironment:e,configuredValue:t,homeDirectory:u.homedir(),platform:n().platform,productRoot:r.productRoot}),o=await m({args:playwrightSetupArguments(a.cli,r),cwd:r.productRoot,displayLabel:"Playwright Chromium setup",env:g(e,l),executable:process.execPath,signal:r.signal,timeoutMs:PLAYWRIGHT_SETUP_TIMEOUT_MS}),i=y(o);if(P(r.signal,o,i),i!==null)throw new PlaywrightSetupError(i.message,{cause:i});return h({productRoot:r.productRoot,signal:r.signal},{ambientEnvironment:e,configuredRegistry:t})}function y(r){if(r.terminationError!==null)return r.terminationError;if(r.error!==null)return r.error;if(r.timedOut)return new Error(`Chromium installer exceeded ${PLAYWRIGHT_SETUP_TIMEOUT_MS.toString()} milliseconds`);if(r.cancelled)return new Error("Chromium installer was cancelled");if(r.outputLimitExceeded)return new Error("Chromium installer exceeded the managed output limit");if(r.exitCode!==0){const e=r.stderr.trim();return new Error(`Chromium installer ${r.exitCode===null?`terminated by ${String(r.exitSignal)}`:`exited with code ${r.exitCode.toString()}`}${e.length===0?"":`: ${e}`}`)}return null}export function setupPlaywright(r){return executePlaywrightSetup({...r,productRoot:c(process.cwd(),r.dir)})}

package/dist/app/status/index.d.ts

@@ -0,0 +1,7 @@
+import { type StatusModel } from "./model.js";
+export type { StatusModel } from "./model.js";
+export interface CollectServiceStatusOptions {
+    dir?: string;
+    service?: null | string;
+}
+export declare function collectServiceStatus(options?: Readonly<CollectServiceStatusOptions>): Promise<StatusModel[]>;

package/dist/app/status/index.js

@@ -0,0 +1 @@
+import{loadManagedConfigs as n}from"../../config/loader/managed-configs.js";import{collectStatusModel as e}from"./model.js";export async function collectServiceStatus(o={}){const{allConfigs:t,configs:a}=await n(o);return a.map(c=>e(c,{allConfigs:t}))}

package/dist/app/status/model.d.ts

@@ -0,0 +1,29 @@
+import type { NormalizedServiceConfig } from "../../config/loader/index.js";
+import { type RunStatus, type RuntimeGraphStatus } from "../../environment/maintenance.js";
+import { type BundleCacheStatus } from "../../engines/bundle-cache.js";
+import { type DirectoryStatus } from "../../process/files/directory-status.js";
+export interface StatusModel {
+    caches: {
+        bundles: BundleCacheStatus;
+    };
+    hasState: boolean;
+    name: string;
+    product: {
+        configFile: null | string;
+        dependencies: string[];
+        dir: string;
+        selectedService: string;
+        services: string[];
+    };
+    runs: RunStatus;
+    runtimeGraphs: RuntimeGraphStatus[];
+    schemaVersion: 1;
+    serviceState: DirectoryStatus;
+    warnings: string[];
+}
+export interface StatusModelOptions {
+    allConfigs?: readonly NormalizedServiceConfig[];
+}
+export declare function collectStatusModel(config: Readonly<NormalizedServiceConfig>, { allConfigs }?: Readonly<StatusModelOptions>): StatusModel;
+export type { BundleCacheStatus } from "../../engines/bundle-cache.js";
+export type { DirectoryStatus } from "../../process/files/directory-status.js";

package/dist/app/status/model.js

@@ -0,0 +1 @@
+import{createEnvironmentMaintenance as l}from"../../environment/maintenance.js";import{runtimePlanning as p}from"../../environment/runtime-planning.js";import{collectBundleCacheStatus as d}from"../../engines/bundle-cache.js";import{collectDirectorySummary as h}from"../../process/files/directory-status.js";export function collectStatusModel(t,{allConfigs:e=[t]}={}){const n=t.productDir,i=p.collectDesiredRuntimeGraphs(e),{runtimeGraphs:r,runs:o}=l(n).inspect(i,t.name),u=h(t.stateDir),s=d(n,t.name),a=S({runtimeGraphs:r,bundles:s}),m=u.exists||r.some(c=>c.exists)||o.total>0||s.exists;return{schemaVersion:1,name:t.name,product:{dir:n,configFile:t.configFile||null,services:e.map(c=>c.name).sort(),selectedService:t.name,dependencies:[...t.testkit.dependsOn].sort()},hasState:m,runs:o,serviceState:u,runtimeGraphs:r,caches:{bundles:s},warnings:a}}function S({runtimeGraphs:t,bundles:e}){const n=[],i=t.reduce((r,o)=>r+o.staleRuntimeDirs.length,0);if(i>0&&n.push(`${i.toString()} stale runtime ${i===1?"directory":"directories"} found outside the configured runtime set.`),e.duplicatedSourceCount>0&&n.push(`${e.duplicatedSourceCount.toString()} source file${e.duplicatedSourceCount===1?"":"s"} have duplicate bundle versions.`),e.unmanagedFileCount>0&&n.push(`${e.unmanagedFileCount.toString()} bundle cache file${e.unmanagedFileCount===1?"":"s"} are unmanaged by the manifest.`),(e.sourcemapFileCount??0)>0||e.sourcemapStatus==="detected"){const r=e.sourcemapFileCount==null?"Bundle files":`${e.sourcemapFileCount.toString()} bundle file${e.sourcemapFileCount===1?"":"s"}`;n.push(`${r} contain inline sourcemaps.`)}return n}

package/dist/app/status/runs.d.ts

@@ -0,0 +1,99 @@
+import { type NormalizedConfigContext } from "../../config/loader/index.js";
+import { type RunManifest } from "../../environment/maintenance.js";
+import { type UnknownRecord } from "../../kernel/unknown-values.js";
+type RunStatusContext = Pick<NormalizedConfigContext, "productDir">;
+export interface BuildRunStatusOptions {
+    full?: boolean;
+    runId?: null | string;
+}
+export interface ActiveRunManifest extends RunManifest {
+    active: boolean;
+}
+export interface RunSessionSummary {
+    kind: null | string;
+    stage: null | string;
+    status: null | string;
+}
+export interface RunManifestSummary {
+    active: boolean;
+    heartbeatAt: null | string;
+    interruptReason: null | string;
+    pid: number | undefined;
+    runId: unknown;
+    session: null | RunSessionSummary;
+    stale: boolean;
+    startedAt: null | string;
+    status: string;
+    terminal: boolean;
+}
+export interface StatusOperation extends UnknownRecord {
+    name?: unknown;
+    status?: unknown;
+}
+export interface LiveArtifactState {
+    reason: null | string;
+    runId: string;
+    status: string;
+}
+export interface LiveArtifactSummary {
+    artifactRef: ".testkit/results/live.json";
+    generatedAt: null | string;
+    operation: null | StatusOperation;
+    operationCount: number;
+    present: true;
+    product: null | {
+        directory: null | string;
+        name: null | string;
+    };
+    run: null | {
+        durationMs: null | number;
+        finishedAt: null | string;
+        id: null | string;
+        interruptReason: null | string;
+        startedAt: null | string;
+        status: null | string;
+        testkitVersion: null | string;
+    };
+    schemaVersion: null | number;
+    state?: LiveArtifactState;
+    summary: unknown;
+    truncated: true;
+}
+export interface FullRunStatus {
+    live: unknown;
+    mode: "full";
+    productDir: string;
+    runs: ActiveRunManifest[];
+}
+export interface SummaryRunStatus {
+    live: LiveArtifactSummary | null;
+    mode: "summary";
+    productDir: string;
+    runs: RunManifestSummary[];
+}
+export type RunStatus = FullRunStatus | SummaryRunStatus;
+interface RenderableRun {
+    active: boolean;
+    pid?: number;
+    runId: unknown;
+    status?: string;
+    terminal?: boolean;
+}
+export interface RenderableRunStatus {
+    live?: unknown;
+    productDir: string;
+    runs?: readonly RenderableRun[];
+}
+export declare function collectRunStatus(options: Readonly<BuildRunStatusOptions & {
+    dir?: string;
+}>): Promise<RunStatus>;
+export declare function buildRunStatus(context: Readonly<RunStatusContext>, options: Readonly<BuildRunStatusOptions> & {
+    full: true;
+}): Promise<FullRunStatus>;
+export declare function buildRunStatus(context: Readonly<RunStatusContext>, options?: Readonly<BuildRunStatusOptions> & {
+    full?: false;
+}): Promise<SummaryRunStatus>;
+export declare function buildRunStatus(context: Readonly<RunStatusContext>, options: Readonly<BuildRunStatusOptions>): Promise<RunStatus>;
+export declare function latestOperation(operations: unknown): StatusOperation | null;
+export declare function describeLiveArtifactState(result: Readonly<RenderableRunStatus>): LiveArtifactState;
+export {};

package/dist/app/status/runs.js

@@ -0,0 +1 @@
+import c from"node:fs";import f from"node:path";import{loadConfigContext as m}from"../../config/loader/index.js";import{createEnvironmentMaintenance as d}from"../../environment/maintenance.js";import{asUnknownRecord as a,displayString as l,isUnknownRecord as p,optionalString as e}from"../../kernel/unknown-values.js";export async function collectRunStatus(t){const r=await m({dir:t.dir});return buildRunStatus(r,t)}export function buildRunStatus(t,r={}){const n=d(t.productDir).inspectRuns().filter(o=>!r.runId||o.runId===r.runId),s=A(f.join(t.productDir,".testkit","results","live.json"));if(r.full)return Promise.resolve({productDir:t.productDir,mode:"full",runs:n,live:s});const i={productDir:t.productDir,mode:"summary",runs:n.map(g),live:k(s)};return i.live&&(i.live.state=describeLiveArtifactState(i)),Promise.resolve(i)}export function latestOperation(t){if(!Array.isArray(t))return null;const r=t.filter(p);return[...r].reverse().find(n=>n.status==="running")??r.at(-1)??null}export function describeLiveArtifactState(t){const r=a(t.live),n=a(r?.run),s=l(n?.id,"unknown"),i=l(n?.status,"unknown"),o=v(t,s);return i==="running"&&!o?{runId:s,status:"stale",reason:"no active run matches this live artifact"}:{runId:s,status:i,reason:e(n?.interruptReason)}}function v(t,r){if(!r||r==="unknown")return!1;for(const n of t.runs??[])if(n.active&&y(r,n.runId))return!0;return!1}function y(t,r){if(!r)return!1;const n=typeof r=="string"?r:typeof r=="number"&&Number.isFinite(r)?r.toString():null;return n?n===t||n.startsWith(`${t}:`):!1}function A(t){try{return JSON.parse(c.readFileSync(t,"utf8"))}catch{return null}}function g(t){const r=h(t.status);return{runId:t.runId,pid:t.pid,status:t.status||"unknown",startedAt:t.startedAt||null,heartbeatAt:t.heartbeatAt||null,interruptReason:t.interruptReason||null,active:t.active,terminal:r,stale:!t.active&&!r,session:b(t.session)}}function h(t){return typeof t=="string"&&["finished","failed","interrupted"].includes(t)}function b(t){const r=a(t);return r?{kind:e(r.kind),status:e(r.status),stage:e(r.stage)}:null}function k(t){const r=a(t);if(!r)return null;const s=a(r.timings)?.operations??[],i=Array.isArray(s)?s:[],o=a(r.product),u=a(r.run);return{present:!0,schemaVersion:w(r.schemaVersion),generatedAt:e(r.generatedAt),product:o?{name:e(o.name),directory:e(o.directory)}:null,run:u?{id:e(u.id),status:e(u.status),startedAt:e(u.startedAt),finishedAt:e(u.finishedAt),durationMs:S(u.durationMs),interruptReason:e(u.interruptReason),testkitVersion:e(u.testkitVersion)}:null,summary:r.summary??null,operation:latestOperation(i),operationCount:i.length,artifactRef:".testkit/results/live.json",truncated:!0}}function S(t){const r=Number(t);return Number.isFinite(r)?r:null}function w(t){return typeof t=="number"&&Number.isFinite(t)?t:null}

package/dist/app/stop/index.d.ts

@@ -0,0 +1,14 @@
+import { type StoppedRun } from "../../environment/maintenance.js";
+export interface StopRunsOptions {
+    all?: boolean;
+    reason?: unknown;
+    runId?: null | string;
+}
+export declare function stopRuns(productDir: string, options?: Readonly<StopRunsOptions>): Promise<StoppedRun[]>;
+export type { StoppedRun } from "../../environment/maintenance.js";
+export declare function stopProductRuns(options: Readonly<StopRunsOptions & {
+    dir?: string;
+}>, defaultReason: string): Promise<{
+    productDir: string;
+    stoppedRuns: StoppedRun[];
+}>;

package/dist/app/stop/index.js

@@ -0,0 +1 @@
+import{loadConfigContext as i}from"../../config/loader/index.js";import{createEnvironmentMaintenance as u}from"../../environment/maintenance.js";import{normalizeOperationReason as a}from"../../domain/operation-reason.js";export async function stopRuns(r,n={}){return u(r).stop(n.runId?{kind:"run",runId:n.runId}:n.all?{kind:"all"}:{kind:"latest-active"},a(n.reason,"run stopped"))}export async function stopProductRuns(r,n){const{productDir:t}=await i({dir:r.dir}),e=a(r.reason,n),o=await stopRuns(t,{...r,reason:e});return{productDir:t,stoppedRuns:o}}