@gfdelarue/testkit 0.4.5 → 0.5.0

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

@@ -1,144 +0,0 @@
-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-finalization.d.ts

@@ -1,56 +0,0 @@
-import { type CommittedRunFinalization } from "../../evidence/finalization.js";
-import { writeRunArtifact, type NormalizedArtifactArchiveConfig, type ReportedRunArtifact, type ReportingEnvironmentService, 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 RunEnvironmentRecord {
-    listServices(): readonly ReportingEnvironmentService[];
-}
-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[];
-    environmentRecord: RunEnvironmentRecord;
-    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, environmentRecord, logRegistry, setupRegistry, operationTimingRegistry, reporter, runInterruptReason, runStatus, publishRunFinalization, }: FinalizeRunArtifactsOptions<Result>): Promise<FinalizedRunArtifacts>;
-export {};

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

@@ -1,3 +0,0 @@
-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/runtime-failures.d.ts

@@ -1,18 +0,0 @@
-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-fixtures.d.ts

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

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

@@ -1,20 +0,0 @@
-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<Pick<ReadyServiceConfig, "name">>): 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/scheduler/estimates.d.ts

@@ -1,32 +0,0 @@
-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/identity.d.ts

@@ -1,9 +0,0 @@
-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/index.d.ts

@@ -1,124 +0,0 @@
-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/locks.d.ts

@@ -1,6 +0,0 @@
-export interface TaskLocks {
-    acquire(lockNames: readonly string[], owner: string): void;
-    available(lockNames: readonly string[]): boolean;
-    release(lockNames: readonly string[], owner: string): void;
-}
-export declare function createTaskLocks(): TaskLocks;

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

@@ -1,20 +0,0 @@
-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/selection.d.ts

@@ -1,9 +0,0 @@
-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[];

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

@@ -1,13 +0,0 @@
-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-protocol.d.ts

@@ -1,85 +0,0 @@
-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-worker.d.ts

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

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

@@ -1,48 +0,0 @@
-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/task-batches.d.ts

@@ -1,23 +0,0 @@
-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-leases.d.ts

@@ -1,15 +0,0 @@
-import type { EnvironmentLease } from "./environment.js";
-export interface TaskLease extends EnvironmentLease {
-    readonly engineCacheDirectory: string;
-    readonly engineWorkspaceDirectory: string;
-}
-export interface TaskLeases {
-    allocate(task: Readonly<{
-        id: number;
-    }>): TaskLease;
-    close(): void;
-    create(lease: Readonly<TaskLease>): void;
-    remove(lease: Readonly<TaskLease>): void;
-}
-export declare function taskExecutionRoot(productDir: string): string;
-export declare function createTaskLeases(productDir: string): TaskLeases;