@gfdelarue/testkit 0.3.0

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

@@ -0,0 +1,161 @@
+import type { RuntimeIsolationPolicy } from "../../config/loader/index.js";
+import type { TestOutcomeStatus } from "../../domain/test-outcomes.js";
+import { type NormalizedCheckDetail, type NormalizedFailureDetail } from "./failure-details.js";
+import type { CollectedSuite, PlanningServiceConfig } from "./planning.js";
+import type { PersistedArtifactReference, ReportingRecord, ReportingRuntimeBatch, ReportingRuntimeReset, RunArtifactFile, RunArtifactSuite, RunServiceResult } from "../../evidence/index.js";
+import type { CompletedRuntimeTaskResult } from "./runtime-task-types.js";
+import type { ScheduledTask } from "./scheduler/index.js";
+export type ResultServiceConfig = Pick<PlanningServiceConfig, "name"> & {
+    testkit: Pick<PlanningServiceConfig["testkit"], "database">;
+};
+export type ResultServicePlanSuite = Pick<CollectedSuite, "engineId" | "files" | "name" | "orderIndex" | "profileId" | "testType"> & Partial<Pick<CollectedSuite, "skippedFiles" | "totalFileCount">>;
+export interface ResultServicePlan {
+    config: ResultServiceConfig;
+    skipped?: boolean;
+    suites: readonly ResultServicePlanSuite[];
+}
+export type ResultTask = Pick<ScheduledTask, "engineId" | "file" | "profileId" | "serviceName" | "suiteKey" | "testType"> & Partial<Pick<ScheduledTask, "runtimeIsolation">>;
+export interface ResultGraph {
+    readonly targetNames: readonly string[];
+}
+export type ResultErrorClassification = "infra" | "product";
+export interface ResultErrorDetail extends ReportingRecord {
+    classification: ResultErrorClassification;
+    message: string;
+}
+export interface NormalizedRuntimeBatch extends ReportingRuntimeBatch {
+    fileCount: number;
+    files: string[];
+    id: string;
+    index: number;
+}
+export interface NormalizedRuntimeReset extends ReportingRuntimeReset {
+    position?: string;
+    reason?: string;
+    runtimeIsolation?: string;
+    trigger?: string;
+}
+type NormalizedCompletedTaskFields = Omit<CompletedRuntimeTaskResult<NormalizedFailureDetail, NormalizedCheckDetail>, "task">;
+export interface NormalizedTaskOutcome extends NormalizedCompletedTaskFields {
+    blockedByRuntime: boolean;
+    infraFailed: boolean;
+    reason: null | string;
+    runtimeBatch: null | NormalizedRuntimeBatch;
+    runtimeIsolation: null | RuntimeIsolationPolicy;
+    runtimeResets: NormalizedRuntimeReset[];
+}
+export type TaskOutcomeInput = Pick<NormalizedTaskOutcome, "status"> & Partial<NormalizedTaskOutcome>;
+export interface TrackedFileResult {
+    artifacts: PersistedArtifactReference[];
+    blockedByRuntime: boolean;
+    checkDetails: NormalizedCheckDetail[];
+    durationMs: number;
+    error: null | string;
+    failed: boolean;
+    failureDetails: NormalizedFailureDetail[];
+    infraFailed: boolean;
+    path: string;
+    reason: null | string;
+    runtimeBatch: null | NormalizedRuntimeBatch;
+    runtimeIsolation: null | RuntimeIsolationPolicy;
+    runtimeResets: NormalizedRuntimeReset[];
+    status: TestOutcomeStatus;
+}
+export interface ServiceSuiteTracker {
+    durationMs: number;
+    engineId: CollectedSuite["engineId"];
+    error: null | string;
+    failedFileSet: Set<string>;
+    failedFiles: string[];
+    fileResultsByPath: Map<string, TrackedFileResult>;
+    key: string;
+    name: string;
+    orderIndex: number;
+    profileId: CollectedSuite["profileId"];
+    testType: CollectedSuite["testType"];
+}
+export interface ServiceTracker {
+    dbBackend: "local" | null;
+    errorDetails: ResultErrorDetail[];
+    errorDetailSet: Set<string>;
+    errors: string[];
+    errorSet: Set<string>;
+    firstTaskAt: null | number;
+    lastTaskAt: null | number;
+    name: string;
+    skipped: boolean;
+    startedAt: number;
+    suiteCount: number;
+    suites: ServiceSuiteTracker[];
+    suitesByKey: Map<string, ServiceSuiteTracker>;
+    totalTaskDurationMs: number;
+}
+export type ServiceTrackerMap = Map<string, ServiceTracker>;
+export interface FinalizedFileResult extends RunArtifactFile {
+    artifacts?: PersistedArtifactReference[];
+    blockedByRuntime?: true;
+    checkDetails?: NormalizedCheckDetail[];
+    durationMs: number;
+    error: null | string;
+    failed: boolean;
+    failureDetails?: NormalizedFailureDetail[];
+    infraFailed?: true;
+    path: string;
+    reason: null | string;
+    runtimeBatch?: NormalizedRuntimeBatch;
+    runtimeIsolation?: RuntimeIsolationPolicy;
+    runtimeResets?: NormalizedRuntimeReset[];
+    status: TestOutcomeStatus;
+}
+export interface FinalizedSuiteResult extends RunArtifactSuite {
+    completedFileCount: number;
+    durationMs: number;
+    error: null | string;
+    failed: boolean;
+    failedFileCount: number;
+    failedFiles: string[];
+    fileCount: number;
+    files: FinalizedFileResult[];
+    engineId: CollectedSuite["engineId"];
+    name: string;
+    notRunFileCount: number;
+    passedFileCount: number;
+    profileId: CollectedSuite["profileId"];
+    skippedFileCount: number;
+    testType: CollectedSuite["testType"];
+}
+export interface FinalizedServiceResult extends RunServiceResult {
+    blockedByRuntime: boolean;
+    blockedByRuntimeFileCount?: number;
+    completedFileCount: number;
+    completedSuiteCount: number;
+    dbBackend?: null | string;
+    durationMs: number;
+    errorDetails: ResultErrorDetail[];
+    errors: string[];
+    failed: boolean;
+    failedFileCount: number;
+    failedSuiteCount: number;
+    infraFailed: boolean;
+    infraFailedFileCount?: number;
+    name: string;
+    notRunFileCount: number;
+    passedFileCount: number;
+    skipped: boolean;
+    skippedFileCount: number;
+    skippedSuiteCount: number;
+    suiteCount: number;
+    suites: FinalizedSuiteResult[];
+    totalFileCount: number;
+    totalTaskDurationMs: number;
+}
+export interface AddTrackerErrorOptions {
+    classification?: ResultErrorClassification;
+}
+export declare function buildServiceTrackers(servicePlans: readonly ResultServicePlan[], startedAt: number): ServiceTrackerMap;
+export declare function recordTaskOutcome(trackers: ReadonlyMap<string, ServiceTracker>, task: Readonly<ResultTask>, outcomeValue: Readonly<TaskOutcomeInput>, finishedAt?: number): void;
+export declare function recordGraphError(trackers: ReadonlyMap<string, ServiceTracker>, graph: null | Readonly<ResultGraph> | undefined, message: string, now?: number, options?: Readonly<AddTrackerErrorOptions>): void;
+export declare function addTrackerError(tracker: ServiceTracker, message: string, options?: Readonly<AddTrackerErrorOptions>): void;
+export declare function finalizeServiceResult(tracker: Readonly<ServiceTracker> | null | undefined, startedAt: number, finishedAt: number): FinalizedServiceResult;
+export declare function summarizeDbBackend(results: readonly Pick<RunServiceResult, "dbBackend">[]): null | string;
+export {};

package/dist/app/run/results.js

@@ -0,0 +1 @@
+import b from"node:path";import{mergeFailureDetails as x}from"./failure-details.js";export function buildServiceTrackers(e,i){const l=new Map;for(const t of e){const r=t.skipped?[]:t.suites.map(w),o={name:t.config.name,dbBackend:z(t.config),skipped:t.skipped===!0,suiteCount:r.length,suites:r,suitesByKey:new Map(r.map(n=>[n.key,n])),errors:[],errorSet:new Set,errorDetails:[],errorDetailSet:new Set,startedAt:i,firstTaskAt:null,lastTaskAt:null,totalTaskDurationMs:0};l.set(t.config.name,o)}return l}function w(e){const i=new Map;for(const l of e.files){const t=g(l);i.set(t,k(t,"not_run",null))}for(const l of e.skippedFiles??[])i.set(l.path,k(l.path,"skipped",l.reason));return{key:`${e.testType}:${e.name}`,name:e.name,testType:e.testType,engineId:e.engineId,profileId:e.profileId,orderIndex:e.orderIndex,failedFiles:[],failedFileSet:new Set,fileResultsByPath:i,durationMs:0,error:null}}function k(e,i,l){return{path:e,failed:i==="failed",durationMs:0,error:null,reason:l,status:i,artifacts:[],infraFailed:!1,blockedByRuntime:!1,failureDetails:[],checkDetails:[],runtimeIsolation:null,runtimeBatch:null,runtimeResets:[]}}function z(e){return e.testkit.database?"local":null}export function recordTaskOutcome(e,i,l,t=Date.now()){const r=e.get(i.serviceName);if(!r||r.skipped)return;const o=r.suitesByKey.get(i.suiteKey);if(!o)return;const n=P(l,i,t);r.firstTaskAt=r.firstTaskAt===null?n.startedAt:Math.min(r.firstTaskAt,n.startedAt),r.lastTaskAt=r.lastTaskAt===null?n.finishedAt:Math.max(r.lastTaskAt,n.finishedAt),r.totalTaskDurationMs+=n.durationMs,o.durationMs+=n.durationMs;const f=g(i.file),s=o.fileResultsByPath.get(f),u=s??k(f,n.status,n.reason);u.failed=n.status==="failed",u.durationMs=n.durationMs,u.error=n.error,u.reason=n.reason,u.status=n.status,u.artifacts=n.artifacts,u.infraFailed=n.infraFailed,u.blockedByRuntime=n.blockedByRuntime,u.failureDetails=n.failureDetails,u.checkDetails=n.checkDetails,u.runtimeIsolation=n.runtimeIsolation,u.runtimeBatch=n.runtimeBatch,u.runtimeResets=n.runtimeResets,s||o.fileResultsByPath.set(f,{...u}),n.status==="failed"&&!o.failedFileSet.has(i.file)&&(o.failedFileSet.add(i.file),o.failedFiles.push(i.file)),n.error&&!o.error&&(o.error=n.error)}function P(e,i,l){const t=e.durationMs??0,r=e.finishedAt??l;return{artifacts:e.artifacts??[],blockedByRuntime:e.blockedByRuntime??!1,checkDetails:e.checkDetails??[],durationMs:t,error:e.error??null,failureDetails:x(e.failureDetails??[]),finishedAt:r,infraFailed:e.infraFailed??!1,reason:e.reason??null,runtimeBatch:e.runtimeBatch??null,runtimeIsolation:e.runtimeIsolation??i.runtimeIsolation??null,runtimeResets:e.runtimeResets??[],startedAt:e.startedAt??Math.max(0,r-t),status:e.status}}export function recordGraphError(e,i,l,t=Date.now(),r={}){const o=i?.targetNames||[];for(const n of o){const f=e.get(n);f&&!f.skipped&&(addTrackerError(f,l,r),f.lastTaskAt=t)}}export function addTrackerError(e,i,l={}){const t=i.trim();if(!t)return;const r=l.classification??"product";e.errorSet.has(t)||(e.errorSet.add(t),e.errors.push(t));const o=`${r}\0${t}`;e.errorDetailSet.has(o)||(e.errorDetailSet.add(o),e.errorDetails.push({message:t,classification:r}))}export function finalizeServiceResult(e,i,l){if(!e||e.skipped)return{name:e?.name||"unknown",failed:!1,skipped:!0,suiteCount:0,completedSuiteCount:0,skippedSuiteCount:0,failedSuiteCount:0,totalFileCount:0,completedFileCount:0,passedFileCount:0,failedFileCount:0,skippedFileCount:0,notRunFileCount:0,durationMs:0,totalTaskDurationMs:0,suites:[],errors:[],errorDetails:[],infraFailed:!1,blockedByRuntime:!1};const t=[...e.suites].sort((a,d)=>a.orderIndex-d.orderIndex||a.name.localeCompare(d.name)).map(a=>v(a)),r=t.filter(a=>a.completedFileCount+a.skippedFileCount===a.fileCount).length,o=t.filter(a=>a.skippedFileCount===a.fileCount&&a.fileCount>0).length,n=t.filter(a=>a.failedFileCount>0).length,f=t.reduce((a,d)=>a+d.fileCount,0),s=t.reduce((a,d)=>a+d.completedFileCount,0),u=t.reduce((a,d)=>a+d.failedFileCount,0),D=t.reduce((a,d)=>a+d.passedFileCount,0),F=t.reduce((a,d)=>a+d.skippedFileCount,0),p=f-s-F,m=t.reduce((a,d)=>a+d.files.filter(c=>c.infraFailed===!0).length,0),C=t.reduce((a,d)=>a+d.files.filter(c=>c.blockedByRuntime===!0).length,0),B=t.reduce((a,d)=>a+d.files.filter(c=>c.status==="cancelled"||c.status==="interrupted").length,0),y=p>0&&B===p,R=p>0&&m===p,h=e.errorDetails,T=h.filter(a=>a.classification!=="infra").length,M=h.filter(a=>a.classification==="infra").length,S=m>0||M>0,I=C>0,A=e.firstTaskAt!==null&&e.lastTaskAt!==null?Math.max(0,e.lastTaskAt-e.firstTaskAt):Math.max(0,l-i);return{name:e.name,dbBackend:e.dbBackend,failed:n>0||T>0||r<e.suiteCount&&!y&&!R,infraFailed:S,blockedByRuntime:I,infraFailedFileCount:m,blockedByRuntimeFileCount:C,skipped:!1,suiteCount:e.suiteCount,completedSuiteCount:r,skippedSuiteCount:o,failedSuiteCount:n,totalFileCount:f,completedFileCount:s,passedFileCount:D,failedFileCount:u,skippedFileCount:F,notRunFileCount:p,durationMs:A,totalTaskDurationMs:e.totalTaskDurationMs,suites:t,errors:e.errors,errorDetails:h}}export function summarizeDbBackend(e){const i=[...new Set(e.map(l=>l.dbBackend).filter(l=>typeof l=="string"))];return i.length===0?null:i.length===1?i[0]:"mixed"}function v(e){const i=[...e.fileResultsByPath.values()].sort((s,u)=>s.path.localeCompare(u.path)).map(s=>({path:s.path,failed:s.failed,status:s.status,durationMs:s.durationMs,error:s.error,reason:s.reason,...s.infraFailed?{infraFailed:!0}:{},...s.blockedByRuntime?{blockedByRuntime:!0}:{},...s.failureDetails.length>0?{failureDetails:s.failureDetails}:{},...s.artifacts.length>0?{artifacts:s.artifacts}:{},...s.checkDetails.length>0?{checkDetails:s.checkDetails}:{},...s.runtimeIsolation?{runtimeIsolation:s.runtimeIsolation}:{},...s.runtimeBatch?{runtimeBatch:s.runtimeBatch}:{},...s.runtimeResets.length>0?{runtimeResets:s.runtimeResets}:{}})),l=i.length,t=i.filter(s=>s.status==="passed").length,r=i.filter(s=>s.status==="failed").length,o=i.filter(s=>s.status==="skipped").length,n=t+r,f=l-n-o;return{name:e.name,testType:e.testType,engineId:e.engineId,profileId:e.profileId,failed:r>0,fileCount:l,completedFileCount:n,passedFileCount:t,failedFileCount:r,skippedFileCount:o,notRunFileCount:f,failedFiles:e.failedFiles,durationMs:e.durationMs,error:e.error,files:i}}function g(e){return e.split(b.sep).join("/")}

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

@@ -0,0 +1,144 @@
+import type { OperationProgressInput } from "./operation-progress.js";
+import type { FinalizedServiceResult, ResultServicePlan } from "./results.js";
+import type { ReadyServiceConfig } from "../../environment/runtime-service.js";
+import type { BatchableTask } from "./task-batches.js";
+import type { WorkerReportedOutcome } from "./worker-loop.js";
+import type { ReportingSetupOperation } from "../../evidence/index.js";
+import type { SetupOperationSnapshot } from "../../evidence/setup-progress.js";
+import type { ResolvedNodeToolchain, ToolchainReportConfig } from "../../toolchains/index.js";
+type ResultServicePlanSuite = ResultServicePlan["suites"][number];
+export type RunEventTaskOutcome = Partial<WorkerReportedOutcome>;
+export type RunEventSetupOperation = ReportingSetupOperation & Partial<Pick<SetupOperationSnapshot, "kind">>;
+export interface RunEventServicePlanSuite {
+    engineId: ResultServicePlanSuite["engineId"];
+    files: ResultServicePlanSuite["files"];
+    name: ResultServicePlanSuite["name"];
+    profileId: ResultServicePlanSuite["profileId"];
+    testType: ResultServicePlanSuite["testType"];
+}
+export interface RunEventServicePlan {
+    service: string;
+    skipped: boolean;
+    suites: readonly RunEventServicePlanSuite[];
+}
+export interface RunEventTaskRef {
+    engineId: BatchableTask["engineId"];
+    file: BatchableTask["file"];
+    profileId: BatchableTask["profileId"];
+    service: string;
+    suite: BatchableTask["suiteName"];
+    testType: BatchableTask["testType"];
+}
+export interface RunDebugLineEvent {
+    line: string;
+    type: "run.debug";
+}
+export interface RunLocalServiceStartingEvent {
+    command: string;
+    runtimeLabel: string;
+    service: string;
+    type: "run.local_service_starting";
+}
+export interface RunOperationFinishedEvent {
+    operation: Readonly<OperationProgressInput>;
+    type: "run.operation_finished";
+}
+export interface RunOperationProgressEvent {
+    operation: Readonly<OperationProgressInput>;
+    type: "run.operation_progress";
+}
+export interface RunOperationStartedEvent {
+    operation: Readonly<OperationProgressInput>;
+    type: "run.operation_started";
+}
+export interface RunPhaseStartedEvent {
+    label: string;
+    type: "run.phase_started";
+}
+export interface RunRuntimeErrorEvent {
+    file: string;
+    message: string;
+    service: string;
+    type: "run.runtime_error";
+}
+export interface RunServicePlansEvent {
+    services: readonly RunEventServicePlan[];
+    type: "run.service_plans";
+}
+export interface RunServiceSkippedEvent {
+    reason: string;
+    service: string;
+    type: "run.service_skipped";
+}
+export interface RunSetupOperationFinishedEvent {
+    operation: Readonly<RunEventSetupOperation>;
+    type: "run.setup_finished";
+}
+export interface RunSummaryEvent {
+    durationMs: number;
+    results: readonly FinalizedServiceResult[];
+    runStatus: "failed" | "interrupted" | "passed";
+    type: "run.summary";
+}
+export interface RunTaskFinishedEvent extends RunEventTaskRef {
+    outcome: Readonly<RunEventTaskOutcome>;
+    type: "run.task_finished";
+}
+export interface RunTaskPlannedSkipEvent {
+    engineId: BatchableTask["engineId"];
+    file: BatchableTask["file"];
+    profileId: BatchableTask["profileId"];
+    reason: null | string;
+    service: string;
+    testType: BatchableTask["testType"];
+    type: "run.task_planned_skip";
+}
+export interface RunTaskStartedEvent extends RunEventTaskRef {
+    targetName: string;
+    type: "run.task_started";
+}
+export interface RunToolchainResolvedEvent {
+    runtimeLabel: string;
+    service: string;
+    summary: string;
+    type: "run.toolchain_resolved";
+}
+export interface RunTotalFilesEvent {
+    total: number;
+    type: "run.total_files";
+}
+export interface RunWarningEvent {
+    message: string;
+    type: "run.warning";
+}
+export type RunEvent = RunDebugLineEvent | RunLocalServiceStartingEvent | RunOperationFinishedEvent | RunOperationProgressEvent | RunOperationStartedEvent | RunPhaseStartedEvent | RunRuntimeErrorEvent | RunServicePlansEvent | RunServiceSkippedEvent | RunSetupOperationFinishedEvent | RunSummaryEvent | RunTaskFinishedEvent | RunTaskPlannedSkipEvent | RunTaskStartedEvent | RunToolchainResolvedEvent | RunTotalFilesEvent | RunWarningEvent;
+export type RunEventListener = (event: RunEvent) => void;
+type ReporterTask = Pick<BatchableTask, "engineId" | "file" | "profileId" | "serviceName" | "suiteName" | "testType">;
+type ReporterPlannedSkip = Pick<BatchableTask, "engineId" | "file" | "profileId" | "serviceName" | "testType"> & {
+    reason?: null | string;
+};
+export interface RunListenerReporter {
+    localServiceStarting(config: Readonly<ToolchainReportConfig>, command: string): void;
+    operationFinished(operation: Readonly<OperationProgressInput>): void;
+    operationProgress(operation: Readonly<OperationProgressInput>): void;
+    operationStarted(operation: Readonly<OperationProgressInput>): void;
+    readonly outputMode: "compact" | "debug";
+    phaseStarted(label: string): void;
+    plannedSkip(entry: Readonly<ReporterPlannedSkip>): void;
+    runSummary(results: readonly FinalizedServiceResult[], durationMs: number, runStatus: "failed" | "interrupted" | "passed"): void;
+    runtimeError(task: Readonly<ReporterTask>, message: string): void;
+    serviceSkipped(config: Readonly<ToolchainReportConfig>, reason: string): void;
+    setServicePlans(plans: readonly ResultServicePlan[]): void;
+    setTotalFileCount(count: number): void;
+    setupOperationFinished(operation: Readonly<RunEventSetupOperation> | null): void;
+    taskFinished(task: Readonly<ReporterTask>, outcome: Readonly<RunEventTaskOutcome>): void;
+    taskStarted(task: Readonly<ReporterTask>, targetConfig: Readonly<Pick<ReadyServiceConfig, "name">>): void;
+    toolchainResolved(config: Readonly<ToolchainReportConfig>, resolvedToolchain: Readonly<ResolvedNodeToolchain>): void;
+    warning(message: string): void;
+    writeDebugLine(line?: string): void;
+}
+export interface RunReporterFromListenerOptions {
+    debug?: boolean;
+}
+export declare function createRunReporterFromListener(listener: RunEventListener, { debug }?: Readonly<RunReporterFromListenerOptions>): RunListenerReporter;
+export {};

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

@@ -0,0 +1 @@
+export function createRunReporterFromListener(r,{debug:p=!1}={}){return{outputMode:p?"debug":"compact",setServicePlans(e){r({type:"run.service_plans",services:e.map(i=>({service:i.config.name,skipped:!!i.skipped,suites:i.suites.map(n=>({name:n.name,testType:n.testType,engineId:n.engineId,profileId:n.profileId,files:n.files}))}))})},setTotalFileCount(e){r({type:"run.total_files",total:e})},phaseStarted(e){r({type:"run.phase_started",label:e})},toolchainResolved(e,i){r({type:"run.toolchain_resolved",service:e.name,runtimeLabel:e.runtimeLabel||e.name,summary:i.summary})},setupOperationFinished(e){e&&r({type:"run.setup_finished",operation:e})},operationStarted(e){r({type:"run.operation_started",operation:e})},operationProgress(e){r({type:"run.operation_progress",operation:e})},operationFinished(e){r({type:"run.operation_finished",operation:e})},localServiceStarting(e,i){r({type:"run.local_service_starting",service:e.name,runtimeLabel:e.runtimeLabel||e.name,command:i})},serviceSkipped(e,i){r({type:"run.service_skipped",service:e.name,reason:i})},plannedSkip(e){r({type:"run.task_planned_skip",service:e.serviceName,file:e.file,testType:e.testType,engineId:e.engineId,profileId:e.profileId,reason:e.reason||null})},taskStarted(e,i){r({type:"run.task_started",service:e.serviceName,file:e.file,suite:e.suiteName,testType:e.testType,engineId:e.engineId,profileId:e.profileId,targetName:i.name})},taskFinished(e,i){r({type:"run.task_finished",service:e.serviceName,file:e.file,suite:e.suiteName,testType:e.testType,engineId:e.engineId,profileId:e.profileId,outcome:i})},runtimeError(e,i){r({type:"run.runtime_error",service:e.serviceName,file:e.file,message:i})},warning(e){r({type:"run.warning",message:e})},writeDebugLine(e=""){r({type:"run.debug",line:e})},runSummary(e,i,n){r({type:"run.summary",results:e,durationMs:i,runStatus:n})}}}

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

@@ -0,0 +1,52 @@
+import { type CommittedRunFinalization } from "../../evidence/finalization.js";
+import { writeRunArtifact, type NormalizedArtifactArchiveConfig, type ReportedRunArtifact, type ReportingExecution, type ReportingMetadata, type ReportingOperationTimingInput, type ReportingRecord, type ReportingServiceLogReference, type ReportingSetupLogReference, type ReportingSetupOperation, type ReportingSuiteSelector, type RunServiceResult } from "../../evidence/index.js";
+interface RunSelection {
+    fileNames: readonly string[];
+    planning?: null | ReportingRecord;
+    serviceFilter: null | string;
+    suiteSelectors: readonly ReportingSuiteSelector[];
+    typeValues: readonly string[];
+}
+interface RunLogRegistry {
+    listServiceLogs(): readonly ReportingServiceLogReference[];
+    listSetupLogs(): readonly ReportingSetupLogReference[];
+}
+interface SetupOperationRegistry {
+    listOperations(): readonly ReportingSetupOperation[];
+}
+interface OperationTimingRegistry {
+    listOperations(): readonly ReportingOperationTimingInput[];
+}
+export interface RunFinalizationReporter<Result extends RunServiceResult = RunServiceResult> {
+    runSummary?(results: readonly Result[], durationMs: number, runStatus: CommittedRunFinalization["artifactStatus"]): void;
+}
+export interface FinalizeRunArtifactsOptions<Result extends RunServiceResult = RunServiceResult> {
+    archiveConfig?: NormalizedArtifactArchiveConfig | null;
+    declaredEnvironmentKeys?: readonly string[];
+    execution: ReportingExecution;
+    finishedAt: number;
+    logRegistry: RunLogRegistry;
+    metadata: ReportingMetadata;
+    operationTimingRegistry?: OperationTimingRegistry | null;
+    productDir: string;
+    reporter: RunFinalizationReporter<Result> | null;
+    results: readonly Result[];
+    runId: null | string;
+    runInterruptReason?: null | string;
+    runStatus?: null | string;
+    runtimeInstanceCount: number;
+    runtimeStats: readonly unknown[];
+    selection: RunSelection;
+    setupRegistry: SetupOperationRegistry;
+    startedAt: number;
+    workerCount: number;
+    publishRunFinalization?: PublishRunFinalization;
+}
+export interface FinalizedRunArtifacts {
+    runArtifact: ReturnType<typeof writeRunArtifact<ReportedRunArtifact>>;
+    shouldFailArchiveCleanup: boolean;
+    shouldFailArchivePublication: boolean;
+}
+export type PublishRunFinalization = (artifactStatus: "failed" | "passed", publish: (finalization: Readonly<CommittedRunFinalization>) => FinalizedRunArtifacts) => Promise<FinalizedRunArtifacts>;
+export declare function finalizeRunArtifacts<Result extends RunServiceResult = RunServiceResult>({ productDir, runId, results, startedAt, finishedAt, execution, workerCount, runtimeInstanceCount, runtimeStats, selection, archiveConfig, declaredEnvironmentKeys, metadata, logRegistry, setupRegistry, operationTimingRegistry, reporter, runInterruptReason, runStatus, publishRunFinalization, }: FinalizeRunArtifactsOptions<Result>): Promise<FinalizedRunArtifacts>;
+export {};

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

@@ -0,0 +1 @@
+import{resolveCommittedRunFinalization as j}from"../../evidence/finalization.js";import{collectTestkitStorageInventory as k,writeRunArtifact as w}from"../../evidence/index.js";import{buildRunArtifact as x}from"../../evidence/reporting.js";import{summarizeDbBackend as C}from"./results.js";export async function finalizeRunArtifacts({productDir:t,runId:e,results:r,startedAt:a,finishedAt:i,execution:R,workerCount:b,runtimeInstanceCount:y,runtimeStats:v,selection:n,archiveConfig:c=null,declaredEnvironmentKeys:p=[],metadata:F,logRegistry:f,setupRegistry:S,operationTimingRegistry:h=null,reporter:z,runInterruptReason:d=null,runStatus:u=null,publishRunFinalization:m}){const s=x({productDir:t,runId:e,results:r,startedAt:a,finishedAt:i,execution:R,workerCount:b,runtimeInstanceCount:y,runtimeStats:v,typeValues:n.typeValues,suiteSelectors:n.suiteSelectors,fileNames:n.fileNames,serviceFilter:n.serviceFilter,planning:n.planning??null,archiveConfig:c,declaredEnvironmentKeys:p,metadata:F,summarizeDbBackend:C,serviceLogs:f.listServiceLogs(),setupLogs:f.listSetupLogs(),setupOperations:S.listOperations(),operationTimings:h?.listOperations()??[],runInterruptReason:d,runStatus:u}),O=V(s.storage),L=k(t);s.storage={...O??{},testkit:L};const A=u==="failed"||r.some(o=>o.failed||o.infraFailed)?"failed":"passed",g=o=>{T(s,o);const l=N({archiveConfig:c,declaredEnvironmentKeys:p,productDir:t,runArtifact:s});return z?.runSummary?.(r,i-a,l.runArtifact.run.status==="interrupted"?"interrupted":l.runArtifact.run.status==="failed"?"failed":"passed"),l};return m?await m(A,g):g(j(A,{interrupted:u==="interrupted",interruptReason:u==="interrupted"?d:null}))}function N({archiveConfig:t,declaredEnvironmentKeys:e,productDir:r,runArtifact:a}){const i=w(r,a,{archiveConfig:t,declaredEnvironmentKeys:e});return{runArtifact:i,shouldFailArchiveCleanup:i.archive.cleanup?.status==="failed",shouldFailArchivePublication:i.archive.publication.status==="failed"&&i.archive.publication.required===!0}}function T(t,e){if(t.run.status=e.artifactStatus,e.artifactStatus!=="interrupted"){delete t.run.interruptReason;return}t.run.interruptReason=e.interruptReason??"run interrupted"}function V(t){return q(t)?t:null}function q(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}

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

@@ -0,0 +1,3 @@
+import { type PlanningServiceConfig } from "./planning.js";
+import type { SuiteSelector } from "../../domain/suite-selection.js";
+export declare function ensureRequestedFilesMatch(configs: readonly PlanningServiceConfig[], typeValues: readonly string[], suiteSelectors: readonly SuiteSelector[], requestedFiles?: readonly string[]): void;

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

@@ -0,0 +1,3 @@
+import{collectSuites as s}from"./planning.js";import{findUnmatchedRequestedFiles as l}from"./selection.js";export function ensureRequestedFilesMatch(e,r,i,n=[]){if(n.length===0)return;const t=l(e,r,i,n,s,u);if(t.length!==0)throw new Error(`Requested file${t.length===1?"":"s"} did not match any selected suites:
+`+t.map(o=>`- ${o}`).join(`
+`))}function u(e){return e.split("\\").join("/")}

package/dist/app/run/runtime-failures.d.ts

@@ -0,0 +1,18 @@
+import type { NormalizedFailureDetail } from "./failure-details.js";
+import type { ProvisionedRun, RuntimeGraphIdentity } from "../../environment/run-environment.js";
+interface RuntimeFailureTask {
+    graphKey: string;
+    targetName?: string;
+}
+export type RuntimeManagerFailureGraph = RuntimeGraphIdentity;
+export interface BlockedRuntimeTask<Task extends RuntimeFailureTask> {
+    blockedByRuntime: true;
+    failureDetails: NormalizedFailureDetail[];
+    graph: RuntimeManagerFailureGraph;
+    infraFailed: true;
+    message: string;
+    reason: string;
+    task: Task;
+}
+export declare function drainRuntimeFailedTasks<Task extends RuntimeFailureTask>(queue: Task[], runtimeManager: Pick<ProvisionedRun, "getGraphFailure" | "getGraph">): BlockedRuntimeTask<Task>[];
+export {};

package/dist/app/run/runtime-failures.js

@@ -0,0 +1 @@
+export function drainRuntimeFailedTasks(t,r){const n=[];for(let a=t.length-1;a>=0;a-=1){const e=t[a],i=r.getGraphFailure(e.graphKey);i&&(t.splice(a,1),n.push({task:e,reason:`Not run because runtime graph failed to initialize: ${i}`,message:i,infraFailed:!0,blockedByRuntime:!0,failureDetails:[{count:1,kind:"runtime_graph_failed",key:"runtime_graph_failed",title:"Runtime graph failed",classification:"infra",message:`Runtime graph failed to initialize: ${i}`}],graph:r.getGraph(e.graphKey)||{key:e.graphKey,targetNames:e.targetName?[e.targetName]:[]}}))}return n.reverse()}

package/dist/app/run/runtime-fixtures.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeFixtureManifest } from "../../engines/contracts/fixture-manifest.js";
+export declare function buildRuntimeFixtureManifest(productDir: string, testFile: string): RuntimeFixtureManifest;

package/dist/app/run/runtime-fixtures.js

@@ -0,0 +1 @@
+import x from"crypto";import p from"fs";import o from"path";const g=["__testkit__/fixtures"],P=new Map([[".csv","text/csv"],[".gif","image/gif"],[".jpg","image/jpeg"],[".jpeg","image/jpeg"],[".json","application/json"],[".pdf","application/pdf"],[".png","image/png"],[".txt","text/plain"],[".webp","image/webp"],[".xls","application/vnd.ms-excel"],[".xlsx","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],[".zip","application/zip"]]);export function buildRuntimeFixtureManifest(t,s){const i=d(t,s),e=[],n=new Set;for(const r of i)if(p.existsSync(r.absolutePath))for(const a of u(r.absolutePath)){const c=l(o.relative(t,a));if(n.has(c))continue;n.add(c);const f=l(o.relative(r.absolutePath,a)),h=p.statSync(a),m=p.readFileSync(a);e.push({aliases:[...new Set([f,o.basename(a),c])],absolutePath:a,contentType:y(a),filename:o.basename(a),path:c,root:r.relativePath,rootRelativePath:f,sha256:x.createHash("sha256").update(m).digest("hex"),sizeBytes:h.size})}return e.sort((r,a)=>r.path.localeCompare(a.path)),{version:1,testFile:l(s),entries:e}}function d(t,s){const i=[],e=o.dirname(s);i.push({relativePath:l(o.join(e,"__fixtures__")),absolutePath:o.join(t,e,"__fixtures__")});for(const n of g)i.push({relativePath:n,absolutePath:o.join(t,n)});return i}function u(t){const s=[],i=p.readdirSync(t,{withFileTypes:!0}).sort((e,n)=>e.name.localeCompare(n.name));for(const e of i){const n=o.join(t,e.name);e.isDirectory()?s.push(...u(n)):e.isFile()&&s.push(n)}return s}function y(t){return P.get(o.extname(t).toLowerCase())??"application/octet-stream"}function l(t){return t.split(o.sep).join("/")}

package/dist/app/run/runtime-task-types.d.ts

@@ -0,0 +1,20 @@
+import type { ReadyServiceConfig } from "../../environment/runtime-service.js";
+import type { ArtifactTask, PersistedArtifactReference, ReportingFailureDetail, ReportingRecord } from "../../evidence/index.js";
+import type { TestOutcomeStatus } from "../../domain/test-outcomes.js";
+export interface RuntimeTask extends ArtifactTask {
+    file: string;
+}
+export interface RuntimeTaskReporter<Task extends RuntimeTask = RuntimeTask> {
+    taskStarted?(task: Readonly<Task>, targetConfig: Readonly<ReadyServiceConfig>): unknown;
+}
+export interface CompletedRuntimeTaskResult<FailureDetail = ReportingFailureDetail, CheckDetail = ReportingRecord> {
+    artifacts: PersistedArtifactReference[];
+    checkDetails: CheckDetail[];
+    durationMs: number;
+    error: null | string;
+    failureDetails: FailureDetail[];
+    finishedAt: number;
+    startedAt: number;
+    status: TestOutcomeStatus;
+    task: RuntimeTask;
+}

package/dist/app/run/runtime-task-types.js

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

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

@@ -0,0 +1,32 @@
+import type { EngineId, PublicTestType, RunnerProfileId } from "../../../domain/identifiers.js";
+import type { Timings } from "../../../evidence/index.js";
+export declare const DEFAULT_ESTIMATE_SOURCE = "default";
+export type TaskEstimateSource = "default" | "timings";
+export type TaskEstimateConfidence = "high" | "low" | "medium";
+export interface TaskEstimate {
+    confidence: TaskEstimateConfidence;
+    durationMs: number;
+    key: null | string;
+    runs: number;
+    source: TaskEstimateSource;
+}
+export interface EstimatedTaskInput {
+    engineId: EngineId;
+    profileId: RunnerProfileId;
+    testType: PublicTestType;
+    timingKey?: null | string;
+}
+export interface EstimateSuiteInput {
+    engineId: EngineId;
+    files?: readonly string[];
+    profileId: RunnerProfileId;
+    testType: PublicTestType;
+    weight?: number;
+}
+export type SchedulerTimings = Timings;
+export interface EstimateTaskOptions {
+    suite: EstimateSuiteInput;
+    task: EstimatedTaskInput;
+    timings?: null | SchedulerTimings;
+}
+export declare function estimateTask({ task, suite, timings }: EstimateTaskOptions): TaskEstimate;

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

@@ -0,0 +1 @@
+export const DEFAULT_ESTIMATE_SOURCE="default";export function estimateTask({task:n,suite:i,timings:e}){const t=s(e,n);return t||{durationMs:o(n,i),source:DEFAULT_ESTIMATE_SOURCE,confidence:"low",runs:0,key:null}}function o(n,i){const e=n.engineId==="playwright"?2e4:n.testType==="dal"?4e3:8e3,t=i.weight??1,r=Math.max(1,i.files?.length??1);return Math.max(1e3,Math.round(e*t/r))}function s(n,i){const e=i.timingKey;if(!e)return null;const t=n?.files[e],r=t?.durationMs||t?.avgDurationMs||0;if(r<=0)return null;const u=t?.runs??0;return{durationMs:Math.max(1,Math.round(r)),source:"timings",confidence:u>=3?"high":"medium",runs:u,key:e}}

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

@@ -0,0 +1,9 @@
+import type { EngineId, PublicTestType, RunnerProfileId } from "../../../domain/identifiers.js";
+export interface SchedulerTaskIdentityInput {
+    engineId: EngineId;
+    file: string;
+    profileId: RunnerProfileId;
+    serviceName: string;
+    testType: PublicTestType;
+}
+export declare function buildSchedulerTaskKey({ serviceName, testType, engineId, profileId, file, }: Readonly<SchedulerTaskIdentityInput>): string;

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

@@ -0,0 +1 @@
+import l from"path";import{resolveEngineProfile as n}from"../../../engines/catalog.js";export function buildSchedulerTaskKey({serviceName:c,testType:o,engineId:i,profileId:r,file:e}){const t=n(o,i);if(t.id!==r)throw new Error(`Task execution identity ${o}/${i}/${r} conflicts with catalog profile ${t.id}`);return[c,o,i,r,e.split(l.sep).join("/").replace(/^\.\/+/,"")].join("|")}

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

@@ -0,0 +1,124 @@
+import { type EstimateSuiteInput, type EstimatedTaskInput, type SchedulerTimings, type TaskEstimateConfidence, type TaskEstimateSource } from "./estimates.js";
+import { type TypedSuiteSelector } from "../../../domain/suite-selection.js";
+import type { ReportingRecord } from "../../../evidence/index.js";
+import { type RuntimeIsolationFileMetadata, type RuntimeIsolationPolicy, type RuntimeIsolationResolutionSuite, type RuntimeIsolationResolverConfig, type RuntimeIsolationResolverTestkitConfig } from "../../../config/loader/index.js";
+export declare const SCHEDULER_POLICY = "longest-estimated-duration-first";
+export declare const SCHEDULER_VERSION = 2;
+export interface SchedulerFileMetadata extends RuntimeIsolationFileMetadata {
+    locks?: readonly string[];
+}
+export interface SchedulerSuiteRequirement {
+    locks?: readonly string[];
+    selector: TypedSuiteSelector;
+}
+export interface SchedulerRequirements {
+    fileLocksByPath?: ReadonlyMap<string, readonly string[]>;
+    suites?: readonly SchedulerSuiteRequirement[];
+}
+export interface SchedulerServiceTestkitConfig extends RuntimeIsolationResolverTestkitConfig<RuntimeIsolationPolicy> {
+    fileMetadataByPath?: ReadonlyMap<string, SchedulerFileMetadata>;
+    requirements?: SchedulerRequirements;
+}
+export interface SchedulerServiceConfig extends RuntimeIsolationResolverConfig<RuntimeIsolationPolicy> {
+    name: string;
+    testkit: SchedulerServiceTestkitConfig;
+}
+export interface SchedulerSuiteInput extends EstimateSuiteInput, RuntimeIsolationResolutionSuite {
+    files: readonly string[];
+    name: string;
+    orderIndex: number;
+}
+export interface SchedulerServicePlanInput {
+    assignedGraphKey?: null | string;
+    config: SchedulerServiceConfig;
+    execution?: unknown;
+    runtimeConfigs?: readonly SchedulerServiceConfig[];
+    runtimeKey?: null | string;
+    runtimeNames?: readonly string[];
+    skipped?: boolean;
+    suites: readonly SchedulerSuiteInput[];
+}
+export interface SchedulerResourceReservation {
+    available: number;
+    capacity: number;
+    kind: string;
+    key: string;
+    perRuntime: number;
+    reserved: number;
+    resourceName: string;
+    scope: string;
+    services?: readonly string[];
+}
+export interface SchedulerRuntimeGraph {
+    key: string;
+    resourceReservations?: readonly SchedulerResourceReservation[];
+}
+export interface BuildScheduledQueueOptions {
+    timings?: null | SchedulerTimings;
+}
+export interface ScheduledTask extends EstimatedTaskInput {
+    estimateConfidence: TaskEstimateConfidence;
+    estimatedDurationMs: number;
+    estimateKey: null | string;
+    estimateRuns: number;
+    estimateSource: TaskEstimateSource;
+    file: string;
+    graphKey: string;
+    id: number;
+    locks: string[];
+    orderIndex: number;
+    resourceCost: number;
+    runtimeIsolation: RuntimeIsolationPolicy;
+    schedulerPolicy: typeof SCHEDULER_POLICY;
+    schedulerRank: number;
+    serviceName: string;
+    suiteKey: string;
+    suiteName: string;
+    targetName: string;
+    timingKey: string;
+}
+type RankedTaskInput = Omit<ScheduledTask, "schedulerPolicy" | "schedulerRank">;
+export interface PlanningTaskMetadata {
+    engineId: ScheduledTask["engineId"];
+    estimateConfidence: TaskEstimateConfidence;
+    estimatedDurationMs: number;
+    estimateRuns: number;
+    estimateSource: TaskEstimateSource;
+    file: string;
+    graphKey: string;
+    id: number;
+    profileId: ScheduledTask["profileId"];
+    rank: null | number;
+    runtimeIsolation: RuntimeIsolationPolicy;
+    service: string;
+    suite: string;
+    timingKey: string;
+    testType: ScheduledTask["testType"];
+}
+export interface PlanningResourceBudgetGraph {
+    graphKey: string;
+    perRuntime: number;
+    services: readonly string[];
+}
+export interface PlanningResourceBudget {
+    available: number;
+    capacity: number;
+    graphs: PlanningResourceBudgetGraph[];
+    kind: string;
+    key: string;
+    reserved: number;
+    resourceName: string;
+    scope: string;
+}
+export interface RunPlanningMetadata extends ReportingRecord {
+    resourceBudgets: PlanningResourceBudget[];
+    scheduler: {
+        policy: typeof SCHEDULER_POLICY;
+        version: typeof SCHEDULER_VERSION;
+    };
+    tasks: PlanningTaskMetadata[];
+}
+export declare function buildScheduledQueue(servicePlans: readonly SchedulerServicePlanInput[], graphs: readonly SchedulerRuntimeGraph[], { timings }?: BuildScheduledQueueOptions): ScheduledTask[];
+export declare function buildRunPlanningMetadata(queue: null | readonly ScheduledTask[] | undefined, graphs?: null | readonly SchedulerRuntimeGraph[]): RunPlanningMetadata;
+export declare function compareScheduledTasks(a: RankedTaskInput, b: RankedTaskInput): number;
+export {};

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

@@ -0,0 +1 @@
+import{buildSchedulerTaskKey as f}from"./identity.js";import{estimateTask as y}from"./estimates.js";import{matchesSuiteSelectors as g}from"../../../domain/suite-selection.js";import{resolveRuntimeIsolationPolicy as h}from"../../../config/loader/index.js";export const SCHEDULER_POLICY="longest-estimated-duration-first",SCHEDULER_VERSION=2;const k=String;export function buildScheduledQueue(i,s,{timings:e}={}){const t=new Map;for(const o of s)t.set(o.key,o);const r=[];let c=1;for(const o of i){if(o.skipped)continue;const a=t.get(o.assignedGraphKey);if(!a)throw new Error(`Assigned graph "${String(o.assignedGraphKey)}" not found for ${o.config.name}`);for(const n of o.suites)for(const l of n.files){const d={id:c,graphKey:a.key,targetName:o.config.name,serviceName:o.config.name,suiteKey:`${n.testType}:${n.name}`,suiteName:n.name,testType:n.testType,engineId:n.engineId,profileId:n.profileId,orderIndex:n.orderIndex,file:l,locks:I(o.config,n,l),runtimeIsolation:h(o.config,n,l),resourceCost:1},p=f(d),m={...d,timingKey:p},u=y({task:m,suite:n,timings:e});r.push({...m,estimatedDurationMs:u.durationMs,estimateSource:u.source,estimateConfidence:u.confidence,estimateRuns:u.runs,estimateKey:u.key}),c+=1}}return r.sort(compareScheduledTasks).map((o,a)=>({...o,schedulerRank:a+1,schedulerPolicy:SCHEDULER_POLICY}))}export function buildRunPlanningMetadata(i,s=[]){return{scheduler:{policy:SCHEDULER_POLICY,version:SCHEDULER_VERSION},resourceBudgets:v(s),tasks:(i||[]).map(e=>({rank:e.schedulerRank||null,id:e.id,service:e.serviceName,suite:e.suiteName,testType:e.testType,engineId:e.engineId,profileId:e.profileId,file:e.file,graphKey:e.graphKey,runtimeIsolation:e.runtimeIsolation,estimatedDurationMs:e.estimatedDurationMs,estimateSource:e.estimateSource,estimateConfidence:e.estimateConfidence,estimateRuns:e.estimateRuns||0,timingKey:e.timingKey}))}}function v(i){const s=new Map;for(const e of i||[])for(const t of e.resourceReservations||[]){const r=s.get(t.key)||{key:t.key,kind:t.kind,scope:t.scope,resourceName:t.resourceName,capacity:t.capacity,reserved:t.reserved,available:t.available,graphs:[]};r.capacity=Math.max(r.capacity||0,t.capacity||0),r.reserved=Math.max(r.reserved||0,t.reserved||0),r.available=Math.max(0,r.capacity-r.reserved),r.graphs.push({graphKey:e.key,services:t.services||[],perRuntime:t.perRuntime}),s.set(t.key,r)}return[...s.values()].sort((e,t)=>e.key.localeCompare(t.key))}export function compareScheduledTasks(i,s){return s.estimatedDurationMs-i.estimatedDurationMs||i.serviceName.localeCompare(s.serviceName)||i.suiteKey.localeCompare(s.suiteKey)||i.file.localeCompare(s.file)}function I(i,s,e){const t=new Set;s.testType==="dal"&&t.add(`database:${i.name}`);const r=i.testkit.requirements?.suites||[];for(const a of r)if(g(s.testType,s.name,[a.selector]))for(const n of a.locks||[])t.add(n);const c=k(e).split("\\").join("/"),o=i.testkit.fileMetadataByPath?.get(c)||null;for(const a of i.testkit.requirements?.fileLocksByPath?.get(c)||[])t.add(a);for(const a of o?.locks||[])t.add(a);return[...t].sort()}