@gfdelarue/testkit 0.4.5 → 0.5.0

package/dist/database/schema-source.d.ts

@@ -1,96 +0,0 @@
-import type { Hash } from "crypto";
-import type { NormalizedSourceSchemaConfig } from "../config/loader/index.js";
-import { type RepoState } from "../repo/state.js";
-import { type DatabaseTemplateServiceConfig, type DatabaseTemplateStepOptions } from "./template-steps.js";
-import { type SourceSchemaDumpResolution } from "./source-url.js";
-type UnknownRecord = Record<string, unknown>;
-type SourceSchemaUnavailableMode = "fail" | "warn-cache";
-type SourceSchemaTestkitConfig = DatabaseTemplateServiceConfig["testkit"] & {
-    fingerprints?: unknown;
-};
-export interface SourceSchemaCacheConfig {
-    name: string;
-    productDir: string;
-    testkit?: Pick<SourceSchemaTestkitConfig, "fingerprints">;
-}
-export interface SourceSchemaServiceConfig extends DatabaseTemplateServiceConfig {
-    testkit: SourceSchemaTestkitConfig;
-}
-export interface SourceSchemaCacheLocationOptions {
-    repoState?: RepoState | null;
-}
-export interface SourceSchemaCacheLocation {
-    cacheDir: string;
-    cacheKey: string;
-    cacheKind: string;
-    cachePath: string;
-    indexPath: string;
-    metadataPath: string;
-    repoState: RepoState;
-    rootDir: string;
-}
-type SourceSchemaOperationOptions = Pick<DatabaseTemplateStepOptions, "ownedContainer" | "parentOperation" | "reporter" | "setupRegistry">;
-export interface SourceSchemaOptions extends SourceSchemaCacheLocationOptions, SourceSchemaOperationOptions {
-    env?: NodeJS.ProcessEnv | null;
-    signal?: AbortSignal;
-    skipSchemaSourceVerify?: boolean;
-}
-interface SourceSchemaVerificationOptions extends SourceSchemaOptions {
-    resolveLocalSnapshotImage?: () => Promise<string>;
-}
-export interface InactiveSourceSchemaState {
-    active: false;
-    cachePath?: string;
-}
-export interface ActiveSourceSchemaState extends SourceSchemaCacheLocation {
-    active: true;
-    cacheExists: boolean;
-    ci: boolean;
-    envName: string | null;
-    refreshed: boolean;
-    refreshError?: unknown;
-    refreshInfo?: SourceSchemaRefreshInfo;
-    sourceSchema: NormalizedSourceSchemaConfig;
-    sourceUrl: string | null;
-    unavailableMode: SourceSchemaUnavailableMode;
-}
-export interface RefreshedSourceSchemaState extends ActiveSourceSchemaState {
-    cacheExists: true;
-    refreshed: true;
-    refreshInfo: SourceSchemaRefreshInfo;
-}
-export type SourceSchemaState = ActiveSourceSchemaState | InactiveSourceSchemaState;
-interface SourceSchemaMetadata extends UnknownRecord {
-    refreshedAt: string;
-    sourceUrl?: SourceSchemaDumpResolution["metadata"];
-}
-export interface SourceSchemaRefreshInfo {
-    metadata: SourceSchemaMetadata;
-    reusedExistingRefresh: boolean;
-    waitedForLock: boolean;
-}
-export interface SourceSchemaMismatchDiagnostics {
-    diffPath: string;
-    localPath: string;
-    metaPath: string;
-    sourceCachePath: string;
-    sourcePath: string;
-}
-export type SourceSchemaVerification = {
-    status: "disabled" | "matched" | "skipped";
-} | {
-    diagnostics: SourceSchemaMismatchDiagnostics;
-    status: "mismatch";
-};
-export declare function getSourceSchemaRootDir(config: Readonly<SourceSchemaCacheConfig>): string;
-export declare function getSourceSchemaCachePath(config: Readonly<SourceSchemaCacheConfig>, options?: Readonly<SourceSchemaCacheLocationOptions>): Promise<string>;
-export declare function resolveSourceSchemaCacheLocation(config: Readonly<SourceSchemaCacheConfig>, options?: Readonly<SourceSchemaCacheLocationOptions>): Promise<SourceSchemaCacheLocation>;
-export declare function resolveSourceSchemaState(config: Readonly<SourceSchemaServiceConfig>, options?: Readonly<SourceSchemaOptions>): Promise<SourceSchemaState>;
-export declare function prepareSourceSchemaCache(config: Readonly<SourceSchemaServiceConfig>, options?: Readonly<SourceSchemaOptions>): Promise<SourceSchemaState>;
-export declare function forceRefreshSourceSchemaCache(config: Readonly<SourceSchemaServiceConfig>, previousState: Readonly<SourceSchemaState> | null, options?: Readonly<SourceSchemaOptions>): Promise<RefreshedSourceSchemaState>;
-export declare function applySourceSchemaCache(config: Readonly<SourceSchemaServiceConfig>, databaseUrl: string, state: Readonly<SourceSchemaState> | null | undefined, options?: Readonly<SourceSchemaOptions>): Promise<boolean>;
-export declare function verifyLocalSchemaMatchesSource(config: Readonly<SourceSchemaServiceConfig>, databaseUrl: string, state: Readonly<SourceSchemaState> | null | undefined, options?: Readonly<SourceSchemaVerificationOptions>): Promise<SourceSchemaVerification>;
-export declare function createSourceSchemaMismatchError(config: Readonly<SourceSchemaServiceConfig>, state: Readonly<ActiveSourceSchemaState>, verification: Readonly<SourceSchemaVerification> | null | undefined): Error;
-export declare function appendSourceSchemaCacheToHash(hash: Pick<Hash, "update">, config: Readonly<SourceSchemaServiceConfig>, state?: Readonly<SourceSchemaState> | null): Promise<void>;
-export declare function buildUnifiedDiffText(leftText: unknown, rightText: unknown, leftLabel?: string, rightLabel?: string): string;
-export {};

package/dist/database/source-refresh-lock.d.ts

@@ -1,8 +0,0 @@
-import { type ProcessLockOptions } from "../process/locks.js";
-export interface SourceSchemaRefreshLockContext {
-    requestedAt: number;
-    waited: boolean;
-}
-export type SourceSchemaRefreshLockOptions = Pick<ProcessLockOptions, "retryIntervalMs" | "signal">;
-export declare function withSourceSchemaRefreshLock<Result>(lockPath: string, task: (context: Readonly<SourceSchemaRefreshLockContext>) => Promise<Result> | Result, options?: Readonly<SourceSchemaRefreshLockOptions>): Promise<Result>;
-export declare function getSourceSchemaRefreshLockPath(cachePath: string): string;

package/dist/database/source-url.d.ts

@@ -1,21 +0,0 @@
-export type DatabaseHostKind = "neon-pooler" | "neon-direct" | "unsupported-pooler" | "unknown-direct";
-export interface DatabaseHostClassification {
-    kind: DatabaseHostKind;
-    host: string;
-}
-export interface SourceSchemaDumpResolution {
-    originalUrl: string;
-    dumpUrl: string;
-    rewritten: boolean;
-    notice: string | null;
-    metadata: {
-        originalHost: string;
-        originalClassification: DatabaseHostKind;
-        resolvedHost: string;
-        resolvedClassification: DatabaseHostKind;
-        rewritten: boolean;
-    };
-}
-export declare function resolveSourceSchemaDumpUrl(databaseUrl: string): SourceSchemaDumpResolution;
-export declare function classifyDatabaseHost(hostname: string): DatabaseHostClassification;
-export declare function assertPgDumpArgsAreSourceSafe(args: readonly string[]): void;

package/dist/database/state-files.d.ts

@@ -1,13 +0,0 @@
-import type { DatabaseConnection } from "./naming.js";
-export interface LocalPostgresState extends DatabaseConnection {
-    containerId: string;
-    containerName: string;
-    containerPort: number;
-    image: string;
-    maxConnections: number;
-    volumeMountPath?: string | null;
-    volumeName?: string | null;
-}
-export declare function writeLocalInfraState(infraDir: string, infra: Readonly<LocalPostgresState>): void;
-export declare function writeCacheState(cacheDir: string, infra: Readonly<LocalPostgresState>, templateDbName: string, fingerprint: string): void;
-export declare function writeStateValue(filePath: string, value: unknown): void;

package/dist/database/state.d.ts

@@ -1,26 +0,0 @@
-export type OwnedDatabaseStateKind = "cache" | "infra" | "legacy" | "runtime";
-export interface OwnedDatabaseStateDir {
-    readonly dir: string;
-    readonly kind: OwnedDatabaseStateKind;
-}
-export interface DatabaseInfo {
-    database: string;
-    host: string;
-    password: string;
-    port: number;
-    ssl: boolean;
-    sslMode: string;
-    url: string;
-    user: string;
-}
-export declare function getLocalInfraDir(productDir: string): string;
-export declare function getLocalLocksDir(productDir: string): string;
-export declare function getLocalServiceCacheDir(productDir: string, serviceName: string): string;
-export declare function listOwnedDatabaseStateDirs(productDir: string): OwnedDatabaseStateDir[];
-export declare function hasRemainingLocalArtifacts(productDir: string): boolean;
-export declare function readOwnedStateValues(productDir: string, fileNames: readonly string[]): Set<string>;
-export declare function readStateValue(filePath: string): string | null;
-export declare function readDatabaseUrl(stateDir: string): string | null;
-export declare function readDatabaseInfo(stateDir: string): DatabaseInfo | null;
-export declare function resolveContainedDatabaseStateDirectory(productDir: string, ...segments: readonly string[]): string;
-export declare function requireContainedDatabaseStateDirectory(productDir: string, candidateDirectory: string, label?: string): string;

package/dist/database/template-steps.d.ts

@@ -1,39 +0,0 @@
-import type { NormalizedDatabaseConfig, NormalizedDatabaseTemplateConfig } from "../config/loader/index.js";
-import { type ConfiguredStepReporter, type ConfiguredStepServiceConfig, type ExecutionEnvironmentConfig, type ExecutionEnvironmentTestkitConfig } from "../steps/index.js";
-import { type RunConfiguredStepsOptions } from "./configured-steps.js";
-import { type StepLogRecord } from "../evidence/setup-progress.js";
-import type { NormalizedConfiguredStep } from "../steps/configured-steps.js";
-import type { OwnedPostgresContainerRoute } from "../domain/postgres-route.js";
-export type DatabaseTemplateStageName = "migrate" | "seed" | "verify";
-type DatabaseTemplateTestkitConfig = ExecutionEnvironmentTestkitConfig & ConfiguredStepServiceConfig["testkit"] & {
-    database?: Partial<Pick<NormalizedDatabaseConfig, "sourceSchema" | "template">> | null;
-};
-export interface DatabaseTemplateServiceConfig extends ExecutionEnvironmentConfig, ConfiguredStepServiceConfig {
-    runtimeLabel?: string | null;
-    testkit: DatabaseTemplateTestkitConfig;
-}
-export type DatabaseTemplateStepOptions = Pick<RunConfiguredStepsOptions, "afterStep" | "ownedContainer" | "parentOperation" | "reporter" | "setupRegistry" | "signal" | "stepTimeoutMs">;
-export interface PostgresDumpOptions {
-    env?: NodeJS.ProcessEnv | null;
-    image?: string | null;
-    logRecord?: StepLogRecord | null;
-    ownedContainer?: OwnedPostgresContainerRoute | null;
-    pgApplicationName?: string | null;
-    reporter?: ConfiguredStepReporter | null;
-    signal?: AbortSignal;
-}
-export declare function runTemplateStage(config: Readonly<DatabaseTemplateServiceConfig>, stageName: DatabaseTemplateStageName, databaseUrl: string, options?: Readonly<DatabaseTemplateStepOptions>): Promise<void>;
-export declare function runTemplateStep(config: Readonly<DatabaseTemplateServiceConfig>, stageName: string, step: Readonly<NormalizedConfiguredStep>, stepIndex: number, databaseUrl: string, options?: Readonly<DatabaseTemplateStepOptions>): Promise<void>;
-export declare function collectTemplateInputs(productDir: string, template?: Partial<Readonly<NormalizedDatabaseTemplateConfig>>): string[];
-export declare function captureTemplateSnapshotText(config: Readonly<DatabaseTemplateServiceConfig>, databaseUrl: string, options?: Readonly<PostgresDumpOptions>): Promise<string>;
-export declare function dumpPostgresSchemaToFile(config: Readonly<DatabaseTemplateServiceConfig>, outputPath: string, databaseUrl: string, options?: Readonly<PostgresDumpOptions>): Promise<void>;
-export declare function pgDumpArgs(): string[];
-export declare function resolvePgDumpClientImage(config: Readonly<DatabaseTemplateServiceConfig>, databaseUrl: string, options?: Readonly<PostgresDumpOptions>): Promise<string>;
-/** Retain only the detected version of one owned server during a template rebuild. */
-export declare function createOwnedPgDumpClientImageResolver(config: Readonly<DatabaseTemplateServiceConfig>, databaseUrl: string, options: Readonly<PostgresDumpOptions & {
-    ownedContainer: OwnedPostgresContainerRoute;
-}>): () => Promise<string>;
-export declare function postgresClientImageForServerVersion(serverVersionNum: unknown): string;
-export declare function sanitizeSnapshotFile(filePath: string): void;
-export declare function sanitizeSnapshotText(dump: unknown): string;
-export {};

package/dist/domain/file-timeout.d.ts

@@ -1,25 +0,0 @@
-export declare const DEFAULT_FILE_TIMEOUT_SECONDS = 60;
-export declare const FILE_TIMEOUT_INTERVAL_SECONDS = 0.25;
-export declare const FILE_TIMEOUT_COOPERATIVE_ERROR_RESERVE_MAX_MS = 2000;
-export declare const FILE_TIMEOUT_COOPERATIVE_ERROR_RESERVE_MIN_MS = 250;
-export declare const FILE_TIMEOUT_COOPERATIVE_ERROR_RESERVE_RATIO = 0.2;
-export declare const FILE_TIMEOUT_SUBPROCESS_EXIT_GRACE_MS = 1000;
-export declare const INTERNAL_FILE_TIMEOUT_SECONDS_ENV = "TESTKIT_INTERNAL_FILE_TIMEOUT_SECONDS";
-export declare const INTERNAL_FILE_DEADLINE_MS_ENV = "TESTKIT_INTERNAL_FILE_DEADLINE_MS";
-export interface FileTimeoutBudget {
-    deadlineMs: number;
-    fileTimeoutSeconds: number;
-}
-export interface FileTimeoutEnv {
-    [INTERNAL_FILE_DEADLINE_MS_ENV]: string;
-    [INTERNAL_FILE_TIMEOUT_SECONDS_ENV]: string;
-}
-export declare function parseFileTimeoutOption(value: unknown): number;
-export declare function normalizeFileTimeoutSeconds(value: unknown, label?: string): number;
-export declare function normalizeWaitIntervalSeconds(value?: unknown): number;
-export declare function readFileTimeoutBudget(env: unknown): FileTimeoutBudget;
-export declare function remainingFileTimeoutMs(budget: FileTimeoutBudget, nowMs?: number): number;
-export declare function remainingFileTimeoutSeconds(budget: FileTimeoutBudget, nowMs?: number): number;
-export declare function remainingCooperativeFileTimeoutMs(budget: FileTimeoutBudget, nowMs?: number): number;
-export declare function cooperativeFileTimeoutErrorReserveMs(fileTimeoutSeconds: number): number;
-export declare function formatWaitForTimeoutError(description: unknown, fileTimeoutSeconds: number): string;

package/dist/domain/identifiers.d.ts

@@ -1,9 +0,0 @@
-export declare const ENGINE_IDS: readonly ["k6", "node-vitest", "playwright"];
-export type EngineId = (typeof ENGINE_IDS)[number];
-export declare const PUBLIC_TEST_TYPES: readonly ["ui", "e2e", "int", "contract", "data", "dal", "load"];
-export type PublicTestType = (typeof PUBLIC_TEST_TYPES)[number];
-export declare const RUNNER_PROFILE_IDS: readonly ["k6-http", "k6-dal", "node-vitest-data", "node-vitest-contract", "playwright-ui"];
-export type RunnerProfileId = (typeof RUNNER_PROFILE_IDS)[number];
-export declare function isEngineId(value: unknown): value is EngineId;
-export declare function isPublicTestType(value: unknown): value is PublicTestType;
-export declare function isRunnerProfileId(value: unknown): value is RunnerProfileId;

package/dist/domain/operation-display.d.ts

@@ -1,10 +0,0 @@
-export type OperationStatusKind = "failed" | "passed" | "running" | "skipped" | "unknown";
-export interface OperationStatusLabelOptions {
-    runningLabel?: string;
-}
-export declare function normalizeOperationStatus(status: unknown): string;
-export declare function operationStatusKind(status: unknown): OperationStatusKind;
-export declare function operationStatusLabel(status: unknown, { runningLabel }?: Readonly<OperationStatusLabelOptions>): string;
-export declare function isNeutralOperationStatus(status: unknown): boolean;
-export declare function isSuccessfulOperationStatus(status: unknown): boolean;
-export declare function formatOperationSummary(operation?: unknown): string;

package/dist/domain/operation-reason.d.ts

@@ -1,5 +0,0 @@
-export declare const MAX_OPERATION_REASON_LENGTH = 240;
-export interface OperationReasonOptions {
-    maxLength?: number;
-}
-export declare function normalizeOperationReason(value: unknown, fallback?: unknown, options?: OperationReasonOptions): string;

package/dist/domain/postgres-route.d.ts

@@ -1,4 +0,0 @@
-export interface OwnedPostgresContainerRoute {
-    containerId: string;
-    containerPort?: number | null;
-}

package/dist/domain/runtime-identity.d.ts

@@ -1 +0,0 @@
-export declare function buildRuntimeIds(count: number): string[];

package/dist/domain/runtime-isolation-contract.d.ts

@@ -1,5 +0,0 @@
-export declare const DEFAULT_RUNTIME_ISOLATION_POLICY: "shared";
-export declare const RUNTIME_ISOLATION_POLICIES: readonly ["shared", "resetBefore", "resetAfter", "exclusive"];
-export type RuntimeIsolationPolicy = (typeof RUNTIME_ISOLATION_POLICIES)[number];
-export declare function isRuntimeIsolationPolicy(value: unknown): value is RuntimeIsolationPolicy;
-export declare function normalizeRuntimeIsolationPolicy(value: unknown, label: string): RuntimeIsolationPolicy;

package/dist/domain/service-name.d.ts

@@ -1,2 +0,0 @@
-export declare function requireServiceName(value: unknown, label?: string): string;
-export declare function assertPortableServiceNameSet(serviceNames: readonly string[]): void;

package/dist/domain/suite-selection.d.ts

@@ -1,20 +0,0 @@
-import { type PublicTestType } from "./identifiers.js";
-export interface PlainSuiteSelector {
-    kind: "plain";
-    name: string;
-    raw: string;
-}
-export interface TypedSuiteSelector {
-    kind: "typed";
-    name: string;
-    raw: string;
-    testType: PublicTestType;
-}
-export type SuiteSelector = PlainSuiteSelector | TypedSuiteSelector;
-export declare function normalizeTypeValues(values?: readonly unknown[]): string[];
-export declare function isAllTypeSelection(typeValues?: readonly string[]): boolean;
-export declare function parseSuiteSelectors(values?: readonly unknown[]): SuiteSelector[];
-export declare function matchesSelectedTypes(selectionType: string, typeValues: readonly string[]): boolean;
-export declare function matchesSuiteSelectors(selectionType: null | string | undefined, suiteName: string, selectors?: null | readonly SuiteSelector[]): boolean;
-export declare function parseTypeOption(values: unknown, positionalType?: null | string): string[];
-export declare function parseSuiteOption(values: unknown): SuiteSelector[];

package/dist/domain/test-outcomes.d.ts

@@ -1,2 +0,0 @@
-export declare const TEST_OUTCOME_STATUS_ORDER: readonly ["passed", "failed", "skipped", "not_run", "cancelled", "interrupted"];
-export type TestOutcomeStatus = (typeof TEST_OUTCOME_STATUS_ORDER)[number];

package/dist/domain/test-types.d.ts

@@ -1,16 +0,0 @@
-import { type PublicTestType } from "./identifiers.js";
-export declare const TEST_TYPE_ORDER: readonly string[];
-declare const RUN_TYPE_VALUES: readonly ["ui", "e2e", "int", "contract", "data", "dal", "load", "all"];
-export type RunType = (typeof RUN_TYPE_VALUES)[number];
-export declare const RUN_TYPE_ORDER: readonly string[];
-export declare const RUN_TYPES: ReadonlySet<string>;
-export interface PublicTestTypeListOptions {
-    includeAll?: boolean;
-}
-export declare function isPublicTestType(value: unknown): value is PublicTestType;
-export declare function isRunType(value: unknown): value is RunType;
-export declare function formatPublicTestType(value: unknown): string;
-export declare function publicTestTypeList({ includeAll }?: PublicTestTypeListOptions): RunType[];
-export declare function publicTestTypeListText(options?: PublicTestTypeListOptions): string;
-export declare function formatTestTypeLabel(testType: PublicTestType): string;
-export {};

package/dist/engines/adapters/evidence-files.d.ts

@@ -1,32 +0,0 @@
-import { type BigIntStats } from "node:fs";
-import fs from "node:fs/promises";
-import type { EngineArtifactEvidence } from "../api/index.js";
-export interface EvidenceFileAccess {
-    lstat(filePath: string): Promise<BigIntStats>;
-    openReadOnly(filePath: string): Promise<fs.FileHandle>;
-    readonly platform: NodeJS.Platform;
-    readChunk(handle: fs.FileHandle, buffer: Buffer): Promise<number>;
-    statHandle(handle: fs.FileHandle): Promise<BigIntStats>;
-}
-export declare const evidenceFileAccess: EvidenceFileAccess;
-export interface EvidenceFileIdentity {
-    readonly sha256: string;
-    readonly sizeBytes: number;
-}
-export interface StableEvidenceFile extends EvidenceFileIdentity {
-    readonly contents: Buffer;
-}
-export interface OwnedEvidenceSnapshot {
-    readonly filePath: string;
-    readonly identity: EvidenceFileIdentity;
-}
-export interface StableJsonFile {
-    readonly file: StableEvidenceFile | null;
-    readonly value: unknown;
-}
-export declare function stableEvidenceFromBuffer(contents: Buffer): StableEvidenceFile;
-export declare function readStableJsonFile(filePath: string, maximumBytes: number, label: string, fileAccess: EvidenceFileAccess): Promise<StableJsonFile>;
-export declare function readStableEvidenceFile(filePath: string, maximumBytes: number, label: string, fileAccess: EvidenceFileAccess, expectedIdentity?: BigIntStats): Promise<StableEvidenceFile>;
-export declare function writeOwnedEvidenceFile(directory: string, filename: string, contents: Buffer | string): Promise<string>;
-export declare function snapshotStableEvidenceFile(sourcePath: string, maximumBytes: number, label: string, fileAccess: EvidenceFileAccess, expectedIdentity: BigIntStats, targetDirectory: string, filename: string): Promise<OwnedEvidenceSnapshot>;
-export declare function evidenceArtifact(filePath: string, file: EvidenceFileIdentity, contentType: string, kind: string, name: string, summary: string): EngineArtifactEvidence;

package/dist/engines/adapters/evidence-identity.d.ts

@@ -1,12 +0,0 @@
-import type { EngineJsonObject, RunnerProfileDescriptor } from "../api/index.js";
-import type { EngineId } from "../../domain/identifiers.js";
-import { type PlatformTarget } from "../../process/host/platform.js";
-export type EngineInstallationKind = "direct-package" | "root-direct-packages" | "root-playwright-family";
-interface EngineEvidenceIdentityRequest {
-    readonly engineId: EngineId;
-    readonly installationKind: EngineInstallationKind;
-    readonly profile: Readonly<RunnerProfileDescriptor>;
-    readonly target?: Readonly<PlatformTarget>;
-}
-export declare function engineEvidenceIdentity(request: Readonly<EngineEvidenceIdentityRequest>): EngineJsonObject;
-export {};

package/dist/engines/adapters/execution.d.ts

@@ -1,41 +0,0 @@
-import { type EngineCancellationSignal, type EngineEvidence, type EngineExecutionInputs, type EngineExecutionRequest, type EngineExecutionResult, type EngineExecutionTask, type EngineFailureEvidence, type EngineJsonObject, type EngineTaskOutcome } from "../api/index.js";
-import { type TestOutcomeStatus } from "../../domain/test-outcomes.js";
-import type { ManagedProcessResult } from "../../process/index.js";
-export interface EngineFailureIdentity {
-    readonly codePrefix: string;
-    readonly label: string;
-}
-export interface ProcessClassification {
-    readonly failure: EngineFailureEvidence | null;
-    readonly status: TestOutcomeStatus;
-}
-interface EngineTaskPreparation {
-    readonly artifactDirectory: string;
-    readonly inputs: EngineExecutionInputs;
-    readonly task: EngineExecutionTask;
-}
-export type ReadyEngineTask<T> = EngineTaskPreparation & {
-    readonly preparationFailure: null;
-    readonly prepared: T;
-};
-export type PreparedEngineTask<T> = ReadyEngineTask<T> | (EngineTaskPreparation & {
-    readonly preparationFailure: EngineFailureEvidence;
-    readonly prepared: null;
-});
-export declare function executeEngineTasks<T>(request: Pick<EngineExecutionRequest, "invocationId" | "observer" | "signal">, tasks: readonly PreparedEngineTask<T>[], identity: EngineFailureIdentity, execute: (task: ReadyEngineTask<T>, startedAtMs: number) => Promise<EngineTaskOutcome>, native: EngineJsonObject): Promise<EngineExecutionResult>;
-export declare function taskBeforeStartOutcome(task: EngineExecutionTask, signal: EngineCancellationSignal, startedAtMs: number, identity: EngineFailureIdentity): EngineTaskOutcome | null;
-export declare function taskTimeoutFailure(timeoutMs: number, identity: EngineFailureIdentity): EngineFailureEvidence;
-export declare function managedProcessFailure(result: ManagedProcessResult, identity: EngineFailureIdentity, evidenceError?: Error | null): EngineFailureEvidence | null;
-export declare function classifyManagedProcessResult(result: ManagedProcessResult, timeoutMs: number, deadlineExceeded: boolean, identity: EngineFailureIdentity): ProcessClassification | null;
-export declare function processExitDetails(result: ManagedProcessResult): {
-    exitCode?: number;
-    exitSignal?: string;
-};
-export declare function processExitFailure(result: ManagedProcessResult, identity: EngineFailureIdentity, selectedMessage?: string | null, fallbackLabel?: string): ProcessClassification;
-export declare function firstOutputLine(output: string): string | null;
-export declare function terminalOutcome(taskId: string, status: TestOutcomeStatus, startedAtMs: number, evidence: EngineEvidence, failure: EngineFailureEvidence | null): EngineTaskOutcome;
-export declare function processOutputEvidence(result: ManagedProcessResult): EngineEvidence;
-export declare function emptyEvidence(): EngineEvidence;
-export declare function failureFromError(error: unknown, code: string): EngineFailureEvidence;
-export declare function errorDetails(error: Error): EngineJsonObject;
-export {};

package/dist/engines/adapters/native-report.d.ts

@@ -1,25 +0,0 @@
-export interface NativeReportIdentity {
-    readonly engineId: "node-vitest" | "playwright";
-    readonly invocationId: string;
-    readonly taskId: string;
-    readonly sourceFile: string;
-}
-export interface NativeReport extends NativeReportIdentity {
-    readonly schemaVersion: 1;
-    readonly result: unknown;
-}
-export interface NativeReportOptions {
-    readonly identity: NativeReportIdentity;
-    readonly reportFile: string;
-    readonly workspaceDirectory: string;
-}
-export declare const NATIVE_REPORT_JSON_BOUNDS: Readonly<{
-    maxCollectionEntries: 100000;
-    maxDepth: 64;
-    maxNodes: 100000;
-    maxStringUnits: number;
-}>;
-export declare function writeNativeReport(options: Readonly<NativeReportOptions>, result: unknown, maximumBytes: number): Promise<void>;
-export declare function readNativeReport(value: unknown, expected: Readonly<NativeReportIdentity>): NativeReport;
-export declare function nativeReporterFile(engineId: NativeReportIdentity["engineId"]): string;
-export declare function requireNativeEvidenceJson(value: unknown, label: string): void;

package/dist/engines/adapters/node-startup-cache.d.ts

@@ -1,8 +0,0 @@
-/**
- * Shares compiled code, never evaluated modules, between fresh engine processes.
- * The caller owns the cache root and must retain it until its processes exit.
- * Cache failures are optional optimization failures and must not prevent tests.
- */
-export declare function getNodeStartupCacheEnvironment(cacheDirectory: string | undefined, consumerEnvironment: Readonly<Record<string, string>>, options?: Readonly<{
-    coverageEnabled?: boolean;
-}>): Promise<Readonly<Record<string, string>>>;

package/dist/engines/adapters/workspace.d.ts

@@ -1,4 +0,0 @@
-export declare function requireRootDirectory(rootDirectory: string): Promise<string>;
-export declare function requireAbsoluteWorkspacePath(value: string, label: string): void;
-export declare function requireConsumerFile(rootDirectory: string, file: string, label: string): Promise<string>;
-export declare function safeSegment(value: string): string;

package/dist/engines/api/capabilities.d.ts

@@ -1,21 +0,0 @@
-import type { EngineId, PublicTestType } from "../../domain/identifiers.js";
-export declare const ENGINE_EXECUTION_HOSTS: readonly ["orchestrator", "kiln-job"];
-export type EngineExecutionHost = (typeof ENGINE_EXECUTION_HOSTS)[number];
-export declare const TASK_BATCHING_MODES: readonly ["isolated", "compatible"];
-export type TaskBatchingMode = (typeof TASK_BATCHING_MODES)[number];
-export interface RunnerProfileCapabilities {
-    readonly executionHost: EngineExecutionHost;
-    readonly taskBatching: TaskBatchingMode;
-}
-interface RunnerProfileIdsByEngine {
-    k6: "k6-dal" | "k6-http";
-    "node-vitest": "node-vitest-contract" | "node-vitest-data";
-    playwright: "playwright-ui";
-}
-export interface RunnerProfileDescriptor<Id extends EngineId = EngineId> {
-    readonly capabilities: RunnerProfileCapabilities;
-    readonly engineId: Id;
-    readonly id: RunnerProfileIdsByEngine[Id];
-    readonly supportedTestTypes: readonly PublicTestType[];
-}
-export {};

package/dist/engines/api/capabilities.js

@@ -1 +0,0 @@
-export const ENGINE_EXECUTION_HOSTS=Object.freeze(["orchestrator","kiln-job"]),TASK_BATCHING_MODES=Object.freeze(["isolated","compatible"]);

package/dist/engines/api/evidence.d.ts

@@ -1,38 +0,0 @@
-export type EngineJsonPrimitive = boolean | null | number | string;
-export type EngineJsonValue = EngineJsonPrimitive | readonly EngineJsonValue[] | EngineJsonObject;
-export interface EngineJsonObject {
-    readonly [key: string]: EngineJsonValue;
-}
-export interface EngineArtifactEvidence {
-    readonly contentType?: string;
-    readonly data?: EngineJsonValue;
-    readonly kind: string;
-    readonly metadata?: EngineJsonObject;
-    readonly name: string;
-    readonly path: string;
-    readonly summary?: string;
-}
-export interface EngineLogEvidence {
-    readonly stream: "engine" | "stderr" | "stdout";
-    readonly text: string;
-}
-export interface EngineMetricEvidence {
-    readonly dimensions?: EngineJsonObject;
-    readonly name: string;
-    readonly unit?: string;
-    readonly value: number;
-}
-export interface EngineEvidence {
-    readonly artifacts: readonly EngineArtifactEvidence[];
-    readonly logs: readonly EngineLogEvidence[];
-    readonly metrics: readonly EngineMetricEvidence[];
-    readonly native?: EngineJsonObject;
-}
-export type EngineFailureClassification = "infra" | "product";
-export interface EngineFailureEvidence {
-    readonly classification?: EngineFailureClassification;
-    readonly code?: string;
-    readonly details?: EngineJsonObject;
-    readonly message: string;
-    readonly stack?: string;
-}

package/dist/engines/api/execution-observer.d.ts

@@ -1,8 +0,0 @@
-import type { EngineExecutionObserver, EngineExecutionRequest } from "./execution.js";
-export interface ValidatingObserverSession {
-    readonly assertValid: () => void;
-    readonly close: () => void;
-    readonly commit: () => void;
-    readonly observer: EngineExecutionObserver;
-}
-export declare function createValidatingObserverSession(request: EngineExecutionRequest): ValidatingObserverSession | null;

package/dist/engines/api/execution-scope.d.ts

@@ -1,17 +0,0 @@
-export type EngineInvocationCleanup = () => Promise<void> | void;
-export interface EngineInvocationScope {
-    defer(cleanup: EngineInvocationCleanup): void;
-}
-export interface EngineInvocationScopeController {
-    drain(): Promise<readonly Error[]>;
-    readonly scope: EngineInvocationScope;
-}
-interface EngineInvocationScopeOptions {
-    readonly timeoutMs: number;
-}
-export declare class EngineInvocationCleanupDeadlineExceededError extends Error {
-    readonly timeoutMs: number;
-    constructor(timeoutMs: number);
-}
-export declare function createEngineInvocationScope(options: EngineInvocationScopeOptions): EngineInvocationScopeController;
-export {};