@gfdelarue/testkit 0.4.5 → 0.6.0

package/dist/evidence/timing.d.ts

@@ -1,23 +0,0 @@
-export interface TimingEntry {
-    avgDurationMs: number;
-    durationMs: number;
-    lastDurationMs: number;
-    lastStatus: string | null;
-    maxDurationMs: number;
-    minDurationMs: number;
-    runs: number;
-    updatedAt: string | null;
-}
-export type TimingFileMap = Readonly<Record<string, TimingEntry | undefined>>;
-export interface Timings {
-    files: TimingFileMap;
-    version: 2;
-}
-export interface TimingUpdate {
-    readonly durationMs: number;
-    readonly key: string;
-    readonly status?: string | null;
-}
-export declare function createEmptyTimings(): Timings;
-export declare function normalizeTimings(parsed: unknown): Timings;
-export declare function applyTimingUpdates(timings: Timings, updates: readonly TimingUpdate[], updatedAt?: string): Timings;

package/dist/file.d.ts

@@ -1,11 +0,0 @@
-import type { EngineId } from "./domain/identifiers.js";
-import type { RuntimeIsolationPolicy } from "./domain/runtime-isolation-contract.js";
-export interface TestkitFileMetadata {
-    engine: EngineId;
-    locks?: string[];
-    runtimeIsolation?: RuntimeIsolationPolicy;
-    skip?: string | {
-        reason: string;
-    };
-}
-export declare function defineFile(metadata: TestkitFileMetadata): TestkitFileMetadata;

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { defineFile } from "./file.js";
-export type { EngineId } from "./domain/identifiers.js";
-export type { TestkitFileMetadata } from "./file.js";
-export type { RuntimeIsolationPolicy } from "./domain/runtime-isolation-contract.js";

package/dist/kernel/error-serialization.d.ts

@@ -1,40 +0,0 @@
-export type ErrorMetadataPrimitive = string | number | boolean | null;
-export type ErrorMetadataValue = ErrorMetadataPrimitive | ErrorMetadataObject | ErrorMetadataValue[];
-export interface ErrorMetadataObject {
-    [key: string]: ErrorMetadataValue;
-}
-export interface SerializedErrorOperation {
-    id?: string;
-    source: string;
-    name: string;
-    kind: string;
-    summary?: string;
-    scope: ErrorMetadataObject;
-    status?: string;
-    error?: string;
-}
-export interface SerializedError {
-    name: string;
-    message: string;
-    code?: string;
-    exitCode?: number;
-    status?: number;
-    phase?: string;
-    operation?: SerializedErrorOperation;
-    diagnostics?: ErrorMetadataObject;
-    stack?: string;
-}
-export interface SerializeErrorOptions {
-    includeStack?: boolean;
-}
-export declare function attachErrorOperation<ErrorValue>(error: ErrorValue, operation: unknown): ErrorValue;
-export declare function attachErrorDiagnostics<ErrorValue>(error: ErrorValue, diagnostics: unknown): ErrorValue;
-export declare function getErrorOperation(error: unknown): SerializedErrorOperation | null;
-export declare function getErrorDiagnostics(error: unknown): ErrorMetadataObject;
-export declare function errorMessage(error: unknown): string;
-export declare function formatError(error: unknown): string;
-export declare function sanitizeErrorMessage(message: string): string;
-export declare function errorDetail(error: unknown): string;
-export declare function serializeError(error: unknown, { includeStack }?: Readonly<SerializeErrorOptions>): SerializedError;
-export declare function toError(value: unknown): Error;
-export declare function hasErrorCode(error: unknown, code: string): boolean;

package/dist/kernel/redaction.d.ts

@@ -1,2 +0,0 @@
-export declare const SENSITIVE_KEY_PATTERN: RegExp;
-export declare function redactSensitiveText(value: unknown): string;

package/dist/kernel/unknown-values.d.ts

@@ -1,11 +0,0 @@
-export type UnknownRecord = Record<string, unknown>;
-export declare function isUnknownRecord(value: unknown): value is UnknownRecord;
-export declare function asUnknownRecord(value: unknown): UnknownRecord | null;
-/** A non-empty string, or null for an empty string and every other value. */
-export declare function optionalString(value: unknown): string | null;
-export declare function displayString(value: unknown, fallback: string): string;
-export declare function isUnknownArray(value: unknown): value is unknown[];
-/** Objects and functions: the values Reflect.get accepts as a target. */
-export declare function isPropertyContainer(value: unknown): value is object;
-export declare function readDynamicProperty(value: unknown, key: string): unknown;
-export declare function isNullableString(value: unknown): value is string | null;

package/dist/kernel/work-metrics.d.ts

@@ -1,6 +0,0 @@
-/** Call-through observation of work performed by Testkit, independent of time. */
-export type WorkObserver = (metric: string, amount: number) => void;
-export declare function isWorkObserved(): boolean;
-export declare function recordWork(metric: string, amount?: number): void;
-/** Install an observer for this process and restore the previous observer. */
-export declare function observeWork(next: WorkObserver): () => void;

package/dist/process/capture-output.d.ts

@@ -1,7 +0,0 @@
-export type OutputLineHandler = (line: string) => void;
-export interface CaptureOutputOptions {
-    livePrefix?: string | null;
-    liveWriter?: OutputLineHandler | null;
-    onLine?: OutputLineHandler | null;
-}
-export declare function captureOutput(stream: NodeJS.ReadableStream | null | undefined, options?: Readonly<CaptureOutputOptions>): Promise<void>;

package/dist/process/command-shell.d.ts

@@ -1 +0,0 @@
-export declare function resolvePosixCommandShell(env: Readonly<NodeJS.ProcessEnv>, ambientEnv?: Readonly<NodeJS.ProcessEnv>): string;

package/dist/process/environment-overlay.d.ts

@@ -1,17 +0,0 @@
-export declare const MANAGED_PROCESS_ENVIRONMENT_OVERLAY_STATE_SYMBOL = "elench.testkit.engine-process.environment-overlay.v1";
-export interface ManagedProcessEnvironmentOverlayOptions {
-    readonly environment: Readonly<Record<string, string>>;
-    readonly label: string;
-}
-/**
- * Adds file-backed consumer values to `process.env` without adding them to the
- * physical environment block inherited by native processes.
- *
- * Managed values behave like immutable, non-enumerable own properties. A Node
- * child that inherits the adapter-owned bootstrap controls can therefore
- * rehydrate the same values without transporting them through its OS spawn
- * environment.
- */
-export declare function installManagedProcessEnvironmentOverlay(options: Readonly<ManagedProcessEnvironmentOverlayOptions>): NodeJS.ProcessEnv;
-/** Returns the exact shared installer as a self-contained ESM source fragment. */
-export declare function managedProcessEnvironmentOverlayInstallerSource(): string;

package/dist/process/environment.d.ts

@@ -1,33 +0,0 @@
-export declare const ENGINE_PROCESS_RESERVED_ENVIRONMENT_KEYS: readonly ["APPDATA", "ComSpec", "HOME", "LANG", "LC_ALL", "LOCALAPPDATA", "PATH", "PATHEXT", "SystemRoot", "TEMP", "TMP", "TMPDIR", "USERPROFILE", "XDG_CACHE_HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME"];
-export interface InvocationProcessEnvironment {
-    readonly environment: Readonly<Record<string, string>>;
-    readonly homeDirectory: string;
-    readonly temporaryDirectory: string;
-}
-export interface NativeInvocationProcessEnvironmentOptions {
-    readonly ambientEnvironment?: Readonly<NodeJS.ProcessEnv>;
-    readonly nativeTemporaryRootDirectory?: string;
-    readonly platform?: NodeJS.Platform;
-}
-export declare function nativeTemporaryRoot(ambientEnvironment?: Readonly<NodeJS.ProcessEnv>, platform?: NodeJS.Platform): string;
-/**
- * Creates the operating-system directories owned by one engine invocation.
- *
- * Engine processes must not inherit the orchestrator user's home, temporary,
- * cache, configuration, or executable search paths. Apart from locale, only
- * the two Windows variables required to launch native processes are copied
- * from the host.
- */
-export declare function createInvocationProcessEnvironment(invocationDirectory: string, ambientEnvironment?: Readonly<NodeJS.ProcessEnv>, platform?: NodeJS.Platform): Promise<InvocationProcessEnvironment>;
-/**
- * Creates an invocation environment whose native-process temporary directory
- * has a short, operating-system-owned path.
- *
- * Chromium and other native tools create Unix-domain sockets below their
- * temporary directory. A correctly isolated workspace can still be too deeply
- * nested for those operating-system path limits, so the directory is a fresh
- * 0700 allocation rather than a shared alias or inherited host path. The
- * caller owns removing `temporaryDirectory` after the managed process scope
- * has terminated.
- */
-export declare function createNativeInvocationProcessEnvironment(invocationDirectory: string, options?: Readonly<NativeInvocationProcessEnvironmentOptions>): Promise<InvocationProcessEnvironment>;

package/dist/process/files/contained-path.d.ts

@@ -1,8 +0,0 @@
-/**
- * Containment guards for configured relative paths. Callers hand over a
- * user-authored path plus the product directory that must contain it; these
- * helpers reject absolute paths, parent-directory escapes, NUL bytes, and
- * filesystem links that resolve outside that directory.
- */
-export declare function normalizeContainedRelativePath(value: string, label: string): string;
-export declare function resolveContainedPath(productDir: string, maybeRelative: string | null | undefined, label: string): string;

package/dist/process/files/directory-status.d.ts

@@ -1,14 +0,0 @@
-export interface DirectoryStatus {
-    exists: boolean;
-    fileCount: number;
-    path: string;
-    sizeBytes: number;
-}
-export interface StatusFile {
-    mtimeMs: number;
-    path: string;
-    size: number;
-}
-export declare function collectDirectorySummary(dir: string): DirectoryStatus;
-export declare function listFiles(dir: string): StatusFile[];
-export declare function pruneEmptyDir(dir: string): void;

package/dist/process/files/dotenv.d.ts

@@ -1,2 +0,0 @@
-export declare function parseDotenv(filePath: string): Record<string, string>;
-export declare function parseDotenvString(source: string): Record<string, string>;

package/dist/process/files/file-snapshot.d.ts

@@ -1,34 +0,0 @@
-export interface FileSnapshotIdentity {
-    readonly ctimeNs: bigint;
-    readonly dev: bigint;
-    readonly ino: bigint;
-    readonly mtimeNs: bigint;
-    readonly size: bigint;
-}
-export interface ReadOnlyOpenFlagConstants {
-    readonly O_NOFOLLOW?: number;
-    readonly O_RDONLY: number;
-}
-/**
- * Returns the strongest read-only, no-follow open flags available on the host.
- * Windows does not expose O_NOFOLLOW, so callers must combine its read-only
- * open with the path/handle identity fencing in this module.
- */
-export declare function readOnlyNoFollowOpenFlags(platform: NodeJS.Platform, constants: Readonly<ReadOnlyOpenFlagConstants>): number;
-/**
- * Compares snapshots produced through one filesystem observation channel, such
- * as two path stats or two stats from the same open handle.
- */
-export declare function sameFileSnapshot(left: Readonly<FileSnapshotIdentity>, right: Readonly<FileSnapshotIdentity>): boolean;
-/**
- * Compares a path lstat snapshot with a snapshot from its opened handle.
- *
- * Windows path and handle stats are separate observation channels. Node/libuv
- * can report dev=0 for a path lstat while fstat reports the real nonzero volume
- * identifier for the same NTFS file, and their timestamp representations can
- * differ even when both observations name the same file. Device, inode, and
- * size therefore form the Windows cross-channel identity fence. Callers must
- * still compare complete snapshots before and after within each individual
- * channel so timestamp or size mutations remain fail-closed.
- */
-export declare function samePathAndHandleFileSnapshot(pathIdentity: Readonly<FileSnapshotIdentity>, handleIdentity: Readonly<FileSnapshotIdentity>, platform: NodeJS.Platform): boolean;

package/dist/process/files/json-file.d.ts

@@ -1,11 +0,0 @@
-export declare function readProperty(value: object, key: PropertyKey): unknown;
-export declare function serializeJson(value: unknown, label: string): string;
-export declare function errorMessage(error: unknown): string;
-export interface AtomicWriteOptions {
-    attempts?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-}
-export declare function writeJsonFileAtomicWithRetry(filePath: string, value: unknown, options?: AtomicWriteOptions): void;
-export declare function writeTextFileAtomicWithRetry(filePath: string, text: string, options?: AtomicWriteOptions): void;
-export declare function isRetryableAtomicReplaceError(error: unknown): boolean;

package/dist/process/files/paths.d.ts

@@ -1,3 +0,0 @@
-export declare function isPathWithin(root: string, candidate: string): boolean;
-/** The platform path with forward-slash separators. */
-export declare function posixPath(value: string): string;

package/dist/process/files/product-dir.d.ts

@@ -1 +0,0 @@
-export declare function resolveProductDir(cwd: string, explicitDir?: string | null): string;

package/dist/process/files/temp-dir.d.ts

@@ -1,11 +0,0 @@
-export interface MakeTempDirOptions {
-    parentDir?: string | null;
-}
-export interface RemoveTempDirOptions {
-    maxRetries?: number | null;
-    retryDelay?: number | null;
-}
-export declare function defaultTempDirParent(): string;
-export declare function makeTempDir(prefix: string, options?: Readonly<MakeTempDirOptions>): string;
-export declare function makeTempDirAsync(prefix: string, options?: Readonly<MakeTempDirOptions>): Promise<string>;
-export declare function removeTempDir(dir?: string | null, options?: Readonly<RemoveTempDirOptions>): void;

package/dist/process/host/metadata.d.ts

@@ -1,6 +0,0 @@
-export interface PackageMetadata extends Record<string, unknown> {
-    version: string;
-}
-export declare function readPackageMetadata(): PackageMetadata;
-export declare function safeHostname(): null | string;
-export declare function safeUsername(): null | string;

package/dist/process/host/platform.d.ts

@@ -1,57 +0,0 @@
-export declare const SUPPORTED_PLATFORMS: readonly ["darwin", "linux", "win32"];
-export declare const SUPPORTED_ARCHITECTURES: readonly ["arm64", "x64"];
-export type SupportedPlatform = (typeof SUPPORTED_PLATFORMS)[number];
-export type SupportedArchitecture = (typeof SUPPORTED_ARCHITECTURES)[number];
-export type LinuxLibc = "glibc" | "musl";
-export interface PlatformTarget {
-    readonly arch: SupportedArchitecture;
-    readonly platform: SupportedPlatform;
-}
-export declare const SUPPORTED_PLATFORM_TARGETS: readonly (Readonly<{
-    arch: "arm64";
-    platform: "darwin";
-}> | Readonly<{
-    arch: "x64";
-    platform: "darwin";
-}> | Readonly<{
-    arch: "arm64";
-    platform: "linux";
-}> | Readonly<{
-    arch: "x64";
-    platform: "linux";
-}> | Readonly<{
-    arch: "x64";
-    platform: "win32";
-}>)[];
-export declare class UnsupportedPlatformTargetError extends Error {
-    readonly arch: string;
-    readonly code = "TESTKIT_PLATFORM_TARGET_UNSUPPORTED";
-    readonly platform: string;
-    constructor(platform: string, arch: string, label?: string);
-}
-export declare function platformTargetKey(target: Readonly<PlatformTarget>): string;
-export declare function currentPlatformTarget(platform?: NodeJS.Platform, arch?: string): PlatformTarget;
-export declare function currentLinuxLibc(): LinuxLibc | null;
-export declare function assertSupportedPlatformTarget(target: Readonly<PlatformTarget>, label?: string): void;
-export declare function isSupportedPlatform(value: string): value is SupportedPlatform;
-export declare function isSupportedArchitecture(value: string): value is SupportedArchitecture;
-export interface CommandResolutionOptions {
-    env?: Readonly<NodeJS.ProcessEnv>;
-    extraWindowsDirs?: readonly string[];
-    platform?: NodeJS.Platform;
-}
-export interface PreparedSpawnCommand {
-    args: string[];
-    command: string;
-    windowsVerbatimArguments: boolean;
-}
-export declare function isWindows(platform?: NodeJS.Platform): boolean;
-export declare function commandName(name: unknown, platform?: NodeJS.Platform): string;
-export declare function executableName(name: unknown, platform?: NodeJS.Platform): string;
-export declare function resolveCommandForSpawn(name: unknown, options?: Readonly<CommandResolutionOptions>): string;
-export declare function prepareCommandForSpawn(name: unknown, args?: unknown, options?: Readonly<CommandResolutionOptions>): PreparedSpawnCommand;
-export declare function packageBinPath(cwd: null | string | undefined, name: unknown, platform?: NodeJS.Platform): string;
-export declare function shellQuote(value: unknown, platform?: NodeJS.Platform): string;
-export declare function joinPathList(entries: readonly unknown[], platform?: NodeJS.Platform): string;
-export declare function dockerHostAddress<T>(host: T, platform?: NodeJS.Platform): T | "host.docker.internal";
-export declare function shouldUseDockerHostNetwork(platform?: NodeJS.Platform): boolean;

package/dist/process/host-command.d.ts

@@ -1,4 +0,0 @@
-import type { ManagedProcessResult } from "./process.js";
-import { type ManagedHostProcessRequest } from "./host-process.js";
-export declare function runManagedHostCommand(request: Readonly<ManagedHostProcessRequest>): Promise<ManagedProcessResult>;
-export declare function requireManagedHostCommandSuccess(displayLabel: string, result: Readonly<ManagedProcessResult>): ManagedProcessResult;

package/dist/process/host-inspection-command.d.ts

@@ -1,13 +0,0 @@
-export declare const DARWIN_PS_EXECUTABLE = "/bin/ps";
-export declare const HOST_POSIX_INSPECTION_ENVIRONMENT: Readonly<Record<string, string>>;
-export interface WindowsHostPowerShellCommand {
-    readonly environment: Readonly<Record<string, string>>;
-    readonly executable: string;
-    readonly systemRoot: string;
-}
-/**
- * Returns the host-owned Windows bootstrap captured when this module loaded.
- * Consumer request environments and later ambient PATH mutation cannot replace
- * the executable used for authoritative process inspection.
- */
-export declare function requireWindowsHostPowerShellCommand(): WindowsHostPowerShellCommand;

package/dist/process/host-process.d.ts

@@ -1,19 +0,0 @@
-import { type ManagedProcessRequest, type ManagedProcessResult, type SupervisedProcessHandle, type SupervisedProcessLiveHandle, type SupervisedProcessOutputMode } from "./process.js";
-export interface ManagedHostProcessRequest extends Omit<ManagedProcessRequest, "env" | "signal"> {
-    readonly env?: Readonly<NodeJS.ProcessEnv>;
-    readonly signal?: AbortSignal;
-}
-export interface SupervisedHostProcessRequest extends ManagedHostProcessRequest {
-    readonly outputMode: SupervisedProcessOutputMode;
-    readonly recoveryIdentity?: "capture";
-}
-export interface SupervisedHostProcessWithoutRecoveryRequest extends Omit<SupervisedHostProcessRequest, "recoveryIdentity"> {
-    readonly recoveryIdentity: "none";
-}
-export declare function runManagedHostProcess(request: Readonly<ManagedHostProcessRequest>): Promise<ManagedProcessResult>;
-export declare function startManagedHostProcess(request: Readonly<SupervisedHostProcessWithoutRecoveryRequest>): SupervisedProcessLiveHandle;
-export declare function startManagedHostProcess(request: Readonly<SupervisedHostProcessRequest>): SupervisedProcessHandle;
-export declare function managedHostProcessInfrastructureError(displayLabel: string, result: Readonly<ManagedProcessResult>): Error | null;
-export declare function normalizeManagedHostEnvironment(environment?: Readonly<NodeJS.ProcessEnv>, platform?: NodeJS.Platform): Record<string, string>;
-export declare function resolveManagedHostExecutable(executable: string, cwd: string, environment: Readonly<Record<string, string>>, platform?: NodeJS.Platform): string;
-export declare function resolveManagedHostExecutableIfAvailable(executable: string, cwd: string, environment: Readonly<Record<string, string>>, platform?: NodeJS.Platform): string | null;

package/dist/process/index.d.ts

@@ -1,9 +0,0 @@
-export { runManagedProcess, ProcessExitedBeforeReadyError, startSupervisedProcess, terminateAttributedProcessLineage, terminateOwnedPosixProcessGroup, type AttributedProcessLineageTerminationRequest, type ManagedProcessCancellationSignal, type ManagedProcessRequest, type ManagedProcessResult, type OwnedPosixProcessGroupTerminationRequest, type SupervisedProcessHandle, type SupervisedProcessLiveHandle, type SupervisedProcessWithoutRecoveryRequest, type SupervisedProcessOutputMode, type SupervisedProcessRecoveryIdentity, type SupervisedProcessReady, type SupervisedProcessRequest, } from "./process.js";
-export { managedHostProcessInfrastructureError, normalizeManagedHostEnvironment, resolveManagedHostExecutable, resolveManagedHostExecutableIfAvailable, runManagedHostProcess, startManagedHostProcess, type ManagedHostProcessRequest, type SupervisedHostProcessRequest, type SupervisedHostProcessWithoutRecoveryRequest, } from "./host-process.js";
-export { requireManagedHostCommandSuccess, runManagedHostCommand } from "./host-command.js";
-export { resolvePosixCommandShell } from "./command-shell.js";
-export { captureOutput, type CaptureOutputOptions, type OutputLineHandler } from "./capture-output.js";
-export { captureProcessCreationIdentity, observeProcessCreationIdentity, processCreationIdentityMatches, type ProcessCreationIdentityObservation, type ProcessCreationIdentityObservationOptions, } from "./process-identity.js";
-export { createInvocationProcessEnvironment, createNativeInvocationProcessEnvironment, ENGINE_PROCESS_RESERVED_ENVIRONMENT_KEYS, type InvocationProcessEnvironment, type NativeInvocationProcessEnvironmentOptions, } from "./environment.js";
-export { installManagedProcessEnvironmentOverlay, managedProcessEnvironmentOverlayInstallerSource, MANAGED_PROCESS_ENVIRONMENT_OVERLAY_STATE_SYMBOL, type ManagedProcessEnvironmentOverlayOptions, } from "./environment-overlay.js";
-export { DEFAULT_SHUTDOWN_TIMEOUT_MS } from "./shutdown.js";

package/dist/process/lifecycle-fence.d.ts

@@ -1,10 +0,0 @@
-import { type ProcessLockOptions } from "./locks.js";
-declare const PRODUCT_LIFECYCLE_FENCE_BRAND: unique symbol;
-export interface ProductLifecycleFence {
-    readonly [PRODUCT_LIFECYCLE_FENCE_BRAND]: true;
-    readonly productDir: string;
-}
-export declare function resolveProductLifecycleLockPath(productDir: string): string;
-export declare function withProductLifecycleFence<Result>(productDir: string, operation: (fence: ProductLifecycleFence) => Result | PromiseLike<Result>, options?: Readonly<Pick<ProcessLockOptions, "signal">>): Promise<Result>;
-export declare function requireProductLifecycleFenceProductDir(fence: Readonly<ProductLifecycleFence>): string;
-export {};

package/dist/process/locks.d.ts

@@ -1,28 +0,0 @@
-interface ProcessLockIdentityObservation {
-    readonly checkedAtMs: number;
-    readonly ownerKey: string;
-}
-export type ProcessLockIdentityObservations = Map<string, ProcessLockIdentityObservation>;
-export interface ProcessLockOptions {
-    /**
-     * Allows reclaiming an aged owner from another hostname only when the lock
-     * path itself is guaranteed to be private to this host.
-     */
-    readonly hostScope?: "current-host" | "shared";
-    readonly identityObservations?: ProcessLockIdentityObservations;
-    readonly retryIntervalMs?: number;
-    readonly signal?: AbortSignal;
-    /** Null, and the default, means wait until ownership changes or aborts. */
-    readonly timeoutMs?: number | null;
-}
-export type ProcessLockAttempt<Result> = {
-    readonly acquired: false;
-} | {
-    readonly acquired: true;
-    readonly value: Result;
-};
-type ProcessLockProbe = "active" | "absent";
-export declare function withProcessLock<Result>(lockPath: string, operation: () => Result | PromiseLike<Result>, options?: Readonly<ProcessLockOptions>): Promise<Result>;
-export declare function tryWithProcessLock<Result>(lockPath: string, operation: () => Result | PromiseLike<Result>, options?: Readonly<Omit<ProcessLockOptions, "timeoutMs">>): Promise<ProcessLockAttempt<Result>>;
-export declare function probeProcessLock(lockPath: string, options?: Readonly<ProcessLockOptions>): ProcessLockProbe;
-export {};

package/dist/process/process-contracts.d.ts

@@ -1,78 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-export interface ManagedProcessCancellationSignal {
-    readonly aborted: boolean;
-    addEventListener(type: "abort", listener: () => void, options?: Readonly<{
-        once?: boolean;
-    }>): void;
-    removeEventListener(type: "abort", listener: () => void): void;
-}
-export interface ManagedProcessRequest {
-    readonly args: readonly string[];
-    readonly cwd: string;
-    readonly displayLabel: string;
-    readonly env: Readonly<Record<string, string>>;
-    readonly executable: string;
-    readonly signal: ManagedProcessCancellationSignal;
-    readonly timeoutMs: number;
-    readonly windowsVerbatimArguments?: boolean;
-}
-export type SupervisedProcessOutputMode = "bounded-capture" | "caller-drained";
-export interface SupervisedProcessRequest extends Omit<ManagedProcessRequest, "timeoutMs"> {
-    readonly recoveryIdentity?: "capture";
-    readonly shutdownTimeoutMs?: number;
-    readonly outputMode: SupervisedProcessOutputMode;
-    readonly timeoutMs: number | null;
-}
-/** Live supervision without publishing an identity for later recovery. */
-export interface SupervisedProcessWithoutRecoveryRequest extends Omit<SupervisedProcessRequest, "recoveryIdentity"> {
-    readonly recoveryIdentity: "none";
-}
-export interface ManagedProcessResult {
-    readonly cancelled: boolean;
-    readonly error: Error | null;
-    readonly exitCode: number | null;
-    readonly exitSignal: NodeJS.Signals | null;
-    readonly outputLimitExceeded: boolean;
-    readonly stderr: string;
-    readonly stdout: string;
-    /** An observed cleanup failure. Null does not prove that every descendant exited. */
-    readonly terminationError: Error | null;
-    readonly timedOut: boolean;
-}
-export interface SupervisedProcessReady {
-    readonly pid: number;
-    readonly recovery: SupervisedProcessRecoveryIdentity;
-}
-export interface SupervisedProcessRecoveryIdentity {
-    readonly creationIdentity: string;
-    readonly processGroupId: number | null;
-}
-/** A live child handle plus the identity needed for later best-effort recovery. */
-export interface SupervisedProcessHandle extends SupervisedProcessLiveHandle {
-    readonly ready: Promise<SupervisedProcessReady>;
-}
-/** Controls the child through its live handle, without persisted recovery metadata. */
-export interface SupervisedProcessLiveHandle {
-    readonly completion: Promise<ManagedProcessResult>;
-    readonly stderr: Readable;
-    readonly stdin: Writable;
-    readonly stdout: Readable;
-    readonly pid: number;
-    readonly shutdownTimeoutMs: number;
-    readonly shutdownDeadlineAt: number | null;
-    onShutdownStarted(listener: (deadlineAt: number) => void): () => void;
-    stop(deadlineAt?: number): Promise<ManagedProcessResult>;
-}
-export interface AttributedProcessLineageTerminationRequest {
-    readonly displayLabel: string;
-    readonly expectedCreationIdentity?: string;
-    readonly pid: number;
-    readonly signal: NodeJS.Signals;
-}
-export interface OwnedPosixProcessGroupTerminationRequest {
-    readonly displayLabel: string;
-    readonly graceMs: number;
-    readonly leaderCreationIdentity: string;
-    readonly leaderPid: number;
-    readonly processGroupId: number;
-}

package/dist/process/process-group.d.ts

@@ -1,12 +0,0 @@
-export interface ProcessGroupCleanupOptions {
-    readonly forceWaitMs?: number;
-    readonly initialSignalSent?: boolean;
-    readonly graceMs?: number;
-    readonly remainingMs?: () => number;
-    readonly groupExists?: (processGroupId: number) => boolean;
-    readonly platform?: NodeJS.Platform;
-    readonly sendSignal?: (processGroupId: number, signal: NodeJS.Signals) => void;
-    readonly sleep?: (ms: number) => Promise<void>;
-}
-export declare function cleanupExitedProcessGroup(pid: number, options?: Readonly<ProcessGroupCleanupOptions>): Promise<Error | null>;
-export declare function processGroupExists(pid: number): boolean;

package/dist/process/process-identity.d.ts

@@ -1,27 +0,0 @@
-interface BoundedProcessIdentityQuery {
-    readonly args: readonly string[];
-    readonly environment: Readonly<Record<string, string>>;
-    readonly executable: string;
-    readonly timeoutMs: number;
-    readonly windowsHide: boolean;
-}
-export type ProcessCreationIdentityObservation = "different" | "matches" | "unknown";
-export interface ProcessCreationIdentityObservationOptions {
-    captureIdentity?(pid: number): string | null;
-    inspectLiveness?(pid: number): "absent" | "alive" | "unknown";
-}
-export declare function captureProcessCreationIdentity(pid: unknown): string | null;
-export declare function processCreationIdentityMatches(pid: unknown, expectedIdentity: unknown): boolean;
-export declare function observeProcessCreationIdentity(pid: unknown, expectedIdentity: unknown, options?: Readonly<ProcessCreationIdentityObservationOptions>): ProcessCreationIdentityObservation;
-export declare function parseWindowsProcessCreationIdentity(identity: string): string | null;
-export declare function parseLinuxProcessCreationIdentity(pid: number, stat: string): string;
-/**
- * Parses the C-locale `ps -o pid=,lstart=` representation used by both the
- * single-process identity boundary and the bounded Darwin process-table
- * snapshot. Whitespace is canonicalized so the two producers cannot drift.
- */
-export declare function parseDarwinProcessCreationIdentity(pid: number, output: string): string;
-export declare function windowsProcessCreationIdentityScript(pid: number): string;
-export declare function runBoundedProcessIdentityQuery(query: Readonly<BoundedProcessIdentityQuery>): string;
-export declare function inspectProcessLiveness(pid: number): "absent" | "alive" | "unknown";
-export {};

package/dist/process/process-limits.d.ts

@@ -1,6 +0,0 @@
-/**
- * Maximum combined stdout and stderr bytes retained by supervised process
- * capture. Process supervision owns this resource limit independently of any
- * engine request or result protocol.
- */
-export declare const MAX_SUPERVISED_PROCESS_CAPTURE_BYTES: number;

package/dist/process/process.d.ts

@@ -1,12 +0,0 @@
-import { type ManagedProcessRequest, type ManagedProcessResult, type SupervisedProcessHandle, type SupervisedProcessLiveHandle, type SupervisedProcessWithoutRecoveryRequest, type SupervisedProcessRequest } from "./process-contracts.js";
-export { type AttributedProcessLineageTerminationRequest, type ManagedProcessCancellationSignal, type ManagedProcessRequest, type ManagedProcessResult, type OwnedPosixProcessGroupTerminationRequest, type SupervisedProcessHandle, type SupervisedProcessLiveHandle, type SupervisedProcessWithoutRecoveryRequest, type SupervisedProcessOutputMode, type SupervisedProcessRecoveryIdentity, type SupervisedProcessReady, type SupervisedProcessRequest, } from "./process-contracts.js";
-export { terminateAttributedProcessLineage, terminateOwnedPosixProcessGroup } from "./recovery.js";
-export { cleanupExitedProcessGroup } from "./process-group.js";
-export declare function runManagedProcess(request: Readonly<ManagedProcessRequest>): Promise<ManagedProcessResult>;
-export declare class ProcessExitedBeforeReadyError extends Error {
-    readonly exitCode: number | null;
-    readonly exitSignal: NodeJS.Signals | null;
-    constructor(exitCode: number | null, exitSignal: NodeJS.Signals | null);
-}
-export declare function startSupervisedProcess(request: Readonly<SupervisedProcessWithoutRecoveryRequest>): SupervisedProcessLiveHandle;
-export declare function startSupervisedProcess(request: Readonly<SupervisedProcessRequest>): SupervisedProcessHandle;

package/dist/process/readiness.d.ts

@@ -1,43 +0,0 @@
-import type { RuntimeSocket } from "./runtime-socket.js";
-export interface ReadyProcess {
-    completion: PromiseLike<ReadyProcessCompletion>;
-}
-export interface ReadyProcessCompletion {
-    error?: Error | null;
-    exitCode: null | number;
-    exitSignal?: NodeJS.Signals | null;
-    terminationError?: Error | null;
-}
-export interface WaitForReadyOptions {
-    name: string;
-    process: ReadyProcess;
-    signal?: AbortSignal | null;
-    timeoutMs: number;
-    url: string;
-}
-export declare const DEFAULT_READY_TIMEOUT_MS = 120000;
-export declare function waitForReady({ name, url, timeoutMs, process, signal, }: Readonly<WaitForReadyOptions>): Promise<void>;
-export declare class ServiceReadinessTimeoutError extends Error {
-    constructor(message: string);
-}
-export declare class ServiceExitedBeforeReadyError extends Error {
-    readonly outcome: string;
-    constructor(message: string, outcome: string, options?: ErrorOptions);
-}
-export declare function serviceCompletionError(name: string, result: Readonly<ReadyProcessCompletion>, phase?: "before becoming ready" | "unexpectedly"): Error;
-export interface EndpointReadinessSuccessfulAttempt {
-    durationMs: number;
-    error?: undefined;
-    host: string;
-    ok: true;
-    port: number;
-}
-export interface EndpointReadinessFailedAttempt {
-    durationMs: number;
-    error: string;
-    host: string;
-    ok: false;
-    port: number;
-}
-export type EndpointReadinessAttempt = EndpointReadinessFailedAttempt | EndpointReadinessSuccessfulAttempt;
-export declare function connectEndpoint(endpoint: Readonly<RuntimeSocket>, timeoutMs: number, signal?: AbortSignal): Promise<EndpointReadinessAttempt>;

package/dist/process/recovery.d.ts

@@ -1,3 +0,0 @@
-import type { AttributedProcessLineageTerminationRequest, OwnedPosixProcessGroupTerminationRequest } from "./process-contracts.js";
-export declare function terminateAttributedProcessLineage(request: Readonly<AttributedProcessLineageTerminationRequest>): Promise<void>;
-export declare function terminateOwnedPosixProcessGroup(request: Readonly<OwnedPosixProcessGroupTerminationRequest>): Promise<void>;

package/dist/process/runs/inspection.d.ts

@@ -1,5 +0,0 @@
-import { type RunManifest } from "./manifest.js";
-export declare function isRunManifestActive(manifest: Readonly<RunManifest>): boolean;
-export declare function inspectRunManifests(productDir: string, runId?: string): Array<RunManifest & {
-    active: boolean;
-}>;