@gfdelarue/testkit 0.4.4 → 0.5.0

package/dist/engines/playwright/runtime/runtime-input.d.ts

@@ -1,36 +0,0 @@
-import type { EngineExecutionInputs, EngineJsonObject, EngineJsonValue, EngineTaskOrchestration } from "../../api/index.js";
-export declare const PLAYWRIGHT_RUNTIME_INPUT_MAX_BYTES: number;
-export declare const PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_BYTES: number;
-export declare const PLAYWRIGHT_RUNTIME_ENVIRONMENT_MAX_ENTRIES = 512;
-export interface PlaywrightTestContext {
-    readonly baseUrl: string;
-    readonly endpoints: Readonly<Record<string, string>>;
-    readonly env: Readonly<Record<string, string>>;
-    readonly fixtures: EngineJsonObject;
-    readonly managed: true;
-    readonly setupData?: EngineJsonValue;
-    readonly uiConfig: EngineJsonObject;
-}
-export interface PlaywrightRuntimeInputRequest {
-    readonly baseUrl: string;
-    readonly directory: string;
-    readonly endpoints: Readonly<Record<string, string>>;
-    readonly inputs: EngineExecutionInputs;
-    readonly invocationId: string;
-    readonly orchestration: EngineTaskOrchestration;
-    readonly taskId: string;
-}
-export interface MaterializedPlaywrightRuntimeInput {
-    readonly sizeBytes: number;
-    readonly digest: string;
-    readonly file: string;
-}
-export declare function readPlaywrightContext(): PlaywrightTestContext | null;
-export declare function materializePlaywrightRuntimeInput(request: Readonly<PlaywrightRuntimeInputRequest>): Promise<MaterializedPlaywrightRuntimeInput>;
-export declare function playwrightRuntimeInputBootstrapSource(input: Readonly<{
-    digest: string;
-    file: string;
-    sizeBytes: number;
-    invocationId: string;
-    taskId: string;
-}>): string;

package/dist/engines/playwright/runtime/sandbox.d.ts

@@ -1,84 +0,0 @@
-import { type APIRequest, type APIRequestContext, type Page } from "@playwright/test";
-export interface UiSandboxOptions {
-    allowRemote?: boolean;
-    backendBaseUrl?: string;
-    baseUrl?: string;
-    frontendBaseUrl?: string;
-    headers?: Record<string, string>;
-    prefix?: string;
-}
-export interface UiSandboxFixture {
-    backendBaseUrl: string;
-    frontendBaseUrl: string;
-    id: string;
-    page: Page;
-}
-interface UiSandboxFixtures {
-    testkitSandbox: UiSandboxFixture;
-}
-export interface UiAnimationPage {
-    evaluate(pageFunction: (frameCount: number) => Promise<void>, frameCount: number): Promise<void>;
-}
-export interface UiNetworkIdlePage extends UiAnimationPage {
-    waitForLoadState(state: "domcontentloaded" | "load" | "networkidle", options?: {
-        timeout?: number;
-    }): Promise<void>;
-}
-interface StableElement {
-    getBoundingClientRect(): {
-        toJSON(): unknown;
-    };
-}
-interface UiStableLocator {
-    evaluate(pageFunction: (node: StableElement, requiredStableFrames: number) => Promise<void>, requiredStableFrames: number): Promise<void>;
-    waitFor(options: {
-        state: "visible";
-        timeout?: number;
-    }): Promise<void>;
-}
-export interface UiStableElementPage {
-    locator(selector: string): UiStableLocator;
-}
-interface ImageElement {
-    readonly complete: boolean;
-    addEventListener(type: "error" | "load", listener: () => void, options: {
-        once: true;
-    }): void;
-}
-interface UiImageLocator {
-    count(): Promise<number>;
-    nth(index: number): {
-        evaluate(pageFunction: (element: ImageElement) => Promise<void> | undefined): Promise<void>;
-    };
-}
-export interface UiImagesPage {
-    locator(selector: string): UiImageLocator;
-}
-interface UiTargetOptions {
-    allowRemote?: unknown;
-}
-export declare function createUiSandbox(options?: UiSandboxOptions): {
-    expect: import("@playwright/test").Expect<{}>;
-    test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & UiSandboxFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
-};
-export declare function createSandboxId(options?: Pick<UiSandboxOptions, "prefix">): string;
-export declare function resolveFrontendBaseUrl(options?: UiSandboxOptions): string;
-export declare function resolveBackendBaseUrl(options?: UiSandboxOptions): string;
-export declare function assertSafeUiTarget(url: unknown, options?: UiTargetOptions): string;
-export declare function assertSafeUiTargets(urls?: readonly unknown[], options?: UiTargetOptions): string[];
-export declare function createAuthedApiClient(playwrightRequest?: APIRequest, options?: UiSandboxOptions): Promise<APIRequestContext>;
-export declare function waitForUiSettled(page: UiNetworkIdlePage, options?: {
-    frames?: number;
-    timeout?: number;
-}): Promise<void>;
-export declare function waitForAnimationFrames(page: UiAnimationPage, frames?: unknown): Promise<void>;
-export declare function waitForNetworkIdle(page: UiNetworkIdlePage, options?: {
-    frames?: number;
-    timeout?: number;
-}): Promise<void>;
-export declare function waitForElementStable(page: UiStableElementPage, selector: string, options?: {
-    frames?: number;
-    timeout?: number;
-}): Promise<void>;
-export declare function waitForImagesLoaded(page: UiImagesPage, containerSelector?: string | null): Promise<void>;
-export {};

package/dist/engines/runtime-input-file.d.ts

@@ -1,27 +0,0 @@
-export declare const ownedRuntimeInputModuleUrl: string;
-export declare const RUNTIME_INPUT_BYTE_MEASURE: {
-    unitLabel: string;
-    unitsOf: (text: string) => number;
-};
-/**
- * Single-writer protocol for the files a host prepares inside an owned task
- * directory and later hands to a guest process by pointer + digest. Writes are
- * exclusive-create (0o600), closed, and atomically renamed into place; reads
- * re-verify the file is still an owned regular file with the prepared size,
- * owner-only permissions, identity realpath, and matching SHA-256 digest.
- * These disposable handoffs require process-lifetime visibility, not persistence
- * across machine power loss; durable evidence uses its separate synced writer.
- */
-export interface OwnedFileProtocol {
-    readonly filename: string;
-    readonly label: string;
-    readonly maxSizeBytes: number;
-}
-export interface OwnedFileRecord {
-    readonly directory: string;
-    readonly file: string;
-    readonly sha256: string;
-    readonly sizeBytes: number;
-}
-export declare function writeOwnedRuntimeInput(taskDirectory: string, document: unknown, protocol: OwnedFileProtocol): Promise<OwnedFileRecord>;
-export declare function readVerifiedOwnedFile(record: OwnedFileRecord, protocol: OwnedFileProtocol): Promise<string>;

package/dist/environment/lifecycle-artifacts.d.ts

@@ -1,7 +0,0 @@
-import type { RunManifest } from "../process/runs/manifest.js";
-interface ActiveRunIdsOptions {
-    activeRunIds?: ReadonlySet<string>;
-}
-export declare function reconcileInactiveRunArtifact(productDir: string, manifest: Readonly<RunManifest>): void;
-export declare function reconcileOrphanedLiveRunArtifact(productDir: string, { activeRunIds }?: Readonly<ActiveRunIdsOptions>): boolean;
-export {};

package/dist/environment/lifecycle-controller.d.ts

@@ -1,70 +0,0 @@
-import type { SupervisedProcessHandle, SupervisedProcessReady } from "../process/index.js";
-export { isRunManifestActive } from "../process/runs/inspection.js";
-import type { RuntimeInstanceContext } from "./runtime-contexts.js";
-import type { LocalServiceLifecycle } from "./services.js";
-import { type ProductLifecycleFence } from "../process/lifecycle-fence.js";
-import { type RunManifest, type RunManifestService } from "../process/runs/manifest.js";
-type LifecycleServiceConfig = Parameters<LocalServiceLifecycle["registerService"]>[0];
-export interface RunLifecycleOptions {
-    controller?: unknown;
-    heartbeat?: boolean;
-    keepAlive?: boolean;
-    pid?: number;
-    resetResultsBeforePublish?: boolean;
-    runId?: string;
-}
-export interface RunPortQuery {
-    host?: unknown;
-    port?: unknown;
-}
-export interface RunPortOwner {
-    active: boolean;
-    manifest: RunManifest;
-    service: RunManifestService;
-}
-type RunGraphContext = Pick<RuntimeInstanceContext, "runtimeDir">;
-export interface RunLifecycleFinalizationState {
-    interruptReason: null | string;
-    interrupted: boolean;
-}
-export interface RunLifecycle extends LocalServiceLifecycle {
-    commitFinalization(status?: string): RunLifecycleFinalizationState;
-    dispose(): void;
-    finalizeForControllerExit(reason?: unknown): boolean;
-    getInterruptReason(): null | string;
-    heartbeat(metadata?: unknown): void;
-    installSignalHandlers(): void;
-    isMaintenanceStopCoordinated(): boolean;
-    isStopRequested(): boolean;
-    manifestPath: string;
-    markFinished(status?: string): void;
-    markRunning(): void;
-    registerService(config: LifecycleServiceConfig, supervisor: SupervisedProcessHandle, ownership: SupervisedProcessReady, cwd: string): void;
-    removeManifest(): Promise<void>;
-    removeSignalHandlers(): void;
-    requestStop(reason?: unknown): void;
-    runId: string;
-    maintenanceStopSignal: AbortSignal;
-    signal: AbortSignal;
-    startHeartbeat(intervalMs?: unknown, metadataProvider?: null | (() => unknown)): () => void;
-    trackGraphContext(context: Readonly<RunGraphContext>): void;
-    unregisterService(supervisorPid: number): void;
-}
-interface RunLifecycleOwnership {
-    incarnationId: string;
-    pid: number;
-    processIdentity: null | string;
-    productDir: string;
-    published: boolean;
-    runId: string;
-}
-interface OwnedRunLifecycleState {
-    manifest: RunManifest | null;
-    ownership: RunLifecycleOwnership;
-    productDir: string;
-}
-export declare function createUnpublishedRunLifecycle(productDir: string, options?: Readonly<RunLifecycleOptions>): RunLifecycle;
-export declare function cleanupOwnedRunLifecycleWithinLifecycleFence(fence: Readonly<ProductLifecycleFence>, lifecycle: Readonly<RunLifecycle>): boolean;
-export declare function readOwnedRunLifecycleWithinLifecycleFence(fence: Readonly<ProductLifecycleFence>, lifecycle: Readonly<RunLifecycle>): OwnedRunLifecycleState;
-export declare function findPortOwner(productDir: string, { host, port }: Readonly<RunPortQuery>): RunPortOwner | null;
-export declare function disposeFailedRunLifecycle(lifecycle: RunLifecycle): void;

package/dist/environment/lifecycle.d.ts

@@ -1,29 +0,0 @@
-import type { LocalPostgresCleanupResult } from "../database/cleanup.js";
-import { type ProductLifecycleFence } from "../process/lifecycle-fence.js";
-import { type RunManifest } from "../process/runs/manifest.js";
-import { type RunLifecycle, type RunLifecycleOptions } from "./lifecycle-controller.js";
-export interface RunCleanupSummary {
-    cleaned: RunManifest[];
-    resourceCleanup: LocalPostgresCleanupResult;
-    skippedActive: RunManifest[];
-    stoppedActive: RunManifest[];
-}
-interface RunCleanupOptions {
-    includeActive?: boolean;
-}
-export interface RunCleanupWithinLifecycleFenceOptions {
-    protectedLiveRunIds?: ReadonlySet<string>;
-}
-export declare function startRunLifecycle(productDir: string, options?: Readonly<RunLifecycleOptions>): Promise<RunLifecycle>;
-export declare function startRunLifecycleWithinLifecycleFence(fence: Readonly<ProductLifecycleFence>, options?: Readonly<RunLifecycleOptions>): Promise<RunLifecycle>;
-export declare function cleanupRuns(productDir: string, { includeActive }?: Readonly<RunCleanupOptions>): Promise<RunCleanupSummary>;
-export declare function cleanupRunsWithinLifecycleFence(fence: Readonly<ProductLifecycleFence>, { protectedLiveRunIds }?: Readonly<RunCleanupWithinLifecycleFenceOptions>): Promise<RunCleanupSummary>;
-export declare function cleanupStaleRuns(productDir: string): Promise<RunManifest[]>;
-export declare function cleanupStaleRunsWithinLifecycleFence(fence: Readonly<ProductLifecycleFence>): Promise<RunManifest[]>;
-export declare function cleanupOwnedRunLifecycleResourcesWithinLifecycleFence(fence: Readonly<ProductLifecycleFence>, lifecycle: Readonly<RunLifecycle>): Promise<boolean>;
-export { listRunManifests, RunManifestInventoryError, type RunManifest, type RunManifestController, type RunManifestPort, type RunManifestService, } from "../process/runs/manifest.js";
-export { stopRunById, stopRunManifest, type StoppedRun } from "./run-stopping.js";
-export { cleanupOwnedRunLifecycleWithinLifecycleFence, findPortOwner, isRunManifestActive, } from "./lifecycle-controller.js";
-export type { RunLifecycleOptions, RunPortQuery, RunPortOwner, RunLifecycleFinalizationState, RunLifecycle, } from "./lifecycle-controller.js";
-export { isPidRunning } from "../process/runs/stop.js";
-export { formatRunSummary } from "../process/runs/manifest.js";

package/dist/environment/maintenance.d.ts

@@ -1,68 +0,0 @@
-import type { NormalizedServiceConfig } from "../config/loader/index.js";
-import type { DatabaseResourceCleanupEntry, LocalPostgresCleanupResult } from "../database/cleanup.js";
-import { type RunManifest, type StoppedRun } from "./lifecycle.js";
-import { type RuntimeCleanupTarget, type RuntimeGraphStatus, type RunStatus } from "./status-runtime.js";
-import type { DesiredRuntimeGraph } from "./planning-types.js";
-export type { RuntimeCleanupTarget, RuntimeGraphStatus, RunStatus } from "./status-runtime.js";
-export type { RunManifest } from "../process/runs/manifest.js";
-export type { StoppedRun } from "./run-stopping.js";
-export interface ResourceCleanupSummary {
-    kept: DatabaseResourceCleanupEntry[];
-    removed: DatabaseResourceCleanupEntry[];
-    skipped?: LocalPostgresCleanupResult["skipped"];
-    stopped?: LocalPostgresCleanupResult["stopped"];
-    targets: DatabaseResourceCleanupEntry[];
-}
-interface RunCleanupPreview {
-    cleaned: RunManifest[];
-    skippedActive: RunManifest[];
-    stoppedActive: RunManifest[];
-}
-export interface EnvironmentInventory {
-    runtimeGraphs: RuntimeGraphStatus[];
-    runs: RunStatus;
-}
-export type RunSelection = {
-    kind: "latest-active";
-} | {
-    kind: "all";
-} | {
-    kind: "run";
-    runId: string;
-};
-export interface EnvironmentCleanupRequest {
-    kind: "cleanup";
-    desiredGraphs: readonly DesiredRuntimeGraph[];
-    serviceName: string | null;
-    dryRun: boolean;
-    resources: boolean;
-}
-export interface EnvironmentDestroyRequest {
-    kind: "destroy";
-    configs: readonly Readonly<NormalizedServiceConfig>[];
-    destroyOwnedResources?: boolean;
-}
-export interface EnvironmentCleanupResult extends RunCleanupPreview {
-    dryRun: boolean;
-    targets: RuntimeCleanupTarget[];
-    runtimeCleaned: RuntimeCleanupTarget[];
-    resourceCleanup: ResourceCleanupSummary;
-    automaticResourceCleanup: ResourceCleanupSummary[];
-}
-export interface CacheMaintenance<Result> {
-    result: Result;
-    prune(): void | Promise<void>;
-}
-export interface EnvironmentMaintenance {
-    inspect(desiredGraphs: readonly DesiredRuntimeGraph[], serviceName?: string | null): EnvironmentInventory;
-    inspectRuns(runId?: string): Array<RunManifest & {
-        active: boolean;
-    }>;
-    stop(selection: RunSelection, reason: string): Promise<StoppedRun[]>;
-    maintain(request: EnvironmentDestroyRequest): Promise<void>;
-    maintain<Result>(request: EnvironmentCleanupRequest, planOtherCaches: () => CacheMaintenance<Result>): Promise<{
-        environment: EnvironmentCleanupResult;
-        otherCaches: Result;
-    }>;
-}
-export declare function createEnvironmentMaintenance(productDir: string): EnvironmentMaintenance;

package/dist/environment/planning-types.d.ts

@@ -1,35 +0,0 @@
-import type { RuntimeDependencyConfig } from "../config/loader/dependencies.js";
-import type { DatabaseReservationService, RuntimeDatabaseReservation } from "../database/runtime-reservations.js";
-export interface RuntimeServiceSpec extends RuntimeDependencyConfig {
-    testkit: RuntimeDependencyConfig["testkit"] & DatabaseReservationService["testkit"] & {
-        runtime: {
-            instances: number;
-            maxConcurrentTasks: number;
-        };
-    };
-}
-export interface RuntimeSelection<Config extends RuntimeServiceSpec = RuntimeServiceSpec> {
-    config: Config;
-    runtimeConfigs: readonly Config[];
-    runtimeKey: string;
-    runtimeNames: readonly string[];
-}
-export interface RuntimeGraph<Config extends RuntimeServiceSpec = RuntimeServiceSpec> {
-    dirName: string;
-    instanceCount: number;
-    key: string;
-    maxConcurrentTasks: number;
-    portNamespaceIndex: number;
-    portNamespaceStride: number;
-    resourceReservations: RuntimeDatabaseReservation[];
-    runtimeConfigs: readonly Config[];
-    runtimeNames: readonly string[];
-    targetNames: string[];
-}
-export interface DesiredRuntimeGraph {
-    dirName: string;
-    instanceCount: number;
-    key: string;
-    runtimeNames: string[];
-    targetNames: string[];
-}

package/dist/environment/readiness.d.ts

@@ -1,12 +0,0 @@
-export interface LocalReadinessConfig {
-    name: string;
-    productDir: string;
-    runtimeLabel: string;
-    testkit: {
-        local: {
-            baseUrl: string;
-            readyUrl?: false | null | string;
-        };
-    };
-}
-export declare function assertLocalServicePortsAvailable(config: Readonly<LocalReadinessConfig>): Promise<void>;

package/dist/environment/readiness.js

@@ -1 +0,0 @@
-import{cleanupStaleRuns as m,findPortOwner as p,formatRunSummary as a}from"./lifecycle.js";import{socketFromUrl as w}from"./template.js";import{isPortInUse as c}from"../process/readiness.js";const s=String;export async function assertLocalServicePortsAvailable(t){const l=[t.testkit.local.baseUrl,t.testkit.local.readyUrl],o=new Set;for(const i of l){const e=typeof i=="string"?w(i):null;if(!e)continue;const r=`${e.host}:${s(e.port)}`;if(!o.has(r)&&(o.add(r),await c(e)&&await m(t.productDir),await c(e))){const n=p(t.productDir,e),u=n?n.active?` Active testkit run ${s(a(n.manifest))} owns ${r} via ${s(n.service.runtimeLabel)}:${s(n.service.serviceName)}.`:` Stale testkit run ${s(a(n.manifest))} owns ${r}.`:"";throw new Error(`Cannot start "${t.runtimeLabel}:${t.name}" because ${r} is already in use. Stop the existing process and rerun testkit.${u}`)}}}

package/dist/environment/ready-environment.d.ts

@@ -1,19 +0,0 @@
-import { type DatabaseInfo } from "../database/state.js";
-import { type RuntimeInstanceContext } from "./runtime-contexts.js";
-import type { ReadyServiceConfig } from "./runtime-service.js";
-export interface ReadyService {
-    readonly baseUrl: string | null;
-    readonly config: ReadyServiceConfig;
-    readonly database: Readonly<DatabaseInfo> | null;
-}
-export interface ReadyEnvironment {
-    readonly engineCacheDirectory?: string;
-    readonly engineWorkspaceDirectory?: string;
-    readonly graphKey: string;
-    readonly leaseDir: string;
-    readonly leaseId: string;
-    readonly runtimeId: string;
-    readonly services: ReadonlyMap<string, ReadyService>;
-    readonly targetNames: readonly string[];
-}
-export declare function createReadyEnvironment(context: RuntimeInstanceContext, lease: Pick<ReadyEnvironment, "leaseDir" | "leaseId">): ReadyEnvironment;

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

@@ -1,38 +0,0 @@
-import { type RuntimeManagerGraph, type RuntimeManagerRuntimeOptions, type RuntimeRequirement, type RuntimeCapacityRequirement, type RuntimeManagerAcquireOptions, type RuntimeManagerReleaseOptions, type RuntimeManagerGraphStats } from "./runtime-manager.js";
-import type { ReadyEnvironment } from "./ready-environment.js";
-import { type CommittedRunFinalization } from "../evidence/finalization.js";
-export type { RuntimeManagerGraphStats, RuntimeManagerRuntimeOptions, RuntimeManagerGraph } from "./runtime-manager.js";
-export interface RuntimeGraphIdentity {
-    readonly key: string;
-    readonly targetNames: readonly string[];
-}
-export interface RunProvisioningOptions {
-    heartbeat?: boolean;
-    keepAlive?: boolean;
-    resetResultsBeforePublish?: boolean;
-    runId?: string;
-}
-export interface RunProvisioning {
-    start(options: Readonly<RunProvisioningOptions>): Promise<ProvisionedRun>;
-}
-export interface ProvisionedRun {
-    readonly runId: string;
-    readonly signal: AbortSignal;
-    readonly committedFinalization: CommittedRunFinalization | null;
-    isStopRequested(): boolean;
-    getInterruptReason(): string | null;
-    requestStop(reason?: unknown): void;
-    beginFinalization(): void;
-    dispose(): void;
-    provision(graphs: readonly RuntimeManagerGraph[], options: Readonly<RuntimeManagerRuntimeOptions>): void;
-    acquire(requirement: Readonly<RuntimeRequirement>, options?: Readonly<RuntimeManagerAcquireOptions>): Promise<ReadyEnvironment>;
-    canAcquire(requirement: Readonly<RuntimeCapacityRequirement>): boolean;
-    release(leaseId: string, options?: Readonly<RuntimeManagerReleaseOptions>): Promise<void>;
-    cleanupAll(): Promise<void>;
-    getStats(): RuntimeManagerGraphStats[];
-    getGraph(graphKey: string): RuntimeGraphIdentity | null;
-    getGraphFailure(graphKey: string): string | null;
-    markGraphFailed(graphKey: string, message: string): void;
-    finish<Result>(status: "failed" | "passed", seal: (state: Readonly<CommittedRunFinalization>) => Result, mode: "normal" | "recovery"): Promise<Result>;
-}
-export declare function createLocalRunEnvironment(productDir: string): RunProvisioning;

package/dist/environment/run-stopping.d.ts

@@ -1,13 +0,0 @@
-import { type RunManifest } from "../process/runs/manifest.js";
-export interface StoppedRun {
-    pid: number;
-    reason: string;
-    runId: string;
-    stopped: true;
-}
-export interface StopRunOptions {
-    graceMs?: number;
-    reason?: unknown;
-}
-export declare function stopRunById(productDir: string, runId: string, options?: Readonly<StopRunOptions>): Promise<boolean>;
-export declare function stopRunManifest(productDir: string, manifest: Readonly<RunManifest>, options?: Readonly<StopRunOptions>): Promise<StoppedRun>;

package/dist/environment/runtime-contexts.d.ts

@@ -1,33 +0,0 @@
-import type { ProvisionDatabaseOptions } from "../database/index.js";
-import type { RuntimeServiceSpec, RuntimeGraph } from "./planning-types.js";
-import { type RuntimePreparationConfig, type RuntimePreparationOptions } from "./runtime-preparation.js";
-import { type LocalServiceLifecycle, type StartedLocalService, type StartLocalServicesOptions } from "./services.js";
-import { type RuntimeServiceConfig } from "./template.js";
-import type { ConfiguredStepServiceConfig } from "../steps/index.js";
-import type { ReadyServiceConfig } from "./runtime-service.js";
-export type RuntimeContextSourceConfig = RuntimeServiceSpec & RuntimeServiceConfig & ReadyServiceConfig & ConfiguredStepServiceConfig & {
-    stateDir: string;
-    testkit: RuntimeServiceSpec["testkit"] & RuntimeServiceConfig["testkit"] & ConfiguredStepServiceConfig["testkit"] & {
-        envFiles?: readonly string[];
-    };
-};
-export type RuntimeContextOptions = RuntimePreparationOptions & StartLocalServicesOptions & Pick<ProvisionDatabaseOptions, "skipSchemaSourceVerify">;
-export type RuntimeInstanceConfig = RuntimePreparationConfig & ReadyServiceConfig;
-export interface RuntimeInstanceContext {
-    graphDir: string;
-    graphKey: string;
-    preparationPromise: Promise<void> | null;
-    prepared: boolean;
-    runtimeConfigs: RuntimeInstanceConfig[];
-    runtimeDir: string;
-    runtimeId: string;
-    started: boolean;
-    startedServices: StartedLocalService[];
-    startupPromise: Promise<void> | null;
-    targetNames: string[];
-}
-export declare function runtimeEngineDirectory(context: Pick<RuntimeInstanceContext, "graphDir" | "runtimeId">): string;
-export declare function createRuntimeInstanceContext(runtimeId: string, graph: RuntimeGraph<RuntimeContextSourceConfig>, productDir: string): RuntimeInstanceContext;
-export declare function ensureRuntimeInstanceReady(context: RuntimeInstanceContext, startApplicationServices: boolean, lifecycle: LocalServiceLifecycle, options?: Readonly<RuntimeContextOptions>): Promise<RuntimeInstanceContext>;
-export declare function cleanupRuntimeInstanceContext(context: RuntimeInstanceContext | null | undefined, lifecycle: LocalServiceLifecycle): Promise<void>;
-export declare function prepareDatabases(runtimeConfigs: readonly RuntimePreparationConfig[], options?: Readonly<RuntimeContextOptions>): Promise<void>;

package/dist/environment/runtime-manager.d.ts

@@ -1,95 +0,0 @@
-import { type RuntimeContextOptions, type RuntimeContextSourceConfig, type RuntimeInstanceContext } from "./runtime-contexts.js";
-import { type OperationTimingRegistry } from "../evidence/operation-timings.js";
-import type { RunLifecycle } from "./lifecycle.js";
-import type { RuntimeGraph } from "./planning-types.js";
-import { type ReadyEnvironment } from "./ready-environment.js";
-export type RuntimeManagerGraph = RuntimeGraph<RuntimeContextSourceConfig>;
-export interface RuntimeCapacityRequirement {
-    graphKey: string;
-    locks?: readonly string[];
-    resourceCost?: number;
-}
-export interface RuntimeRequirement extends RuntimeCapacityRequirement {
-    id: number;
-    startApplicationServices: boolean;
-    serviceName?: string;
-    targetName?: string;
-}
-export type RuntimeManagerRuntimeOptions = RuntimeContextOptions & {
-    operationTimingRegistry?: null | OperationTimingRegistry;
-};
-export interface CreateRuntimeManagerOptions {
-    graphs: readonly RuntimeManagerGraph[];
-    lifecycle: RunLifecycle;
-    productDir: string;
-    runtimeOptions?: Readonly<RuntimeManagerRuntimeOptions>;
-}
-export interface RuntimeManagerAcquireOptions {
-    operationTimingParentId?: null | string;
-}
-export interface RuntimeManagerReleaseOptions {
-    invalidate?: boolean;
-}
-interface RuntimeLeaseReleaseState {
-    leaseDir: boolean;
-    locks: boolean;
-    runtimeSlot: boolean;
-}
-interface RuntimeSlotResourceReservation {
-    key: string;
-    services: readonly string[];
-    units: number;
-}
-export interface RuntimeSlot {
-    activeLeaseCount: number;
-    activeResourceUnits: number;
-    context: null | RuntimeInstanceContext;
-    draining: boolean;
-    graph: RuntimeManagerGraph;
-    peakLeaseCount: number;
-    peakResourceUnits: number;
-    resourceReservations: RuntimeSlotResourceReservation[];
-    runtimeId: string;
-}
-export interface RuntimeLease extends ReadyEnvironment {
-    context: RuntimeInstanceContext;
-    lockNames: readonly string[];
-    released?: boolean;
-    releaseState?: RuntimeLeaseReleaseState;
-    resourceCost: number;
-    slot: RuntimeSlot;
-}
-export interface RuntimeManagerRuntimeStats {
-    peakLeaseCount: number;
-    peakResourceUnits: number;
-    resourceReservations: RuntimeSlotResourceReservation[];
-    runtimeId: string;
-}
-export interface RuntimeManagerResourceBudgetStats {
-    active: number;
-    available: number;
-    capacity: number;
-    key: string;
-    peakActive: number;
-    reserved: number;
-}
-export interface RuntimeManagerGraphStats {
-    graphKey: null | string;
-    maxConcurrentTasks: null | number;
-    resourceBudgets: RuntimeManagerResourceBudgetStats[];
-    runtimeCount: number;
-    runtimes: RuntimeManagerRuntimeStats[];
-    targetNames: string[];
-}
-export interface RuntimeManager {
-    acquire<Task extends RuntimeRequirement>(task: Readonly<Task>, options?: Readonly<RuntimeManagerAcquireOptions>): Promise<RuntimeLease>;
-    canAcquire<Task extends RuntimeCapacityRequirement>(task: Readonly<Task>): boolean;
-    cleanupAll(): Promise<void>;
-    getGraphFailure(graphKey: string): string | null;
-    getGraph(graphKey: string): null | RuntimeManagerGraph;
-    getStats(): RuntimeManagerGraphStats[];
-    markGraphFailed(graphKey: string, message: string): void;
-    release(lease: null | RuntimeLease | undefined, options?: Readonly<RuntimeManagerReleaseOptions>): Promise<void>;
-}
-export declare function createRuntimeManager({ productDir, graphs, lifecycle, runtimeOptions, }: Readonly<CreateRuntimeManagerOptions>): RuntimeManager;
-export {};

package/dist/environment/runtime-planning.d.ts

@@ -1,16 +0,0 @@
-import type { NormalizedServiceConfig } from "../config/loader/index.js";
-import type { DesiredRuntimeGraph } from "./planning-types.js";
-import { resolveRuntimeInstanceConfigs } from "./template.js";
-import { resolveRuntimeConfigs } from "../config/loader/dependencies.js";
-import type { RuntimeGraph, RuntimeSelection, RuntimeServiceSpec } from "./planning-types.js";
-export interface RuntimePlanning {
-    collectDesiredRuntimeGraphs: typeof collectDesiredRuntimeGraphs;
-    resolveRuntimeInstanceConfigs: typeof resolveRuntimeInstanceConfigs;
-    buildRuntimeGraphs: typeof buildRuntimeGraphs;
-    resolveRuntimeConfigs: typeof resolveRuntimeConfigs;
-    buildGraphDirName: typeof buildGraphDirName;
-}
-export declare const runtimePlanning: RuntimePlanning;
-export declare function buildRuntimeGraphs<Config extends RuntimeServiceSpec>(servicePlans: readonly RuntimeSelection<Config>[]): RuntimeGraph<Config>[];
-export declare function buildGraphDirName(runtimeNames: readonly string[]): string;
-export declare function collectDesiredRuntimeGraphs(allConfigs?: readonly NormalizedServiceConfig[]): DesiredRuntimeGraph[];

package/dist/environment/runtime-preparation.d.ts

@@ -1,30 +0,0 @@
-import type { RuntimeServiceConfig } from "./template.js";
-import { type ConfiguredStepReporter, type ConfiguredStepServiceConfig } from "../steps/index.js";
-import { type SetupOperationRegistry } from "../evidence/setup-progress.js";
-import type { FingerprintPolicy } from "../repo/fingerprint-policy.js";
-import type { NormalizedBuildPrepareConfig } from "../steps/build-config.js";
-export type RuntimePreparationConfig = RuntimeServiceConfig & ConfiguredStepServiceConfig & {
-    runtimeLabel: string;
-    stateDir: string;
-    testkit: RuntimeServiceConfig["testkit"] & ConfiguredStepServiceConfig["testkit"] & {
-        envFiles?: readonly string[];
-        fingerprints?: FingerprintPolicy;
-        prepareDir: string;
-    };
-};
-export type RuntimePreparationInputConfig = Omit<RuntimePreparationConfig, "testkit"> & {
-    testkit: Omit<RuntimePreparationConfig["testkit"], "runtime"> & {
-        runtime: Omit<RuntimePreparationConfig["testkit"]["runtime"], "prepare"> & {
-            prepare?: NormalizedBuildPrepareConfig | null;
-        };
-    };
-};
-export interface RuntimePreparationOptions {
-    extraEnv?: NodeJS.ProcessEnv | null;
-    reporter?: ConfiguredStepReporter | null;
-    setupRegistry?: SetupOperationRegistry | null;
-    signal?: AbortSignal;
-}
-export declare function prepareRuntimeServices(runtimeConfigs: readonly RuntimePreparationInputConfig[], options?: Readonly<RuntimePreparationOptions>): Promise<void>;
-export declare function prepareRuntimeService(config: RuntimePreparationInputConfig, options?: Readonly<RuntimePreparationOptions>): Promise<void>;
-export declare function computeRuntimePrepareFingerprint(config: RuntimePreparationConfig, options?: Readonly<Pick<RuntimePreparationOptions, "signal">>): Promise<string>;

package/dist/environment/runtime-service.d.ts

@@ -1,18 +0,0 @@
-import type { EngineJsonObject } from "../engines/api/index.js";
-import type { EngineId } from "../domain/identifiers.js";
-import type { ExecutionEnvironmentConfig } from "../steps/index.js";
-export interface ReadyServiceLocalConfig {
-    baseUrl?: null | string;
-    cwd?: string;
-    env?: Readonly<Record<string, string>>;
-}
-export interface ReadyServiceConfig extends ExecutionEnvironmentConfig {
-    engineConfigurations?: Readonly<Partial<Record<EngineId, EngineJsonObject>>>;
-    stateDir: string;
-    testkit: ExecutionEnvironmentConfig["testkit"] & {
-        execution: {
-            fileTimeoutSeconds: number;
-        };
-        local?: null | ReadyServiceLocalConfig;
-    };
-}