@wringer/core 0.0.0 → 0.1.1

package/dist/decide-guard.d.ts

@@ -0,0 +1,12 @@
+import type { RunView } from './build-run-view.ts';
+import type { Mode } from './run-events.ts';
+import { WringerError } from './wringer-error.ts';
+export interface GuardInput {
+    readonly needsRun: boolean;
+    readonly needsDoctor: boolean;
+    readonly run: RunView | undefined;
+    readonly targetName: string;
+    readonly mode: Mode;
+    readonly fingerprintChanged: boolean;
+}
+export declare function decideGuard(input: GuardInput): WringerError | null;

package/dist/define-driver.d.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+import type { Driver, DriverCheckDefinition, DriverCommand, DriverCommandHelper, DriverSession, Fence, ServiceDefinition } from './types.ts';
+export interface DriverDefinition<Name extends string, Options, OptionsInput, TargetConfig, ConfigInput, Client> {
+    readonly name: Name;
+    readonly options: z.ZodType<Options, OptionsInput>;
+    readonly targetConfig: z.ZodType<TargetConfig, ConfigInput>;
+    readonly services?: Readonly<Record<string, ServiceDefinition<Options, TargetConfig>>>;
+    readonly client: (session: DriverSession<Options, TargetConfig>, fence: Fence) => Client;
+    readonly commands?: (command: DriverCommandHelper<Options, TargetConfig, Client>) => readonly DriverCommand<Options, TargetConfig, Client>[];
+    readonly checks?: readonly DriverCheckDefinition<Options, TargetConfig, Client>[];
+}
+export type DriverFactory<Name extends string, OptionsInput, ConfigInput, Client> = (options: OptionsInput) => Driver<Name, Client, ConfigInput>;
+export declare function defineDriver<Name extends string, Options, OptionsInput, TargetConfig, ConfigInput, Client>(definition: DriverDefinition<Name, Options, OptionsInput, TargetConfig, ConfigInput, Client>): DriverFactory<Name, OptionsInput, ConfigInput, Client>;

package/dist/dispatch.d.ts

@@ -0,0 +1,10 @@
+import type { Envelope } from './envelope.ts';
+import type { ExitCode } from './error-codes.ts';
+import type { Session, Wringer } from './types.ts';
+export interface DispatchResult {
+    readonly envelope: Envelope;
+    readonly exitCode: ExitCode;
+    readonly late: Promise<void>;
+}
+export declare const defaultTimeoutMs = 120000;
+export declare function dispatch(wringer: Wringer, path: readonly string[], rawArgs: unknown, session: Session): Promise<DispatchResult>;

package/dist/envelope.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+export declare const evidenceSchema: z.ZodObject<{
+    kind: z.ZodString;
+    path: z.ZodString;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export type Evidence = z.infer<typeof evidenceSchema>;
+export declare const envelopeErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        "check-failed": "check-failed";
+        "doctor-required": "doctor-required";
+        environment: "environment";
+        internal: "internal";
+        "not-running": "not-running";
+        "read-only": "read-only";
+        "target-not-allowed": "target-not-allowed";
+        timeout: "timeout";
+        usage: "usage";
+    }>;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const envelopeSchema: z.ZodObject<{
+    wringer: z.ZodLiteral<1>;
+    ok: z.ZodBoolean;
+    command: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+    instance: z.ZodNullable<z.ZodString>;
+    feature: z.ZodNullable<z.ZodString>;
+    sha: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNumber;
+    data: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        path: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+    cursors: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    truncatedPath: z.ZodOptional<z.ZodString>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            "check-failed": "check-failed";
+            "doctor-required": "doctor-required";
+            environment: "environment";
+            internal: "internal";
+            "not-running": "not-running";
+            "read-only": "read-only";
+            "target-not-allowed": "target-not-allowed";
+            timeout: "timeout";
+            usage: "usage";
+        }>;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Envelope = z.infer<typeof envelopeSchema>;
+export declare const streamEventSchema: z.ZodObject<{
+    wringer: z.ZodLiteral<1>;
+    event: z.ZodString;
+    data: z.ZodUnknown;
+}, z.core.$strict>;
+export type StreamEvent = z.infer<typeof streamEventSchema>;

package/dist/error-codes.d.ts

@@ -0,0 +1,25 @@
+export declare const errorCodes: readonly ['check-failed', 'usage', 'read-only', 'doctor-required', 'not-running', 'target-not-allowed', 'environment', 'internal', 'timeout'];
+export type ErrorCode = (typeof errorCodes)[number];
+export type ExitCode = 0 | 1 | 2 | 3 | 4 | 5;
+export declare const exitCodeFor: {
+    readonly 'check-failed': 1;
+    readonly usage: 2;
+    readonly 'read-only': 3;
+    readonly 'doctor-required': 3;
+    readonly 'not-running': 3;
+    readonly 'target-not-allowed': 3;
+    readonly environment: 4;
+    readonly internal: 4;
+    readonly timeout: 5;
+};
+export declare const defaultMessageFor: {
+    readonly 'check-failed': 'A check failed.';
+    readonly usage: 'The command or its arguments are not valid.';
+    readonly 'read-only': 'The target refused a write.';
+    readonly 'doctor-required': 'The doctor has not passed on this run.';
+    readonly 'not-running': 'The target has no running run.';
+    readonly 'target-not-allowed': 'The command does not run on this target.';
+    readonly environment: 'The environment failed.';
+    readonly internal: 'wringer failed with an internal error.';
+    readonly timeout: 'The command ran past its deadline.';
+};

package/dist/find-cancel-failure.d.ts

@@ -0,0 +1,2 @@
+import type { WringerError } from './wringer-error.ts';
+export declare function findCancelFailure(failures: readonly WringerError[]): WringerError | null;

package/dist/find-colliding-service-key.d.ts

@@ -0,0 +1,5 @@
+export interface DriverServices {
+    readonly name: string;
+    readonly serviceNames: readonly string[];
+}
+export declare function findCollidingServiceKey(drivers: readonly DriverServices[]): string | null;

package/dist/find-own-value.d.ts

@@ -0,0 +1 @@
+export declare function findOwnValue<Value>(record: Readonly<Record<string, Value>>, key: string): Value | undefined;

package/dist/find-remote-stop-failure.d.ts

@@ -0,0 +1,2 @@
+import type { ProcessResult } from './run-process.ts';
+export declare function findRemoteStopFailure(stops: readonly PromiseSettledResult<ProcessResult>[]): string | null;

package/dist/find-verdict-refusal.d.ts

@@ -0,0 +1,3 @@
+import type { RunView } from './build-run-view.ts';
+import { WringerError } from './wringer-error.ts';
+export declare function findVerdictRefusal(read: RunView | undefined, current: RunView | undefined): WringerError | null;

package/dist/follow-process.d.ts

@@ -0,0 +1,10 @@
+export interface FollowProcessRequest {
+    readonly argv: readonly string[];
+    readonly signal: AbortSignal;
+    readonly onLine: (line: string) => void;
+}
+export interface FollowResult {
+    readonly exitCode: number;
+    readonly stderr: string;
+}
+export declare function followProcess(request: FollowProcessRequest): Promise<FollowResult>;

package/dist/get-lock-value.d.ts

@@ -0,0 +1,2 @@
+import type { FileLockResult } from '@zgeoff/std/with-file-lock';
+export declare function getLockValue<Value>(path: string, result: FileLockResult<Value>): Value;

package/dist/get-target.d.ts

@@ -0,0 +1,2 @@
+import type { TargetDefinition, Wringer } from './types.ts';
+export declare function getTarget(wringer: Wringer, name: string): TargetDefinition;

package/dist/host.d.ts

@@ -0,0 +1,19 @@
+import type { ProcessResult } from './run-process.ts';
+export type Access = 'read-write' | 'read-only';
+export interface HostRequest {
+    readonly argv: readonly string[];
+    readonly access: Access;
+    readonly stdin?: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+export interface FollowRequest {
+    readonly argv: readonly string[];
+    readonly access: Access;
+    readonly signal: AbortSignal;
+    readonly onLine: (line: string) => void;
+}
+export interface Host {
+    readonly kind: 'local' | 'ssh';
+    readonly run: (request: HostRequest) => Promise<ProcessResult>;
+    readonly follow: (request: FollowRequest) => Promise<number>;
+}

package/dist/index.d.ts

@@ -1 +1,59 @@
+export { bindDrivers } from './bind-drivers.ts';
+export type { BoundHelpers } from './bind-drivers.ts';
+export { buildEnvelope } from './build-envelope.ts';
+export type { EnvelopeInput } from './build-envelope.ts';
+export { buildEnvelopeJSONSchema } from './build-envelope-json-schema.ts';
+export { buildRunView } from './build-run-view.ts';
+export type { DoctorState, RunView, SupervisorInfo } from './build-run-view.ts';
+export { buildRunPaths, buildStatePaths } from './build-state-paths.ts';
+export type { RunPaths, StatePaths } from './build-state-paths.ts';
+export { createDirectory } from './create-directory.ts';
+export { createFileState, eventSizeCapBytes, pointersSchema } from './create-file-state.ts';
+export type { FileStateOptions, Pointers, StatePort } from './create-file-state.ts';
+export { createNodeStateFileSystem } from './create-node-state-file-system.ts';
+export { createRepoState } from './create-repo-state.ts';
+export type { StateFileSystem } from './create-node-state-file-system.ts';
+export { createWringer, defaultStateDir } from './create-wringer.ts';
+export type { WringerBuilder, WringerOptions } from './create-wringer.ts';
+export { defineDriver } from './define-driver.ts';
+export { findOwnValue } from './find-own-value.ts';
+export type { DriverDefinition, DriverFactory } from './define-driver.ts';
+export { dataCapBytes } from './cap-data.ts';
+export { defaultTimeoutMs, dispatch } from './dispatch.ts';
+export type { DispatchResult } from './dispatch.ts';
+export { envelopeErrorSchema, envelopeSchema, evidenceSchema, streamEventSchema, } from './envelope.ts';
+export type { Envelope, Evidence, StreamEvent } from './envelope.ts';
 export { envelopeVersion } from './envelope-version.ts';
+export { defaultMessageFor, errorCodes, exitCodeFor } from './error-codes.ts';
+export type { ErrorCode, ExitCode } from './error-codes.ts';
+export type { Access, FollowRequest, Host, HostRequest } from './host.ts';
+export { isErrorCode } from './is-error-code.ts';
+export { launchLineSchema } from './launch-line-schema.ts';
+export type { LaunchLine } from './launch-line-schema.ts';
+export { local } from './local.ts';
+export { defaultRefusalHint } from './make-fence.ts';
+export { makeProcessSupervisorPort } from './make-process-supervisor-port.ts';
+export type { ProcessSupervisorOptions } from './make-process-supervisor-port.ts';
+export { emptyFingerprint } from './parse-patch-id.ts';
+export { parseReportBlock } from './parse-report-block.ts';
+export type { ReportBlockResult } from './parse-report-block.ts';
+export { readFingerprint } from './read-fingerprint.ts';
+export type { FingerprintHost, FingerprintRequest } from './read-fingerprint.ts';
+export { readStreamLines } from './read-stream-lines.ts';
+export { readText } from './read-text.ts';
+export { renderReportMarkdown } from './render-report-markdown.ts';
+export { reportSchema, verdictSchema } from './report-schema.ts';
+export type { FeatureStatus, Report, Verdict } from './report-schema.ts';
+export { checkResultSchema, endpointsSchema, modeSchema, runEventSchema, runIDSchema, } from './run-events.ts';
+export type { CheckResult, Endpoints, Mode, RunEvent, RunID } from './run-events.ts';
+export { runProcess } from './run-process.ts';
+export type { ProcessRequest, ProcessResult } from './run-process.ts';
+export type { RunStatus } from './append-run-event.ts';
+export { runSupervisorProcess } from './run-supervisor-process.ts';
+export { ssh } from './ssh.ts';
+export type { PrefixLayer, SSHOptions } from './ssh.ts';
+export { supervisorCommandName } from './supervisor-protocol.ts';
+export type * from './types.ts';
+export { createNodeRepoHost } from './create-node-repo-host.ts';
+export { WringerError } from './wringer-error.ts';
+export type { WringerErrorDetails } from './wringer-error.ts';

package/dist/is-error-code.d.ts

@@ -0,0 +1 @@
+export declare function isErrorCode(error: unknown, code: string): boolean;

package/dist/keep-cancelled-call.d.ts

@@ -0,0 +1 @@
+export declare function keepCancelledCall(cancelled: Promise<unknown>[], calling: Promise<unknown>, signal: AbortSignal): void;

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

@@ -0,0 +1 @@
+export declare function killProcessGroup(pid: number, signal?: NodeJS.Signals): void;

package/dist/launch-line-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const launchLineSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type LaunchLine = Readonly<z.infer<typeof launchLineSchema>>;

package/dist/listen-supervisor-socket.d.ts

@@ -0,0 +1,8 @@
+import type { SupervisorConnectionOptions } from './answer-supervisor-connection.ts';
+export interface SupervisorSocketOptions extends SupervisorConnectionOptions {
+    readonly path: string;
+}
+export interface SupervisorSocket {
+    readonly close: (graceMs: number) => Promise<void>;
+}
+export declare function listenSupervisorSocket(options: SupervisorSocketOptions): Promise<SupervisorSocket>;

package/dist/local.d.ts

@@ -0,0 +1,2 @@
+import type { Host } from './host.ts';
+export declare function local(): Host;

package/dist/make-fence.d.ts

@@ -0,0 +1,8 @@
+import type { Access } from './host.ts';
+import type { Fence } from './types.ts';
+export declare const defaultRefusalHint = "This target is read-only. Stop and report the write you needed.";
+export interface FenceOptions {
+    readonly access: Access;
+    readonly hint: string;
+}
+export declare function makeFence(options: FenceOptions): Fence;

package/dist/make-fenced-exec.d.ts

@@ -0,0 +1,10 @@
+import type { Access, Host } from './host.ts';
+import type { DriverExec, RepoExec } from './types.ts';
+export interface FencedExecOptions {
+    readonly host: Host;
+    readonly access: Access;
+    readonly hint: string;
+    readonly signal: AbortSignal;
+}
+export declare function makeRepoExec(options: FencedExecOptions): RepoExec;
+export declare function makeDriverExec(options: FencedExecOptions): DriverExec;

package/dist/make-process-supervisor-port.d.ts

@@ -0,0 +1,7 @@
+import type { SupervisorPort } from './types.ts';
+export interface ProcessSupervisorOptions {
+    readonly selfCommand: readonly string[];
+    readonly root: string;
+    readonly stateDir: string;
+}
+export declare function makeProcessSupervisorPort(options: ProcessSupervisorOptions): SupervisorPort;

package/dist/open-drive.d.ts

@@ -0,0 +1,23 @@
+import type { RunView } from './build-run-view.ts';
+import type { Access } from './host.ts';
+import type { Drive, Emit, EvidenceFiles, SupervisorPort, TargetDefinition, Wringer } from './types.ts';
+export interface DriveRequest {
+    readonly wringer: Wringer;
+    readonly root: string;
+    readonly stateDir: string;
+    readonly targetName: string;
+    readonly target: TargetDefinition;
+    readonly access: Access;
+    readonly hint: string;
+    readonly run: RunView;
+    readonly feature: string | null;
+    readonly cursors: Readonly<Record<string, number>>;
+    readonly signal: AbortSignal;
+    readonly deadlineAt: number;
+    readonly now: () => Date;
+    readonly emit: Emit;
+    readonly files: EvidenceFiles;
+    readonly callSupervisor: SupervisorPort['call'];
+}
+export declare const unassignedFeature = "unassigned";
+export declare function openDrive(request: DriveRequest): Drive;

package/dist/open-runless-drive.d.ts

@@ -0,0 +1,17 @@
+import type { Access } from './host.ts';
+import type { Drive, Emit, EvidenceFiles, TargetDefinition, Wringer } from './types.ts';
+export interface RunlessDriveRequest {
+    readonly wringer: Wringer;
+    readonly root: string;
+    readonly stateDir: string;
+    readonly targetName: string;
+    readonly target: TargetDefinition;
+    readonly access: Access;
+    readonly hint: string;
+    readonly feature: string | null;
+    readonly signal: AbortSignal;
+    readonly now: () => Date;
+    readonly emit: Emit;
+    readonly files: EvidenceFiles;
+}
+export declare function openRunlessDrive(request: RunlessDriveRequest): Drive;

package/dist/parse-launch-line.d.ts

@@ -0,0 +1,2 @@
+import type { LaunchLine } from './launch-line-schema.ts';
+export declare function parseLaunchLine(line: string): LaunchLine;

package/dist/parse-patch-id.d.ts

@@ -0,0 +1,2 @@
+export declare const emptyFingerprint = "empty";
+export declare function parsePatchID(stdout: string): string;

package/dist/parse-report-block.d.ts

@@ -0,0 +1,9 @@
+import type { Report } from './report-schema.ts';
+export type ReportBlockResult = {
+    readonly ok: true;
+    readonly report: Report;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function parseReportBlock(body: string): ReportBlockResult;

package/dist/parse-run-log.d.ts

@@ -0,0 +1,2 @@
+import type { RunEvent } from './run-events.ts';
+export declare function parseRunLog(text: string): readonly RunEvent[];

package/dist/pick-access-refusal.d.ts

@@ -0,0 +1,12 @@
+import type { Access } from './host.ts';
+import type { Effect } from './types.ts';
+import { WringerError } from './wringer-error.ts';
+export interface AccessInput {
+    readonly path: readonly string[];
+    readonly allowedTargets: readonly string[] | undefined;
+    readonly targetName: string;
+    readonly access: Access;
+    readonly effect: Effect;
+    readonly hint: string;
+}
+export declare function pickAccessRefusal(input: AccessInput): WringerError | null;

package/dist/pick-command-needs.d.ts

@@ -0,0 +1,15 @@
+import type { DoctorState } from './build-run-view.ts';
+import type { Mode } from './run-events.ts';
+export interface CommandNeedsFacts {
+    readonly isBuiltin: boolean;
+    readonly needsRun: boolean | undefined;
+    readonly needsDoctor: boolean | undefined;
+    readonly mode: Mode;
+    readonly doctor: DoctorState | undefined;
+}
+export interface CommandNeeds {
+    readonly needsRun: boolean;
+    readonly needsDoctor: boolean;
+    readonly readsFingerprint: boolean;
+}
+export declare function pickCommandNeeds(facts: CommandNeedsFacts): CommandNeeds;

package/dist/pick-command-plan.d.ts

@@ -0,0 +1,23 @@
+import type { RunView } from './build-run-view.ts';
+import type { DriveKind } from './pick-drive-kind.ts';
+import type { Mode } from './run-events.ts';
+import { WringerError } from './wringer-error.ts';
+export interface CommandFacts {
+    readonly needsRun: boolean;
+    readonly needsDoctor: boolean;
+    readonly isRepoCommand: boolean;
+    readonly run: RunView | undefined;
+    readonly targetName: string;
+    readonly mode: Mode;
+    readonly fingerprintChanged: boolean;
+    readonly deadlinePassed: boolean;
+}
+export type CommandPlan = {
+    readonly kind: 'refuse';
+    readonly failure: WringerError;
+} | {
+    readonly kind: 'run';
+    readonly driveKind: DriveKind;
+    readonly drive: boolean;
+};
+export declare function pickCommandPlan(facts: CommandFacts): CommandPlan;

package/dist/pick-context-target.d.ts

@@ -0,0 +1,7 @@
+export interface ContextTargetInput {
+    readonly targetNames: readonly string[];
+    readonly sessionTarget: string | undefined;
+    readonly savedTarget: string | undefined;
+    readonly commandKey: string;
+}
+export declare function pickContextTarget(input: ContextTargetInput): string;

package/dist/pick-drive-kind.d.ts

@@ -0,0 +1,8 @@
+import type { RunStatus } from './append-run-event.ts';
+export interface DriveFacts {
+    readonly runStatus: RunStatus | null;
+    readonly needsRun: boolean;
+    readonly isRepoCommand: boolean;
+}
+export type DriveKind = 'run' | 'runless' | 'none';
+export declare function pickDriveKind(facts: DriveFacts): DriveKind;

package/dist/pick-envelope-context.d.ts

@@ -0,0 +1 @@
+export declare function pickEnvelopeContext<Context>(before: Context | null, after: Context | null, ranOnRun: boolean): Context | null;

package/dist/pick-envelope-payload.d.ts

@@ -0,0 +1,12 @@
+import { WringerError } from './wringer-error.ts';
+export interface PayloadInput {
+    readonly data: unknown;
+    readonly commandFailure: WringerError | null;
+    readonly cursors: Readonly<Record<string, number>> | WringerError;
+}
+export interface EnvelopePayload {
+    readonly data: unknown;
+    readonly failure: WringerError | null;
+    readonly cursors: Readonly<Record<string, number>>;
+}
+export declare function pickEnvelopePayload(input: PayloadInput): EnvelopePayload;

package/dist/pick-envelope-run.d.ts

@@ -0,0 +1,6 @@
+import type { RunView } from './build-run-view.ts';
+export interface EnvelopeRunContext {
+    readonly targetName: string;
+    readonly run: RunView | undefined;
+}
+export declare function pickEnvelopeRun(before: EnvelopeRunContext | null, settled: EnvelopeRunContext | null, bound: RunView | null): RunView | undefined;

package/dist/pick-envelope-target.d.ts

@@ -0,0 +1,4 @@
+import type { RunView } from './build-run-view.ts';
+export declare function pickEnvelopeTarget(settled: {
+    readonly targetName: string;
+} | null, bound: RunView | null): string | null;

package/dist/pick-late-failure-write.d.ts

@@ -0,0 +1,13 @@
+import type { LateFailureEvent, RunID } from './run-events.ts';
+import type { WringerError } from './wringer-error.ts';
+export interface LateFailureFacts {
+    readonly runID: RunID | null;
+    readonly command: string;
+    readonly answered: WringerError | null;
+    readonly at: Date;
+}
+export interface LateFailureWrite {
+    readonly runID: RunID | null;
+    readonly event: LateFailureEvent;
+}
+export declare function pickLateFailureWrite(settled: PromiseSettledResult<unknown>, facts: LateFailureFacts): LateFailureWrite | null;

package/dist/pick-log-refusal.d.ts

@@ -0,0 +1,4 @@
+import type { RunView } from './build-run-view.ts';
+import type { RunViewRefusal } from './create-file-state.ts';
+import type { Envelope } from './envelope.ts';
+export declare function pickLogRefusal(envelope: Envelope, read: RunView | undefined): RunViewRefusal | null;

package/dist/pick-merge-base-failure.d.ts

@@ -0,0 +1,2 @@
+import { WringerError } from './wringer-error.ts';
+export declare function pickMergeBaseFailure(failure: unknown, noSharedCommit: WringerError): unknown;

package/dist/pick-merge-base-steps.d.ts

@@ -0,0 +1,13 @@
+import type { GitRequest } from './run-git.ts';
+import { WringerError } from './wringer-error.ts';
+export interface MergeBaseStepInput {
+    readonly root: string;
+    readonly base: string;
+    readonly newestCommit: string;
+}
+export interface MergeBaseSteps {
+    readonly verifyBase: GitRequest;
+    readonly mergeBase: GitRequest;
+    readonly noSharedCommit: WringerError;
+}
+export declare function pickMergeBaseSteps(input: MergeBaseStepInput): MergeBaseSteps | WringerError;

package/dist/pick-pending-cleanups.d.ts

@@ -0,0 +1,10 @@
+export interface CleanupFacts {
+    readonly launched: boolean;
+    readonly serviceKeys: readonly string[];
+    readonly stopping: ReadonlySet<string>;
+}
+export interface PendingCleanups {
+    readonly app: readonly string[];
+    readonly services: readonly string[];
+}
+export declare function pickPendingCleanups(facts: CleanupFacts): PendingCleanups;

package/dist/pick-submodule-refusal.d.ts

@@ -0,0 +1,2 @@
+import { WringerError } from './wringer-error.ts';
+export declare function pickSubmoduleRefusal(statusEntries: Uint8Array): WringerError | null;

package/dist/pick-supervisor-operation.d.ts

@@ -0,0 +1,16 @@
+import type { SupervisorRequest } from './supervisor-protocol.ts';
+import type { ServiceInstance } from './types.ts';
+import { WringerError } from './wringer-error.ts';
+export type SupervisorOperation = {
+    readonly kind: 'stop';
+} | {
+    readonly kind: 'status';
+} | {
+    readonly kind: 'call';
+    readonly cancelAfterMs: readonly number[];
+    readonly call: (signal: AbortSignal) => Promise<unknown>;
+} | {
+    readonly kind: 'refuse';
+    readonly error: WringerError;
+};
+export declare function pickSupervisorOperation(request: SupervisorRequest, services: ReadonlyMap<string, Pick<ServiceInstance, 'methods'>>, nowMs: number): SupervisorOperation;

package/dist/prepare-args.d.ts

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+import type { ArgsResult } from './types.ts';
+export declare function prepareArgs<Args, Prepared>(schema: z.ZodType<Args>, raw: unknown, build: (args: Args) => Prepared): ArgsResult<Prepared>;

package/dist/probe-process.d.ts

@@ -0,0 +1 @@
+export declare function probeProcess(pid: number): boolean;

package/dist/quote-shell-word.d.ts

@@ -0,0 +1 @@
+export declare function quoteShellWord(word: string): string;

package/dist/race-deadline.d.ts

@@ -0,0 +1 @@
+export declare function raceDeadline<T>(work: Promise<T>, deadline: AbortSignal): Promise<T>;

package/dist/read-changed-paths.d.ts

@@ -0,0 +1,7 @@
+import type { FingerprintHost } from './read-fingerprint.ts';
+export interface ChangedPathsRequest {
+    readonly cwd: string;
+    readonly base: string;
+    readonly exclude: readonly string[];
+}
+export declare function readChangedPaths(host: Pick<FingerprintHost, 'runGit'>, request: ChangedPathsRequest): Promise<readonly string[]>;

package/dist/read-default-base.d.ts

@@ -0,0 +1,2 @@
+import type { FingerprintHost } from './read-fingerprint.ts';
+export declare function readDefaultBase(host: Pick<FingerprintHost, 'runGit'>, root: string): Promise<string>;

package/dist/read-fingerprint.d.ts

@@ -0,0 +1,13 @@
+import type { GitRequest } from './run-git.ts';
+import type { ProcessResult } from './run-process.ts';
+export interface FingerprintHost {
+    readonly runGit: (request: GitRequest) => Promise<ProcessResult>;
+    readonly runGitBytes: (request: GitRequest) => Promise<Uint8Array>;
+    readonly removeDirectory: (path: string) => Promise<void>;
+}
+export interface FingerprintRequest {
+    readonly cwd: string;
+    readonly base: string;
+    readonly exclude: readonly string[];
+}
+export declare function readFingerprint(host: FingerprintHost, request: FingerprintRequest): Promise<string>;

package/dist/read-head-sha.d.ts

@@ -0,0 +1,2 @@
+import type { FingerprintHost } from './read-fingerprint.ts';
+export declare function readHeadSHA(host: Pick<FingerprintHost, 'runGit'>, root: string): Promise<string | null>;