@astrosheep/keiyaku 4.2.0 → 4.4.0

package/build/src/akuma/akuma-product.d.ts

@@ -1,6 +1,7 @@
 import { AkumaHandle } from "./akuma-handle.js";
-import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput, ResultRoute } from "./akuma.js";
+import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
 import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
+import type { ResultRoute } from "./result-route.js";
 import type { WorldRoot } from "../world.js";
 type AkumaCallLaunchInput = AkumaCallInput & Readonly<{
     resultRoute?: ResultRoute;

package/build/src/akuma/akuma.d.ts

@@ -57,13 +57,12 @@ export type AkumaCallInput = Readonly<{
     readonly?: true;
     allowed?: readonly AllowedAction[];
 }>;
-/** Opaque, serializable caller result address carried across the Body process. */
-export type ResultRoute = Readonly<unknown>;
 export type AkumaCallContext = Readonly<{
     initiatorCwd?: string;
     cwdCanonical?: true;
 }>;
 export type { TellResult, TellWake } from "./body.js";
+export type { ResultRoute } from "./result-route.js";
 export type InterruptReceipt = Readonly<{
     kind: "unavailable";
     evidence: "hung" | "untidy" | "unavailable";

package/build/src/akuma/body.d.ts

@@ -1,7 +1,7 @@
 import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import type { ProviderAdapter } from "./provider.js";
-import type { ResultRoute } from "./akuma.js";
+import type { ResultRoute } from "./result-route.js";
 import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
 import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
@@ -43,7 +43,7 @@ export type TellWakeRuntime = Readonly<{
 }>;
 type BodyRuntime = Readonly<{
     now(): string;
-    spawnChild?(launch: RequestChildLaunch): Promise<void>;
+    spawnChild?(launch: RequestChildLaunch): Promise<OwnedProcess>;
     spawnBody?(launch: BodyLaunch): Promise<OwnedProcess>;
     express?(route: ResultRoute, options: Readonly<{
         as: string;

package/build/src/akuma/body.js

@@ -6,7 +6,7 @@ import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, watchHeart, } from "./heart/index.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
-import { handoffProcess, spawnDetachedProcess, } from "../runtime/proc/run.js";
+import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 100;
 export const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
@@ -102,7 +102,7 @@ async function expressInitialOutcome(launch, soul, outcome, runtime) {
 function defaultRuntime() {
     return {
         now: () => new Date().toISOString(),
-        spawnChild: handoffAkumaBody,
+        spawnChild: spawnAkumaBody,
         spawnBody: spawnAkumaBody,
     };
 }
@@ -122,9 +122,6 @@ export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url)
         log: launch.paths.log,
     };
 }
-async function handoffAkumaBody(launch) {
-    await handoffProcess(await bodyProcessInput(launch));
-}
 async function prepareBodyStart(paths, leash) {
     const before = await readHeart(paths);
     if (before.pause !== null)
@@ -181,7 +178,7 @@ async function runBodyTurns(input) {
             adapter,
             bodySequence,
             supervisor,
-            runtimeSpawn: runtime.spawnChild ?? handoffAkumaBody,
+            runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,

package/build/src/akuma/index.d.ts

@@ -1,7 +1,8 @@
 import { type AkuId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 export { Akuma, AkumaHandle, AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
-export type { AkumaCallInput, ResultRoute } from "./akuma.js";
+export type { AkumaCallInput } from "./akuma.js";
+export type { ResultRoute } from "./result-route.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";

package/build/src/akuma/result-route.d.ts

@@ -0,0 +1,2 @@
+/** Opaque, serializable caller result address carried across the Body process. */
+export type ResultRoute = Readonly<unknown>;

package/build/src/akuma/result-route.js

@@ -0,0 +1 @@
+export {};

package/build/src/akuma/turn-drive.js

@@ -28,7 +28,7 @@ export async function turnRecipe(paths, soul) {
     const admitted = latest?.provider === soul.provider.name ? latest : undefined;
     const session = admitted?.coordinate;
     return {
-        cwd: admitted?.cwd ?? soul.cwd,
+        cwd: soul.cwd,
         options: admitted?.options ?? soul.options,
         ...(session === undefined ? {} : { session }),
     };

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -1,5 +1,4 @@
-import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
-import type { ResultRoute } from "../../akuma/akuma.js";
+import { type AkuId, type ActivityHistory, type ResultRoute } from "../../akuma/index.js";
 import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";

package/build/src/runtime/proc/launch.d.ts

@@ -1,33 +1,21 @@
 import { type ChildProcess } from "node:child_process";
-export type LaunchIntent = "handoff" | "retained";
 export type DetachedProcessInput = Readonly<{
     argv: readonly string[];
     cwd: string;
     env?: NodeJS.ProcessEnv;
     log: string;
 }>;
-export type SpawnLaunchPolicy = Readonly<{
-    kind: "spawn";
-    detached: boolean;
-    windowsHide: true;
-    shell: false;
-}>;
-export type PlatformLaunchPolicy = Readonly<{
-    kind: "windows-launcher";
-}> | SpawnLaunchPolicy;
-export declare function platformLaunchPolicy(intent: LaunchIntent, platform?: NodeJS.Platform): PlatformLaunchPolicy;
-export declare function spawnOptionsFor<Stdio>(intent: LaunchIntent, input: Readonly<{
+export declare function spawnOptionsFor<Stdio>(input: Readonly<{
     cwd?: string;
     env?: NodeJS.ProcessEnv;
-}>, stdio: Stdio, platform?: NodeJS.Platform): Readonly<{
+}>, stdio: Stdio): Readonly<{
     cwd: string | undefined;
     env: NodeJS.ProcessEnv | undefined;
-    detached: boolean;
+    detached: true;
     stdio: Stdio;
     windowsHide: true;
     shell: false;
 }>;
 export declare function windowsLauncherPath(): string;
-export declare function spawnLoggedProcess(input: DetachedProcessInput, intent: LaunchIntent): Promise<ChildProcess>;
-export declare function handoffWindowsLaunch(input: DetachedProcessInput, launcher?: string): Promise<void>;
-export declare function handoffProcess(input: DetachedProcessInput): Promise<void>;
+export declare function launchFailure(command: string, diagnostic: string): NodeJS.ErrnoException;
+export declare function spawnWindowsLauncher(input: DetachedProcessInput, launcher?: string): ChildProcess;

package/build/src/runtime/proc/launch.js

@@ -1,28 +1,14 @@
 import { spawn } from "node:child_process";
-import { open } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-export function platformLaunchPolicy(intent, platform = process.platform) {
-    if (platform === "win32" && intent === "handoff")
-        return { kind: "windows-launcher" };
-    return {
-        kind: "spawn",
-        detached: true,
-        windowsHide: true,
-        shell: false,
-    };
-}
-export function spawnOptionsFor(intent, input, stdio, platform = process.platform) {
-    const policy = platformLaunchPolicy(intent, platform);
-    if (policy.kind !== "spawn")
-        throw new Error("Windows Body handoff uses the GUI launcher");
+export function spawnOptionsFor(input, stdio) {
     return {
         cwd: input.cwd,
         env: input.env,
-        detached: policy.detached,
+        detached: true,
         stdio,
-        windowsHide: policy.windowsHide,
-        shell: policy.shell,
+        windowsHide: true,
+        shell: false,
     };
 }
 export function windowsLauncherPath() {
@@ -32,7 +18,7 @@ export function windowsLauncherPath() {
     }
     return sourcePath;
 }
-function launchFailure(command, diagnostic) {
+export function launchFailure(command, diagnostic) {
     const error = new Error(diagnostic.length > 0 ? diagnostic : `spawn ${command} UNKNOWN`);
     const code = /\b(?:ENOENT|EACCES|EINVAL)\b/.exec(error.message)?.[0];
     if (code)
@@ -41,58 +27,13 @@ function launchFailure(command, diagnostic) {
     error.path = command;
     return error;
 }
-async function waitSpawned(child) {
-    await new Promise((resolve, reject) => {
-        child.once("spawn", resolve);
-        child.once("error", reject);
-    });
-    if (child.pid === undefined)
-        throw new Error("detached process spawned without a pid");
-}
-export async function spawnLoggedProcess(input, intent) {
-    const log = await open(input.log, "a");
-    try {
-        const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor(intent, input, ["ignore", log.fd, log.fd]));
-        await waitSpawned(child);
-        return child;
-    }
-    finally {
-        await log.close();
-    }
-}
-export async function handoffWindowsLaunch(input, launcher = windowsLauncherPath()) {
-    const child = spawn(launcher, [input.log, ...input.argv], {
+export function spawnWindowsLauncher(input, launcher = windowsLauncherPath()) {
+    return spawn(launcher, ["--retain", input.log, ...input.argv], {
         cwd: input.cwd,
         env: input.env,
-        stdio: ["ignore", "ignore", "pipe"],
+        detached: true,
+        stdio: ["pipe", "pipe", "pipe"],
         windowsHide: true,
         shell: false,
     });
-    let stderr = "";
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-        stderr = `${stderr}${chunk}`.slice(-4_000);
-    });
-    const closed = new Promise((resolve) => {
-        child.once("close", (exitCode) => resolve(exitCode));
-    });
-    try {
-        await waitSpawned(child);
-    }
-    catch (error) {
-        throw error instanceof Error ? error : new Error(String(error));
-    }
-    const code = await closed;
-    if (code === 0)
-        return;
-    throw launchFailure(input.argv[0] ?? launcher, stderr.trim());
-}
-export async function handoffProcess(input) {
-    const policy = platformLaunchPolicy("handoff");
-    if (policy.kind === "windows-launcher") {
-        await handoffWindowsLaunch(input);
-        return;
-    }
-    const child = await spawnLoggedProcess(input, "handoff");
-    child.unref();
 }

package/build/src/runtime/proc/lifecycle.d.ts

@@ -0,0 +1,6 @@
+export type ProcessLifecycle = Readonly<{
+    markInert(): void;
+    terminate(force?: boolean): Promise<void>;
+    release(): void;
+}>;
+export declare function createProcessLifecycle(runTermination: (force: boolean) => Promise<void>, releaseCustody: () => void): ProcessLifecycle;

package/build/src/runtime/proc/lifecycle.js

@@ -0,0 +1,26 @@
+export function createProcessLifecycle(runTermination, releaseCustody) {
+    let state = "active";
+    let termination;
+    return {
+        markInert() {
+            state = "inert";
+        },
+        terminate(force = false) {
+            if (state === "inert")
+                return Promise.resolve();
+            if (termination !== undefined)
+                return termination;
+            state = "terminating";
+            termination = runTermination(force).finally(() => {
+                state = "inert";
+            });
+            return termination;
+        },
+        release() {
+            if (state !== "active")
+                return;
+            state = "inert";
+            releaseCustody();
+        },
+    };
+}

package/build/src/runtime/proc/process-exit.d.ts

@@ -0,0 +1,4 @@
+import { type FileHandle } from "node:fs/promises";
+import type { DetachedProcessExit } from "./types.js";
+export declare function detachedExitStatus(code: number | null, signal: NodeJS.Signals | null): string;
+export declare function retainDetachedExitEvidence(log: FileHandle, path: string, from: number, code: number | null, signal: NodeJS.Signals | null): Promise<DetachedProcessExit>;

package/build/src/runtime/proc/process-exit.js

@@ -0,0 +1,31 @@
+import { open } from "node:fs/promises";
+export function detachedExitStatus(code, signal) {
+    return code === null ? `signal ${signal ?? "unknown"}` : `exit ${code}`;
+}
+export async function retainDetachedExitEvidence(log, path, from, code, signal) {
+    const status = detachedExitStatus(code, signal);
+    const marker = Buffer.from(`[child ${status}]\n`);
+    let written = 0;
+    while (written < marker.byteLength) {
+        const write = await log.write(marker, written, marker.byteLength - written);
+        if (write.bytesWritten === 0)
+            throw new Error("run log exit marker write made no progress");
+        written += write.bytesWritten;
+    }
+    const evidence = await log.stat();
+    if (evidence.size < from)
+        throw new Error("run log shrank before exit evidence was retained");
+    const referenced = await open(path, "r");
+    try {
+        const current = await referenced.stat();
+        if (current.dev !== evidence.dev || current.ino !== evidence.ino) {
+            throw new Error("run log path changed before exit evidence was retained");
+        }
+        if (current.size < evidence.size)
+            throw new Error("run log path size changed before exit evidence was retained");
+    }
+    finally {
+        await referenced.close();
+    }
+    return { code, signal, log: { path, from, to: evidence.size } };
+}

package/build/src/runtime/proc/run.d.ts

@@ -1,6 +1,7 @@
-import { type ChildProcess } from "node:child_process";
 import { type DetachedProcessInput } from "./launch.js";
-export { handoffProcess, type DetachedProcessInput } from "./launch.js";
+import type { OwnedProcess } from "./types.js";
+export type { DetachedProcessInput } from "./launch.js";
+export type { DetachedProcessExit, OwnedProcess, RunLogReference } from "./types.js";
 type ProcessLaunch = Readonly<{
     readonly argv: readonly string[];
     readonly cwd?: string;
@@ -39,23 +40,7 @@ export type ProcessConsumption = Readonly<{
     readonly outcome: ProcessOutcome | ProcessStreamError;
     readonly pid: number | null;
 }>;
-export type RunLogReference = Readonly<{
-    path: string;
-    from: number;
-    to: number;
-}>;
-export type DetachedProcessExit = Readonly<{
-    code: number | null;
-    signal: NodeJS.Signals | null;
-    log: RunLogReference;
-}>;
-export type OwnedProcess = Readonly<{
-    pid: number;
-    exited: Promise<DetachedProcessExit>;
-    terminate(force?: boolean): Promise<void>;
-    release(): void;
-}>;
-export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;
+export { terminateOwnedProcess } from "./termination.js";
 export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<OwnedProcess>;
 export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
 export declare function runCrossPlatformProcess(input: ProcessInput): Promise<ProcessOutcome>;

package/build/src/runtime/proc/run.js

@@ -1,11 +1,11 @@
-import { execFile, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { open } from "node:fs/promises";
-import { setTimeout as delay } from "node:timers/promises";
-import { promisify } from "node:util";
 import crossSpawn from "cross-spawn";
 import { spawnOptionsFor } from "./launch.js";
-export { handoffProcess } from "./launch.js";
-const TERMINATION_GRACE_MS = 250;
+import { detachedExitStatus, retainDetachedExitEvidence } from "./process-exit.js";
+import { createProcessLifecycle } from "./lifecycle.js";
+import { terminateOwnedProcess } from "./termination.js";
+import { spawnWindowsRetainedProcess } from "./windows-run.js";
 const STREAM_TAIL_BYTES = 16 * 1024;
 function tailCapture(limit) {
     const bytes = Buffer.allocUnsafe(limit);
@@ -34,98 +34,10 @@ function tailCapture(limit) {
         },
     };
 }
-function ignoreMissingProcess(error) {
-    if (error.code !== "ESRCH")
-        throw error;
-}
-function detachedExitStatus(code, signal) {
-    return code === null ? `signal ${signal ?? "unknown"}` : `exit ${code}`;
-}
-const WINDOWS_TERMINATION_TIMEOUT_MS = 1_000;
-const execFileAsync = promisify(execFile);
-async function terminateWindowsTree(pid) {
-    await execFileAsync("taskkill", ["/PID", String(pid), "/T", "/F"], {
-        timeout: WINDOWS_TERMINATION_TIMEOUT_MS,
-        windowsHide: true,
-    });
-}
-export async function terminateOwnedProcess(child, force = false) {
-    const pid = child.pid;
-    if (pid === undefined || child.exitCode !== null || child.signalCode !== null)
-        return;
-    let exited = false;
-    const exit = new Promise((resolve) => {
-        child.once("exit", () => {
-            exited = true;
-            resolve();
-        });
-        child.once("close", () => {
-            exited = true;
-            resolve();
-        });
-    });
-    if (process.platform === "win32") {
-        await terminateWindowsTree(pid);
-        await exit;
-        return;
-    }
-    if (force) {
-        try {
-            process.kill(-pid, "SIGKILL");
-        }
-        catch (error) {
-            ignoreMissingProcess(error);
-        }
-        await exit;
-        return;
-    }
-    try {
-        process.kill(-pid, "SIGTERM");
-    }
-    catch (error) {
-        ignoreMissingProcess(error);
-        await exit;
-        return;
-    }
-    await Promise.race([exit, delay(TERMINATION_GRACE_MS)]);
-    if (exited || child.exitCode !== null || child.signalCode !== null)
-        return;
-    try {
-        process.kill(-pid, "SIGKILL");
-    }
-    catch (error) {
-        ignoreMissingProcess(error);
-    }
-    await exit;
-}
-async function retainDetachedExitEvidence(log, path, from, code, signal) {
-    const status = detachedExitStatus(code, signal);
-    const marker = Buffer.from(`[child ${status}]\n`);
-    let written = 0;
-    while (written < marker.byteLength) {
-        const write = await log.write(marker, written, marker.byteLength - written);
-        if (write.bytesWritten === 0)
-            throw new Error("run log exit marker write made no progress");
-        written += write.bytesWritten;
-    }
-    const evidence = await log.stat();
-    if (evidence.size < from)
-        throw new Error("run log shrank before exit evidence was retained");
-    const referenced = await open(path, "r");
-    try {
-        const current = await referenced.stat();
-        if (current.dev !== evidence.dev || current.ino !== evidence.ino) {
-            throw new Error("run log path changed before exit evidence was retained");
-        }
-        if (current.size < evidence.size)
-            throw new Error("run log path size changed before exit evidence was retained");
-    }
-    finally {
-        await referenced.close();
-    }
-    return { code, signal, log: { path, from, to: evidence.size } };
-}
+export { terminateOwnedProcess } from "./termination.js";
 export async function spawnDetachedProcess(input) {
+    if (process.platform === "win32")
+        return spawnWindowsRetainedProcess(input);
     const log = await open(input.log, "a");
     let launched = false;
     let logClosed = false;
@@ -137,11 +49,10 @@ export async function spawnDetachedProcess(input) {
     };
     try {
         const from = (await log.stat()).size;
-        const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor("retained", input, ["ignore", log.fd, log.fd]));
-        let state = "active";
-        let termination;
+        const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor(input, ["ignore", log.fd, log.fd]));
+        const lifecycle = createProcessLifecycle((force) => terminateOwnedProcess(child, force), () => child.unref());
         const invalidate = () => {
-            state = "inert";
+            lifecycle.markInert();
         };
         child.once("exit", invalidate);
         child.once("close", invalidate);
@@ -182,21 +93,8 @@ export async function spawnDetachedProcess(input) {
         return {
             pid,
             exited,
-            terminate(force = false) {
-                if (state === "inert")
-                    return Promise.resolve();
-                if (termination !== undefined)
-                    return termination;
-                state = "terminating";
-                termination = terminateOwnedProcess(child, force).finally(invalidate);
-                return termination;
-            },
-            release: () => {
-                if (state === "inert")
-                    return;
-                state = "inert";
-                child.unref();
-            },
+            terminate: lifecycle.terminate,
+            release: lifecycle.release,
         };
     }
     finally {
@@ -216,7 +114,7 @@ function terminalOutcome(code, stdout, stderr, consuming) {
 async function executeProcess(input, timeoutMs, consumeStdout, spawnProcess = spawn) {
     if (input.signal?.aborted === true)
         return { outcome: { kind: "cancelled" }, pid: null };
-    const child = spawnProcess(input.argv[0], input.argv.slice(1), spawnOptionsFor("retained", input, ["ignore", "pipe", "pipe"]));
+    const child = spawnProcess(input.argv[0], input.argv.slice(1), spawnOptionsFor(input, ["ignore", "pipe", "pipe"]));
     const stdout = tailCapture(STREAM_TAIL_BYTES);
     const stderr = tailCapture(STREAM_TAIL_BYTES);
     let stop;

package/build/src/runtime/proc/stdio.js

@@ -4,10 +4,7 @@ import { spawnOptionsFor } from "./launch.js";
 import { terminateOwnedProcess } from "./run.js";
 const DEFAULT_DRAIN_TIMEOUT_MS = 1_000;
 export function spawnStdioProcess(input) {
-    const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor("retained", {
-        cwd: input.cwd,
-        env: input.env ?? process.env,
-    }, ["pipe", "pipe", "pipe"]));
+    const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor({ cwd: input.cwd, env: input.env ?? process.env }, ["pipe", "pipe", "pipe"]));
     let stderr = "";
     let inputEnded = false;
     let forced;

package/build/src/runtime/proc/termination.d.ts

@@ -0,0 +1,3 @@
+import { type ChildProcess } from "node:child_process";
+export declare function terminateWindowsTree(pid: number): Promise<void>;
+export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;

package/build/src/runtime/proc/termination.js

@@ -0,0 +1,74 @@
+import { execFile } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+const TERMINATION_GRACE_MS = 250;
+const WINDOWS_TERMINATION_TIMEOUT_MS = 1_000;
+const execFileAsync = promisify(execFile);
+function ignoreMissingProcess(error) {
+    if (error.code !== "ESRCH")
+        throw error;
+}
+export async function terminateWindowsTree(pid) {
+    try {
+        await execFileAsync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            timeout: WINDOWS_TERMINATION_TIMEOUT_MS,
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        const diagnostic = error;
+        const text = `${diagnostic.stderr ?? ""} ${diagnostic.message ?? ""}`;
+        if (diagnostic.code === "ESRCH" || /not found|no running instance|does not exist/iu.test(text))
+            return;
+        throw error;
+    }
+}
+export async function terminateOwnedProcess(child, force = false) {
+    const pid = child.pid;
+    if (pid === undefined || child.exitCode !== null || child.signalCode !== null)
+        return;
+    let exited = false;
+    const exit = new Promise((resolve) => {
+        child.once("exit", () => {
+            exited = true;
+            resolve();
+        });
+        child.once("close", () => {
+            exited = true;
+            resolve();
+        });
+    });
+    if (process.platform === "win32") {
+        await terminateWindowsTree(pid);
+        await exit;
+        return;
+    }
+    if (force) {
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch (error) {
+            ignoreMissingProcess(error);
+        }
+        await exit;
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch (error) {
+        ignoreMissingProcess(error);
+        await exit;
+        return;
+    }
+    await Promise.race([exit, delay(TERMINATION_GRACE_MS)]);
+    if (exited || child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch (error) {
+        ignoreMissingProcess(error);
+    }
+    await exit;
+}

package/build/src/runtime/proc/types.d.ts

@@ -0,0 +1,16 @@
+export type RunLogReference = Readonly<{
+    path: string;
+    from: number;
+    to: number;
+}>;
+export type DetachedProcessExit = Readonly<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    log: RunLogReference;
+}>;
+export type OwnedProcess = Readonly<{
+    pid: number;
+    exited: Promise<DetachedProcessExit>;
+    terminate(force?: boolean): Promise<void>;
+    release(): void;
+}>;

package/build/src/runtime/proc/types.js

@@ -0,0 +1 @@
+export {};

package/build/src/runtime/proc/windows-run.d.ts

@@ -0,0 +1,3 @@
+import { type DetachedProcessInput } from "./launch.js";
+import type { OwnedProcess } from "./types.js";
+export declare function spawnWindowsRetainedProcess(input: DetachedProcessInput): Promise<OwnedProcess>;

package/build/src/runtime/proc/windows-run.js

@@ -0,0 +1,199 @@
+import { open } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { launchFailure, spawnWindowsLauncher } from "./launch.js";
+import { detachedExitStatus, retainDetachedExitEvidence } from "./process-exit.js";
+import { createProcessLifecycle } from "./lifecycle.js";
+import { terminateWindowsTree } from "./termination.js";
+function createWindowsContext(input, log, from, closeLog) {
+    const child = spawnWindowsLauncher(input);
+    const reader = createInterface({ input: child.stdout });
+    let startedResolve;
+    let startedReject;
+    let exitResolve;
+    let exitReject;
+    const startedPromise = new Promise((resolve, reject) => {
+        startedResolve = resolve;
+        startedReject = reject;
+    });
+    const exited = new Promise((resolve, reject) => {
+        exitResolve = resolve;
+        exitReject = reject;
+    });
+    void exited.catch(() => undefined);
+    child.stderr?.setEncoding("utf8");
+    const context = {
+        input,
+        log,
+        from,
+        closeLog,
+        child,
+        reader,
+        stderr: "",
+        started: false,
+        targetPid: undefined,
+        released: false,
+        finished: false,
+        startedPromise,
+        startedResolve,
+        startedReject,
+        exited,
+        exitResolve,
+        exitReject,
+    };
+    child.stderr?.on("data", (chunk) => {
+        context.stderr = `${context.stderr}${chunk}`.slice(-4_000);
+    });
+    return context;
+}
+function failWindows(context, error) {
+    if (context.released)
+        return;
+    context.lifecycle?.markInert();
+    if (!context.started)
+        context.startedReject(error);
+    if (!context.finished) {
+        context.finished = true;
+        context.exitReject(error);
+    }
+    context.reader.close();
+    context.child.stdout?.resume();
+    if (context.targetPid !== undefined) {
+        void terminateWindowsTree(context.targetPid)
+            .catch(() => undefined)
+            .finally(() => context.child.stdin?.end());
+    }
+    else if (context.child.pid !== undefined && context.child.exitCode === null && context.child.signalCode === null) {
+        void terminateWindowsTree(context.child.pid)
+            .catch(() => undefined)
+            .finally(() => context.child.stdin?.end());
+    }
+    else {
+        context.child.stdin?.end();
+    }
+}
+function recordWindowsExit(context, code) {
+    if (context.finished)
+        return;
+    context.finished = true;
+    context.lifecycle?.markInert();
+    void (async () => {
+        let failure;
+        let result;
+        try {
+            result = await retainDetachedExitEvidence(context.log, context.input.log, context.from, code, null);
+        }
+        catch (error) {
+            failure = error;
+        }
+        try {
+            await context.closeLog();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        context.reader.close();
+        context.child.stdin?.end();
+        context.child.stdout?.resume();
+        if (failure !== undefined) {
+            const status = detachedExitStatus(code, null);
+            throw new Error(`pre-admission ${status}: run-log evidence unavailable: ${failure instanceof Error ? failure.message : String(failure)}`);
+        }
+        context.exitResolve(result);
+    })().catch(context.exitReject);
+}
+function handleWindowsLine(context, line) {
+    const startedMatch = /^started ([0-9]+)$/u.exec(line);
+    if (startedMatch !== null) {
+        const pid = Number.parseInt(startedMatch[1], 10);
+        if (!Number.isSafeInteger(pid) || pid <= 0 || context.started) {
+            failWindows(context, new Error("Windows launcher returned an invalid started record"));
+            return;
+        }
+        context.started = true;
+        context.targetPid = pid;
+        context.startedResolve(pid);
+        return;
+    }
+    const exitedMatch = /^exited ([0-9]+)$/u.exec(line);
+    if (exitedMatch !== null) {
+        if (!context.started) {
+            failWindows(context, new Error("Windows launcher returned exit before started"));
+            return;
+        }
+        recordWindowsExit(context, Number.parseInt(exitedMatch[1], 10));
+        return;
+    }
+    if (line.length > 0)
+        failWindows(context, new Error(`Windows launcher returned malformed protocol: ${line}`));
+}
+function installWindowsProtocol(context) {
+    context.child.once("error", (error) => failWindows(context, error));
+    context.child.once("close", () => {
+        if (context.released)
+            return;
+        if (!context.started) {
+            failWindows(context, launchFailure(context.input.argv[0] ?? "windows-launch.exe", context.stderr.trim()));
+        }
+        else if (!context.finished) {
+            failWindows(context, new Error("Windows launcher exited before target exit evidence"));
+        }
+    });
+    context.reader.on("line", (line) => handleWindowsLine(context, line));
+}
+function ownedWindowsProcess(context, pid) {
+    const lifecycle = createProcessLifecycle(async () => {
+        await terminateWindowsTree(pid);
+        await context.exited;
+    }, () => {
+        context.released = true;
+        context.reader.close();
+        context.child.stdin?.write("release\n");
+        context.child.stdin?.end();
+        context.child.stdout?.resume();
+        context.child.unref();
+        void context.closeLog();
+    });
+    context.lifecycle = lifecycle;
+    return {
+        pid,
+        exited: context.exited,
+        terminate: lifecycle.terminate,
+        release: lifecycle.release,
+    };
+}
+export async function spawnWindowsRetainedProcess(input) {
+    const log = await open(input.log, "a");
+    let logClosed = false;
+    const closeLog = async () => {
+        if (logClosed)
+            return;
+        logClosed = true;
+        await log.close();
+    };
+    const context = createWindowsContext(input, log, (await log.stat()).size, closeLog);
+    installWindowsProtocol(context);
+    try {
+        const pid = await context.startedPromise;
+        return ownedWindowsProcess(context, pid);
+    }
+    catch (error) {
+        context.reader.close();
+        if (context.child.pid !== undefined) {
+            try {
+                await terminateWindowsTree(context.child.pid);
+            }
+            catch {
+                /* preserve the launch error */
+            }
+        }
+        await new Promise((resolve) => {
+            if (context.child.exitCode !== null || context.child.signalCode !== null) {
+                resolve();
+                return;
+            }
+            context.child.once("close", () => resolve());
+        });
+        await closeLog();
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "files": [
     "build"
   ],