@gfdelarue/testkit 0.4.5 → 0.5.0

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

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

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

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

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

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

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

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

package/dist/app/run/engine-failure-stack.d.ts

@@ -1 +0,0 @@
-export declare function formatEngineInvocationStack(error: unknown): string | undefined;

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

@@ -1,30 +0,0 @@
-import { type EngineExecutionInputs, type EngineJsonObject } from "../../engines/api/index.js";
-import { type EngineId } from "../../domain/identifiers.js";
-import type { ScheduledTask } from "./scheduler/index.js";
-import type { Environment } from "./environment.js";
-import type { TaskLease } from "./task-leases.js";
-export interface ExecutionRequest {
-    readonly engineConfigurations: Readonly<Partial<Record<EngineId, EngineJsonObject>>>;
-    readonly fileTimeoutSeconds: number;
-    readonly productDir: string;
-}
-export interface EngineInputPreparationContext {
-    readonly environment: Environment;
-    readonly lease: TaskLease;
-    readonly nativeConfigDirectory: string;
-    readonly request: ExecutionRequest;
-    readonly runtimeEnvironment: Readonly<Record<string, string>>;
-    readonly task: ScheduledTask;
-}
-export interface EngineOrchestrationIntegration {
-    readonly engineId: EngineId;
-    resolveConfiguration(context: Readonly<EngineInputPreparationContext>): EngineExecutionInputs["configuration"];
-    resolveSupportModules(context: Readonly<EngineInputPreparationContext>): EngineExecutionInputs["supportModules"];
-}
-export interface EngineOrchestrationRegistry {
-    readonly integrations: readonly EngineOrchestrationIntegration[];
-    resolve(engineId: EngineId): EngineOrchestrationIntegration;
-}
-export declare const BUILT_IN_ENGINE_ORCHESTRATION: EngineOrchestrationRegistry;
-export declare function defaultEnvironmentValues(environment: Readonly<Environment>): Readonly<Record<string, string>>;
-export declare function engineInputEnvironment(context: Readonly<EngineInputPreparationContext>): Readonly<Record<string, string>>;

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

@@ -1,33 +0,0 @@
-import type { EngineJsonObject } from "../../engines/api/index.js";
-import type { ScheduledTask } from "./scheduler/index.js";
-import type { TaskBatch } from "./task-batches.js";
-export interface Environment {
-    readonly baseUrl: null | string;
-    readonly databaseUrl: null | string;
-    readonly endpoints: Readonly<Record<string, string>>;
-    readonly env: Readonly<Record<string, string>>;
-    readonly ui: EngineJsonObject | null;
-}
-export interface EnvironmentLease {
-    readonly directory: string;
-    readonly id: string;
-}
-export type EnvironmentTask = ScheduledTask | TaskBatch<ScheduledTask>;
-export interface EnvironmentGraph {
-    readonly key: string;
-    readonly targetNames: readonly string[];
-}
-export interface AcquiredEnvironment {
-    readonly environment: Environment;
-    readonly nativeConfigDirectory: string;
-    release(options: Readonly<{
-        invalidate: boolean;
-    }>): Promise<void>;
-}
-export interface EnvironmentEntry {
-    acquire(task: Readonly<EnvironmentTask>, lease: Readonly<EnvironmentLease>): Promise<AcquiredEnvironment>;
-    canAcquire(task: Readonly<ScheduledTask>): boolean;
-    getGraph(graphKey: string): EnvironmentGraph | null;
-    getGraphFailure(graphKey: string): null | string;
-    markGraphFailed(graphKey: string, message: string): void;
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,161 +0,0 @@
-import type { RuntimeIsolationPolicy } from "../../domain/runtime-isolation-contract.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 {};