stitchkit 0.108.1 → 0.108.3

package/CHANGELOG.md

@@ -15,6 +15,35 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [0.108.3] - 2026-10-09
+
+### Added
+
+- `stitchkit/process/owner-loss` — `bootstrapNativeCommandOwnerLoss()` lets a single-file Bun
+  application keep `stitchkit/process` behind a dynamic import while carrying the same package-owned
+  owner-loss guard in its bundle. Call it before application argv routing and skip that routing when
+  it returns `true`; consumers do not inspect or copy the private guard protocol. → ADR 0255
+
+### Fixed
+
+- `stitchkit/cli` — numeric, bigint and boolean `z.literal()` fields now receive their primitive
+  values from argv, including homogeneous literal sets, unions, wrappers and array elements. String
+  literals retain their lexical form (`007` stays `"007"`), and mixed-type literal sets remain raw
+  rather than guessing a type from spelling.
+
+## [0.108.2] - 2026-10-09
+
+### Added
+
+- `stitchkit/process` — `runNativeCommand` takes `ownerLoss: 'terminate'`: on Linux and Darwin under
+  Bun or Node, a package-owned per-command guard binds the command's process group to a private
+  inherited kernel channel. If the JavaScript caller is killed or crashes, channel EOF makes the
+  guard KILL its own group without polling, `finally` or PID reclamation. The option requires
+  `group: 'own'`; unsupported platforms refuse with `COMMAND_UNAVAILABLE`. It is opt-in because each
+  guarded call uses one extra short-lived process and descriptor. Output, stdin, target exit status,
+  deadlines and cancellation retain the existing contract; `onLeaderStarted` reports the guard that
+  leads the owned group. → ADR 0255
+
 ## [0.108.1] - 2026-10-07
 
 ### Fixed

package/dist/entrypoints/agent-runtime/coding-tools.js

@@ -6,10 +6,11 @@ import {
   AgentCodingToolAuthorizationSchema2,
   AgentCodingToolPathAuthorizationSchema2,
   createAgentCodingTools2
-} from "../../index-e35py42g.js";
+} from "../../index-tycmtxky.js";
 import"../../index-2kbysk9s.js";
-import"../../index-epg514ys.js";
+import"../../index-dj1aycxw.js";
 import"../../index-8ks9b85e.js";
+import"../../index-dasy32c8.js";
 import"../../index-zrtrjkbf.js";
 import"../../index-636mggad.js";
 export {

package/dist/entrypoints/agent-runtime/sandbox.js

@@ -8,16 +8,18 @@ import"../../index-q6crhe1n.js";
 import"../../index-fynr93w4.js";
 import {
   createAgentCodingTools2
-} from "../../index-e35py42g.js";
+} from "../../index-tycmtxky.js";
 import"../../index-2kbysk9s.js";
 import {
   COMMAND_CLEANUP_TIMEOUT_MS,
-  NativeCommandError2,
+  NativeCommandError2
+} from "../../index-dj1aycxw.js";
+import {
   spawnOwnedCommand,
   nativeCommandOwner,
   terminateOwnedGroup,
   startNativeCommand
-} from "../../index-epg514ys.js";
+} from "../../index-dasy32c8.js";
 import"../../index-zrtrjkbf.js";
 import {
   MAX_TIMER_MS

package/dist/entrypoints/cli.js

@@ -15,7 +15,7 @@ import {
   renderCliView2,
   pollUntilDone2,
   createCli2
-} from "../index-4qh90tyw.js";
+} from "../index-fgq4w9bf.js";
 import"../index-fynr93w4.js";
 import"../index-ct75c3at.js";
 import"../index-q6crhe1n.js";

package/dist/entrypoints/contract.js

@@ -4,7 +4,7 @@ import {
   paginatedSchema2,
   encodeCursor2,
   decodeCursor2
-} from "../index-q4hjtyye.js";
+} from "../index-qd8x73e8.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES2,
   ContractStreamFrameSchema2

package/dist/entrypoints/index.js

@@ -44,7 +44,7 @@ import {
   paginatedSchema2,
   encodeCursor2,
   decodeCursor2
-} from "../index-q4hjtyye.js";
+} from "../index-qd8x73e8.js";
 import {
   ManagedFilePathSchema2,
   ManagedFileRefSchema2

package/dist/entrypoints/node.js

@@ -11,7 +11,7 @@ import {
 import"../index-ykdcnq1f.js";
 import"../index-4s0fep5q.js";
 import"../index-fsw1ybf3.js";
-import"../index-q4hjtyye.js";
+import"../index-qd8x73e8.js";
 import"../index-xqhede6x.js";
 import {
   createHandler2,

package/dist/entrypoints/process/owner-loss.d.ts

@@ -0,0 +1,3 @@
+/** Narrow startup bootstrap for a bundled application that lazy-imports `stitchkit/process`. */
+export { bootstrapNativeCommandOwnerLoss } from '../../process/owner-loss-guard.js';
+//# sourceMappingURL=owner-loss.d.ts.map

package/dist/entrypoints/process/owner-loss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner-loss.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/process/owner-loss.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,OAAO,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/entrypoints/process/owner-loss.js

@@ -0,0 +1,6 @@
+import {
+  bootstrapNativeCommandOwnerLoss2
+} from "../../index-dj1aycxw.js";
+export {
+  bootstrapNativeCommandOwnerLoss2 as bootstrapNativeCommandOwnerLoss
+};

package/dist/entrypoints/process.js

@@ -5,9 +5,11 @@ import {
   probeProcessOwner2
 } from "../index-bh2ht9y5.js";
 import {
-  NativeCommandError2,
+  NativeCommandError2
+} from "../index-dj1aycxw.js";
+import {
   startNativeCommand
-} from "../index-epg514ys.js";
+} from "../index-dasy32c8.js";
 // src/process/command.ts
 function runNativeCommand(input) {
   return startNativeCommand(input).result;

package/dist/entrypoints/server.js

@@ -26,7 +26,7 @@ import {
 import"../index-ykdcnq1f.js";
 import"../index-4s0fep5q.js";
 import"../index-fsw1ybf3.js";
-import"../index-q4hjtyye.js";
+import"../index-qd8x73e8.js";
 import"../index-xqhede6x.js";
 import {
   contextContributionDelta,

package/dist/entrypoints/tools.js

@@ -71,7 +71,7 @@ import {
   WaitTimeoutError,
   runWaitOperation,
   createCli2
-} from "../index-4qh90tyw.js";
+} from "../index-fgq4w9bf.js";
 import {
   ManagedFilePathSchema2,
   ManagedFileRefSchema2

package/dist/{index-epg514ys.js → index-dasy32c8.js}

@@ -1,3 +1,17 @@
+import {
+  NativeCommandOptionsSchema,
+  NativeCommandError2,
+  abortOwnerLossLaunch,
+  attachOwnerLossControl,
+  transferOwnerLossControl,
+  awaitCommandStart,
+  ownerLossAvailable,
+  ownerLossGuardCommand,
+  hostIsBun,
+  spawnBunChild,
+  spawnBunInheritedChild,
+  ownerLossGuardEntry
+} from "./index-dj1aycxw.js";
 import {
   raceAbort
 } from "./index-b0kddvzw.js";
@@ -9,147 +23,6 @@ import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
 
-// src/process/contract.ts
-import { z } from "zod";
-var NativeCommandSettlementSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("exit"),
-    exitCode: z.number().int().nullable(),
-    signal: z.string().nullable()
-  }),
-  z.object({
-    kind: z.literal("stopped"),
-    cause: z.unknown(),
-    exitCode: z.number().int().nullable(),
-    signal: z.string().nullable()
-  }),
-  z.object({ kind: z.literal("error"), cause: z.unknown() })
-]);
-var COMMAND_CLEANUP_TIMEOUT_MS = 2000;
-var MAX_COMMAND_STOP_GRACE_MS = 3600000;
-var NativeCommandStopPolicySchema = z.strictObject({
-  target: z.enum(["group", "leader"]),
-  signal: z.enum(["SIGTERM", "SIGINT", "SIGHUP", "SIGQUIT", "SIGUSR1", "SIGUSR2"]).default("SIGTERM"),
-  graceMs: z.number().int().nonnegative().max(MAX_COMMAND_STOP_GRACE_MS),
-  killOn: z.custom((v) => v instanceof AbortSignal).optional()
-});
-var REMOVED_NATIVE_COMMAND_OPTIONS = {
-  killGraceMs: "stop: { target: 'group', graceMs } (removed in 0.105.0)"
-};
-function unknownOptionMessage(keys) {
-  return keys.map((key) => {
-    const name = String(key);
-    const replacement = Object.hasOwn(REMOVED_NATIVE_COMMAND_OPTIONS, name) ? REMOVED_NATIVE_COMMAND_OPTIONS[name] : undefined;
-    return replacement === undefined ? `Unknown runNativeCommand option ${name}` : `Unknown runNativeCommand option ${name}; use ${replacement}`;
-  }).join("; ");
-}
-var DEFAULT_GROUP_STOP = {
-  target: "group",
-  signal: "SIGTERM",
-  graceMs: 100
-};
-var DEFAULT_LEADER_STOP = {
-  target: "leader",
-  signal: "SIGTERM",
-  graceMs: 100
-};
-var NativeCommandOptionsSchema = z.strictObject({
-  executable: z.string().min(1),
-  args: z.array(z.string()).default([]),
-  cwd: z.string().optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  envPolicy: z.enum(["declared-only", "ambient"]).default("declared-only"),
-  signal: z.custom((v) => v instanceof AbortSignal).optional(),
-  timeoutMs: z.number().int().positive().max(MAX_TIMER_MS).optional(),
-  maxOutputBytes: z.number().int().positive().optional(),
-  capture: z.boolean().default(false),
-  stdin: z.custom((v) => v instanceof Uint8Array).optional(),
-  maxStdinBytes: z.number().int().positive().default(1024 * 1024),
-  onOutput: z.custom((v) => typeof v === "function").optional(),
-  onLeaderSettled: z.custom((v) => typeof v === "function").optional(),
-  onLeaderStarted: z.custom((v) => typeof v === "function").optional(),
-  drainTimeoutMs: z.number().int().positive().max(MAX_TIMER_MS).optional(),
-  group: z.enum(["own", "caller"]).default("own"),
-  stdio: z.enum(["pipe", "inherit"]).default("pipe"),
-  stop: NativeCommandStopPolicySchema.optional(),
-  descendants: z.enum(["terminate-after-leader", "leave"]).optional(),
-  cleanupTimeoutMs: z.number().int().positive().max(30000).default(COMMAND_CLEANUP_TIMEOUT_MS)
-}, {
-  error: (issue) => issue.code === "unrecognized_keys" ? unknownOptionMessage(issue.keys) : undefined
-}).check((ctx) => {
-  const input = ctx.value;
-  if (!input.signal && input.timeoutMs === undefined)
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "Declare a caller signal or a finite timeout"
-    });
-  if (input.capture && input.maxOutputBytes === undefined)
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "Capture requires a finite combined output budget"
-    });
-  if (input.stdin && input.stdin.byteLength > input.maxStdinBytes)
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "stdin exceeds maxStdinBytes"
-    });
-  if (input.group === "caller" && input.stop?.target === "group")
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "group: 'caller' stops only the leader; use stop.target 'leader'"
-    });
-  if (input.group === "caller" && input.descendants !== undefined)
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "group: 'caller' has no group of its own, so descendants does not apply"
-    });
-  if (input.stdio === "inherit") {
-    const piped = [
-      input.capture && "capture",
-      input.onOutput && "onOutput",
-      input.stdin && "stdin",
-      input.maxOutputBytes !== undefined && "maxOutputBytes",
-      input.drainTimeoutMs !== undefined && "drainTimeoutMs"
-    ].filter((name) => typeof name === "string");
-    for (const name of piped)
-      ctx.issues.push({
-        code: "custom",
-        input: ctx.value,
-        message: `stdio: 'inherit' leaves no pipe for ${name}`
-      });
-  }
-}).transform((input) => ({
-  ...input,
-  stop: input.stop ?? (input.group === "caller" ? DEFAULT_LEADER_STOP : DEFAULT_GROUP_STOP),
-  descendants: input.descendants ?? "terminate-after-leader"
-}));
-var NativeCommandResultSchema = z.object({
-  exitCode: z.number().int().nullable(),
-  signal: z.string().nullable(),
-  descendantsStopped: z.boolean(),
-  stdout: z.instanceof(Uint8Array),
-  stderr: z.instanceof(Uint8Array)
-});
-var NativeCommandLimitReasonSchema = z.enum(["deadline", "output-budget"]);
-
-class NativeCommandError2 extends Error {
-  code;
-  reason;
-  constructor(code, message, options) {
-    super(message, options);
-    this.code = code;
-    if (options?.reason !== undefined && code !== "COMMAND_LIMIT")
-      throw new TypeError("Only COMMAND_LIMIT accepts a limit reason");
-    this.reason = options?.reason === undefined ? undefined : NativeCommandLimitReasonSchema.parse(options.reason);
-    this.name = "NativeCommandError";
-  }
-}
-
 // src/process/group.ts
 function createCommandDeadline(timeoutMs, reason) {
   assertPositiveSafeInteger("Command deadline", timeoutMs, RangeError);
@@ -395,176 +268,11 @@ function createCommandLifetime(input) {
 }
 
 // src/process/launch.ts
-import { Readable as Readable3 } from "node:stream";
+import { Readable as Readable2 } from "node:stream";
 
 // src/process/owned-child.ts
 import { spawn } from "node:child_process";
-
-// src/process/bun-child.ts
-import { EventEmitter } from "node:events";
-import { Readable, Writable } from "node:stream";
-function hostIsBun() {
-  return typeof Bun !== "undefined";
-}
-function readableOf(source) {
-  const reader = source.getReader();
-  let reading = false;
-  return new Readable({
-    read() {
-      if (reading)
-        return;
-      reading = true;
-      reader.read().then(({ done, value }) => {
-        reading = false;
-        if (done)
-          this.push(null);
-        else
-          this.push(value);
-      }, (error) => {
-        reading = false;
-        this.destroy(error instanceof Error ? error : new Error(String(error)));
-      });
-    },
-    destroy(error, done) {
-      reader.cancel().then(() => done(error), () => done(error));
-    }
-  });
-}
-var REPORTED_SPAWN_CODES = new Set(["ENOENT", "EACCES", "EAGAIN", "EMFILE", "ENFILE"]);
-function reportedSpawnFailure(cause) {
-  return typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" && REPORTED_SPAWN_CODES.has(cause.code);
-}
-var waitClosed = (stream) => stream.closed ? Promise.resolve() : new Promise((resolve) => stream.once("close", () => resolve()));
-function defineBunChildren() {
-
-  class BunProcess extends EventEmitter {
-    pipes;
-    pid;
-    exitCode = null;
-    signalCode = null;
-    #subprocess;
-    constructor(pipes) {
-      super();
-      this.pipes = pipes;
-    }
-    watch(subprocess) {
-      this.pid = subprocess.pid;
-      this.#subprocess = subprocess;
-      subprocess.exited.then(() => {
-        this.exitCode = subprocess.exitCode;
-        this.signalCode = subprocess.signalCode;
-        this.emit("exit", this.exitCode, this.signalCode);
-        for (const pipe of this.pipes)
-          if (pipe.readableFlowing === null)
-            pipe.resume();
-        this.closeAfterPipes();
-      });
-    }
-    fail(cause) {
-      for (const pipe of this.pipes)
-        pipe.resume();
-      setImmediate(() => {
-        this.emit("error", cause);
-        this.closeAfterPipes();
-      });
-    }
-    kill(signal) {
-      const subprocess = this.#subprocess;
-      if (!subprocess || this.exitCode !== null || this.signalCode !== null)
-        return false;
-      try {
-        subprocess.kill(signal);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    closeAfterPipes() {
-      Promise.all(this.pipes.map(waitClosed)).then(() => this.emit("close", this.exitCode, this.signalCode));
-    }
-  }
-
-  class BunChild extends BunProcess {
-    stdin;
-    stdout;
-    stderr;
-    constructor(stdin, stdout, stderr) {
-      super([stdout, stderr]);
-      this.stdin = stdin;
-      this.stdout = stdout;
-      this.stderr = stderr;
-    }
-  }
-  return { BunProcess, BunChild };
-}
-var bunChildren;
-function children() {
-  bunChildren ??= defineBunChildren();
-  return bunChildren;
-}
-function sinkWritable(sink) {
-  let ended = false;
-  const end = () => {
-    if (ended)
-      return Promise.resolve(0);
-    ended = true;
-    return Promise.resolve().then(() => sink.end());
-  };
-  return new Writable({
-    write(chunk, _encoding, done) {
-      Promise.resolve().then(() => sink.write(chunk)).then(() => done(), done);
-    },
-    final(done) {
-      end().then(() => done(), done);
-    },
-    destroy(error, done) {
-      end().then(() => done(error), () => done(error));
-    }
-  });
-}
-function spawnBunChild(input) {
-  const { BunChild } = children();
-  try {
-    const subprocess = Bun.spawn([input.executable, ...input.args], {
-      cwd: input.cwd,
-      env: input.env,
-      detached: input.group,
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const child = new BunChild(sinkWritable(subprocess.stdin), readableOf(subprocess.stdout), readableOf(subprocess.stderr));
-    child.watch(subprocess);
-    return child;
-  } catch (cause) {
-    if (!reportedSpawnFailure(cause))
-      throw cause;
-    const child = new BunChild(new Writable({ write: (_chunk, _encoding, done) => done() }), Readable.from([]), Readable.from([]));
-    child.fail(cause);
-    return child;
-  }
-}
-function spawnBunInheritedChild(input) {
-  const { BunProcess } = children();
-  const child = new BunProcess([]);
-  try {
-    child.watch(Bun.spawn([input.executable, ...input.args], {
-      cwd: input.cwd,
-      env: input.env,
-      detached: input.group,
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit"
-    }));
-  } catch (cause) {
-    if (!reportedSpawnFailure(cause))
-      throw cause;
-    child.fail(cause);
-  }
-  return child;
-}
-
-// src/process/owned-child.ts
+import { Duplex } from "node:stream";
 var groups = new WeakSet;
 function spawnOwnedCommand(input) {
   const child = hostIsBun() ? spawnBunChild(input) : nodeChild(input);
@@ -573,12 +281,27 @@ function spawnOwnedCommand(input) {
   return child;
 }
 function nodeChild(input) {
-  return spawn(input.executable, [...input.args], {
+  if (input.ownerLoss === undefined)
+    return spawn(input.executable, [...input.args], {
+      cwd: input.cwd,
+      env: input.env,
+      detached: input.group,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  const [executable, ...args] = ownerLossGuardCommand(input.ownerLoss, input.executable, input.args);
+  const child = spawn(executable, args, {
     cwd: input.cwd,
     env: input.env,
     detached: input.group,
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe", "pipe"]
   });
+  const control = child.stdio[3];
+  if (!(control instanceof Duplex)) {
+    abortOwnerLossLaunch(child.pid);
+    throw new Error("Owner-loss guard supplied no control pipe");
+  }
+  attachOwnerLossControl(child, control);
+  return child;
 }
 var INHERITED_OUTPUT = {
   destroyed: true,
@@ -614,12 +337,31 @@ class InheritedChild {
   }
 }
 function spawnInheritedCommand(input) {
-  const child = new InheritedChild(hostIsBun() ? spawnBunInheritedChild(input) : spawn(input.executable, [...input.args], {
-    cwd: input.cwd,
-    env: input.env,
-    detached: input.group,
-    stdio: "inherit"
-  }));
+  const observable = hostIsBun() ? spawnBunInheritedChild(input) : (() => {
+    if (input.ownerLoss === undefined)
+      return spawn(input.executable, [...input.args], {
+        cwd: input.cwd,
+        env: input.env,
+        detached: input.group,
+        stdio: "inherit"
+      });
+    const [executable, ...args] = ownerLossGuardCommand(input.ownerLoss, input.executable, input.args);
+    const spawned = spawn(executable, args, {
+      cwd: input.cwd,
+      env: input.env,
+      detached: input.group,
+      stdio: ["inherit", "inherit", "inherit", "pipe"]
+    });
+    const control = spawned.stdio[3];
+    if (!(control instanceof Duplex)) {
+      abortOwnerLossLaunch(spawned.pid);
+      throw new Error("Owner-loss guard supplied no control pipe");
+    }
+    attachOwnerLossControl(spawned, control);
+    return spawned;
+  })();
+  const child = new InheritedChild(observable);
+  transferOwnerLossControl(observable, child);
   if (input.group)
     groups.add(child);
   return child;
@@ -629,7 +371,7 @@ function ownsCommandGroup(child) {
 }
 
 // src/process/transport.ts
-import { Readable as Readable2, Writable as Writable2 } from "node:stream";
+import { Readable, Writable } from "node:stream";
 function createCommandTransport(child) {
   const leader = Promise.withResolvers();
   const closed = Promise.withResolvers();
@@ -686,17 +428,17 @@ function createCommandTransport(child) {
       stderr = child.stderr;
       destructors.set("stderr", () => stderr?.destroy());
       const input = "stdin" in child ? child.stdin : undefined;
-      if (input instanceof Writable2) {
+      if (input instanceof Writable) {
         stdin = input;
         pendingHandles.add("stdin");
         destructors.set("stdin", () => input.destroy());
         pipe("stdin", input);
       }
-      if (stdout instanceof Readable2)
+      if (stdout instanceof Readable)
         pipe("stdout", stdout);
-      if (stderr instanceof Readable2)
+      if (stderr instanceof Readable)
         pipe("stderr", stderr);
-      if (stdout instanceof Readable2 && stderr instanceof Readable2)
+      if (stdout instanceof Readable && stderr instanceof Readable)
         release("launcher");
       return { stdout, stderr };
     },
@@ -714,7 +456,7 @@ function createCommandTransport(child) {
             child.stdout.destroy();
           else if (name === "stderr")
             child.stderr.destroy();
-          else if ("stdin" in child && child.stdin instanceof Writable2)
+          else if ("stdin" in child && child.stdin instanceof Writable)
             child.stdin.destroy();
         } catch (cause) {
           failures.push(cause);
@@ -747,7 +489,7 @@ function nativeCommandOwner(child) {
   return owners.get(child);
 }
 function outputStream(source, closed, maxBufferedBytes) {
-  if (source instanceof Readable3)
+  if (source instanceof Readable2)
     return {
       bytes: source,
       destroy() {
@@ -830,7 +572,8 @@ function launchNativeCommand({
     args: options.args,
     cwd: options.cwd,
     env: options.envPolicy === "ambient" ? { ...process.env, ...options.env } : options.env ?? {},
-    group: options.group === "own" && (driver?.group ?? true)
+    group: options.group === "own" && (driver?.group ?? true),
+    ownerLoss: options.ownerLoss === "terminate" ? { entry: ownerLossGuardEntry(), signalTarget: options.stop.target } : undefined
   };
   let inherited;
   if (!launch) {
@@ -859,10 +602,12 @@ function launchNativeCommand({
     ...transport,
     stdout: stdout.bytes,
     stderr: stderr.bytes,
-    start() {
+    async start() {
       if (native)
         onSpawn?.(native);
+      const pid = await awaitCommandStart(child);
       stdin?.end(options.stdin);
+      return pid;
     }
   };
 }
@@ -1021,6 +766,10 @@ function startNativeCommand(input, onSpawn, driver) {
   killOn?.throwIfAborted();
   if (process.platform === "win32" && driver?.group !== false)
     throw new NativeCommandError2("COMMAND_UNAVAILABLE", "POSIX process groups are required");
+  if (options.ownerLoss === "terminate" && !ownerLossAvailable(process.platform))
+    throw new NativeCommandError2("COMMAND_UNAVAILABLE", "ownerLoss: 'terminate' is available on Linux and Darwin");
+  if (options.ownerLoss === "terminate" && (driver?.launch !== undefined || driver?.group === false))
+    throw new NativeCommandError2("COMMAND_UNAVAILABLE", "ownerLoss: 'terminate' requires the package-owned process-group launcher");
   const { cleanupTimeoutMs, timeoutMs } = nativeCommandBudgets(options, driver);
   const controller = new AbortController;
   const abort = () => controller.abort(options.signal?.reason);
@@ -1126,8 +875,7 @@ function startNativeCommand(input, onSpawn, driver) {
   };
   const run = (async () => {
     try {
-      launched.start();
-      const pid = acquired?.child.pid;
+      const pid = await raceAbort(launched.start(), controller.signal);
       if (pid !== undefined)
         options.onLeaderStarted?.({ pid });
       const drains = Promise.all([
@@ -1166,4 +914,4 @@ function startNativeCommand(input, onSpawn, driver) {
   return owner;
 }
 
-export { COMMAND_CLEANUP_TIMEOUT_MS, NativeCommandError2, CommandStopped, spawnOwnedCommand, nativeCommandOwner, terminateOwnedGroup, startNativeCommand };
+export { CommandStopped, spawnOwnedCommand, nativeCommandOwner, terminateOwnedGroup, startNativeCommand };