stitchkit 0.108.2 → 0.108.4

package/dist/index-dj1aycxw.js

@@ -0,0 +1,639 @@
+import {
+  MAX_TIMER_MS
+} from "./index-eemvahkc.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"),
+  ownerLoss: z.enum(["terminate"]).optional(),
+  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.group === "caller" && input.ownerLoss !== undefined)
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "ownerLoss: 'terminate' requires group: 'own'"
+    });
+  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/owner-loss-guard.ts
+import { spawn } from "node:child_process";
+import { Socket } from "node:net";
+import { fileURLToPath } from "node:url";
+
+// src/process/bun-child.ts
+import { EventEmitter } from "node:events";
+import { Readable, Writable } from "node:stream";
+
+// src/process/owner-loss-control.ts
+import { z as z2 } from "zod";
+var MAX_GUARD_MESSAGE_BYTES = 4096;
+var OwnerLossGuardMessageSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({ kind: z2.literal("started"), pid: z2.number().int().positive() }),
+  z2.strictObject({
+    kind: z2.literal("unavailable"),
+    message: z2.string().min(1).max(1024),
+    code: z2.string().min(1).max(64).optional()
+  })
+]);
+var guards = new WeakMap;
+function abortOwnerLossLaunch(pid) {
+  if (pid === undefined)
+    return;
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch (error) {
+    if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
+      throw error;
+  }
+}
+function unavailable(message, cause) {
+  return new NativeCommandError2("COMMAND_UNAVAILABLE", "Command could not start", {
+    cause: cause ?? new Error(message)
+  });
+}
+function attachOwnerLossControl(child, control) {
+  const settled = Promise.withResolvers();
+  settled.promise.catch(() => {
+    return;
+  });
+  let complete = false;
+  let bytes = 0;
+  let text = "";
+  const decoder = new TextDecoder;
+  const ignoreSettledError = () => {
+    return;
+  };
+  const finish = (outcome) => {
+    if (complete)
+      return;
+    complete = true;
+    control.off("data", onData);
+    control.off("end", onMissing);
+    control.off("close", onMissing);
+    control.off("error", onError);
+    control.on("error", ignoreSettledError);
+    control.once("close", () => control.off("error", ignoreSettledError));
+    if ("pid" in outcome)
+      settled.resolve(outcome.pid);
+    else
+      settled.reject(outcome.error);
+  };
+  const onMissing = () => finish({ error: unavailable("Owner-loss guard exited before the command started") });
+  const onError = (cause) => finish({ error: unavailable("Owner-loss guard control failed", cause) });
+  const onData = (chunk) => {
+    if (complete)
+      return;
+    bytes += chunk.byteLength;
+    if (bytes > MAX_GUARD_MESSAGE_BYTES) {
+      finish({ error: unavailable("Owner-loss guard response exceeded its finite bound") });
+      return;
+    }
+    text += decoder.decode(chunk, { stream: true });
+    const newline = text.indexOf(`
+`);
+    if (newline < 0)
+      return;
+    try {
+      const message = OwnerLossGuardMessageSchema.parse(JSON.parse(text.slice(0, newline)));
+      if (message.kind === "started")
+        finish({ pid: message.pid });
+      else {
+        const cause = new Error(message.message);
+        if (message.code !== undefined)
+          Object.defineProperty(cause, "code", { value: message.code });
+        finish({ error: unavailable(message.message, cause) });
+      }
+    } catch (cause) {
+      finish({ error: unavailable("Owner-loss guard returned an invalid response", cause) });
+    }
+  };
+  control.on("data", onData);
+  control.once("end", onMissing);
+  control.once("close", onMissing);
+  control.once("error", onError);
+  child.on("exit", onMissing);
+  guards.set(child, { control, started: settled.promise });
+}
+function transferOwnerLossControl(source, target) {
+  const registration = guards.get(source);
+  if (registration !== undefined)
+    guards.set(target, registration);
+}
+async function awaitCommandStart(child) {
+  const registration = guards.get(child);
+  if (registration !== undefined)
+    await registration.started;
+  return child.pid;
+}
+
+// src/process/owner-loss-protocol.ts
+var OWNER_LOSS_GUARD_FLAG = "--stitchkit-owner-loss-guard-v1";
+function ownerLossAvailable(platform) {
+  return platform === "linux" || platform === "darwin";
+}
+function ownerLossGuardCommand(guard, executable, args) {
+  return [
+    process.execPath,
+    guard.entry,
+    OWNER_LOSS_GUARD_FLAG,
+    guard.signalTarget,
+    executable,
+    ...args
+  ];
+}
+
+// src/process/owner-loss-socket.ts
+import { connect } from "node:net";
+function connectOwnerLossSocket(fd) {
+  return Reflect.apply(connect, undefined, [{ fd }]);
+}
+
+// src/process/bun-child.ts
+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 ownerLoss = input.ownerLoss;
+    const guarded = ownerLoss !== undefined;
+    const command = guarded ? ownerLossGuardCommand(ownerLoss, input.executable, input.args) : [input.executable, ...input.args];
+    const subprocess = guarded ? Bun.spawn(command, {
+      cwd: input.cwd,
+      env: input.env,
+      detached: input.group,
+      stdio: ["pipe", "pipe", "pipe", "socket-fd"]
+    }) : Bun.spawn(command, {
+      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);
+    if (guarded) {
+      const fd = subprocess.stdio[3];
+      if (typeof fd !== "number") {
+        abortOwnerLossLaunch(subprocess.pid);
+        throw new Error("Owner-loss guard supplied no control socket");
+      }
+      attachOwnerLossControl(child, connectOwnerLossSocket(fd));
+    }
+    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 {
+    const ownerLoss = input.ownerLoss;
+    const guarded = ownerLoss !== undefined;
+    const command = guarded ? ownerLossGuardCommand(ownerLoss, input.executable, input.args) : [input.executable, ...input.args];
+    const subprocess = guarded ? Bun.spawn(command, {
+      cwd: input.cwd,
+      env: input.env,
+      detached: input.group,
+      stdio: ["inherit", "inherit", "inherit", "socket-fd"]
+    }) : Bun.spawn(command, {
+      cwd: input.cwd,
+      env: input.env,
+      detached: input.group,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    child.watch(subprocess);
+    if (guarded) {
+      const fd = subprocess.stdio[3];
+      if (typeof fd !== "number") {
+        abortOwnerLossLaunch(subprocess.pid);
+        throw new Error("Owner-loss guard supplied no control socket");
+      }
+      attachOwnerLossControl(child, connectOwnerLossSocket(fd));
+    }
+  } catch (cause) {
+    if (!reportedSpawnFailure(cause))
+      throw cause;
+    child.fail(cause);
+  }
+  return child;
+}
+function spawnBunGuardTarget(executable, args) {
+  return Bun.spawn([executable, ...args], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+}
+
+// src/process/owner-loss-guard.ts
+var FORWARDED_SIGNALS = [
+  "SIGTERM",
+  "SIGINT",
+  "SIGHUP",
+  "SIGQUIT",
+  "SIGUSR1",
+  "SIGUSR2"
+];
+function causeMessage(cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  if (typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string")
+    return { message, code: cause.code };
+  return { message };
+}
+function guardMessage(control, message, written) {
+  control.write(`${JSON.stringify(message)}
+`, written);
+}
+function mirrorTargetExit(control, code, signal) {
+  control.destroy();
+  if (signal !== null)
+    process.kill(process.pid, signal);
+  else
+    process.exitCode = code ?? 1;
+}
+function refuseTarget(control, cause) {
+  const detail = causeMessage(cause);
+  control.end(`${JSON.stringify({ kind: "unavailable", ...detail })}
+`, () => {
+    process.exitCode = 127;
+  });
+}
+function spawnNodeTarget(executable, args, onStarted, onExit, onUnavailable) {
+  let child;
+  try {
+    child = spawn(executable, [...args], { stdio: "inherit" });
+  } catch (cause) {
+    onUnavailable(cause);
+    return;
+  }
+  child.once("spawn", () => {
+    const pid = child.pid;
+    if (pid === undefined)
+      onUnavailable(new Error("Command started without a pid"));
+    else
+      onStarted(pid);
+  });
+  child.once("error", onUnavailable);
+  child.once("exit", onExit);
+}
+function spawnBunTarget(executable, args, onStarted, onExit, onUnavailable) {
+  let child;
+  try {
+    child = spawnBunGuardTarget(executable, args);
+  } catch (cause) {
+    onUnavailable(cause);
+    return;
+  }
+  onStarted(child.pid);
+  child.exited.then(() => onExit(child.exitCode, child.signalCode));
+}
+function runOwnerLossGuard(signalTarget, executable, args) {
+  const bun = hostIsBun();
+  const control = bun ? connectOwnerLossSocket(3) : new Socket({ fd: 3, readable: true, writable: true });
+  let armed = true;
+  const ownerLost = () => {
+    if (!armed)
+      return;
+    process.kill(-process.pid, "SIGKILL");
+  };
+  control.once("end", ownerLost);
+  control.once("close", ownerLost);
+  control.once("error", ownerLost);
+  if (signalTarget !== "group" && signalTarget !== "leader" || executable === undefined) {
+    armed = false;
+    refuseTarget(control, new Error("Owner-loss guard received an invalid invocation"));
+    return;
+  }
+  let targetPid;
+  let handshakeWritten = false;
+  let pendingTargetExit;
+  const forwarders = new Map;
+  if (signalTarget === "leader")
+    for (const signal of FORWARDED_SIGNALS) {
+      const forward = () => {
+        if (targetPid === undefined)
+          return;
+        try {
+          process.kill(targetPid, signal);
+        } catch (error) {
+          if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
+            throw error;
+        }
+      };
+      forwarders.set(signal, forward);
+      process.on(signal, forward);
+    }
+  const removeForwarders = () => {
+    for (const [signal, forward] of forwarders)
+      process.removeListener(signal, forward);
+    forwarders.clear();
+  };
+  const targetStarted = (pid) => {
+    targetPid = pid;
+    guardMessage(control, { kind: "started", pid }, () => {
+      handshakeWritten = true;
+      const pending = pendingTargetExit;
+      if (pending !== undefined) {
+        pendingTargetExit = undefined;
+        targetExit(pending.code, pending.signal);
+      }
+    });
+  };
+  const targetExit = (code, signal) => {
+    if (!handshakeWritten) {
+      pendingTargetExit = { code, signal };
+      return;
+    }
+    armed = false;
+    removeForwarders();
+    mirrorTargetExit(control, code, signal);
+  };
+  const targetUnavailable = (cause) => {
+    armed = false;
+    removeForwarders();
+    refuseTarget(control, cause);
+  };
+  if (!bun)
+    spawnNodeTarget(executable, args, targetStarted, targetExit, targetUnavailable);
+  else
+    spawnBunTarget(executable, args, targetStarted, targetExit, targetUnavailable);
+}
+var guardInvocation = false;
+function startOwnerLossGuardEntry() {
+  if (process.argv[2] !== OWNER_LOSS_GUARD_FLAG)
+    return;
+  const entry = process.argv[1];
+  if (entry === undefined || fileURLToPath(import.meta.url) !== entry)
+    return;
+  runOwnerLossGuard(process.argv[3], process.argv[4], process.argv.slice(5));
+  guardInvocation = true;
+}
+function bootstrapNativeCommandOwnerLoss2() {
+  return guardInvocation;
+}
+function ownerLossGuardEntry() {
+  return fileURLToPath(import.meta.url);
+}
+startOwnerLossGuardEntry();
+
+export { COMMAND_CLEANUP_TIMEOUT_MS, NativeCommandOptionsSchema, NativeCommandError2, abortOwnerLossLaunch, attachOwnerLossControl, transferOwnerLossControl, awaitCommandStart, ownerLossAvailable, ownerLossGuardCommand, hostIsBun, spawnBunChild, spawnBunInheritedChild, bootstrapNativeCommandOwnerLoss2, ownerLossGuardEntry };

package/dist/{index-4qh90tyw.js → index-fgq4w9bf.js}

@@ -183,6 +183,25 @@ function unwrap(field) {
   }
   return field;
 }
+function literalKind(field) {
+  const base = unwrap(field);
+  if (base instanceof z.ZodLiteral) {
+    const kinds = new Set;
+    for (const value of base.values) {
+      const kind = typeof value;
+      if (kind !== "boolean" && kind !== "number" && kind !== "bigint" && kind !== "string")
+        return;
+      kinds.add(kind);
+    }
+    return kinds.size === 1 ? kinds.values().next().value : undefined;
+  }
+  if (base instanceof z.ZodUnion) {
+    const kinds = base.def.options.map(literalKind);
+    const first = kinds[0];
+    return first !== undefined && kinds.every((kind) => kind === first) ? first : undefined;
+  }
+  return;
+}
 function classify(field) {
   if (field instanceof z.ZodBoolean)
     return "boolean";
@@ -198,7 +217,10 @@ function classify(field) {
     return "array";
   if (field instanceof z.ZodObject)
     return "object";
-  if (field instanceof z.ZodString || field instanceof z.ZodLiteral)
+  const primitiveLiteral = literalKind(field);
+  if (primitiveLiteral !== undefined)
+    return primitiveLiteral;
+  if (field instanceof z.ZodString)
     return "string";
   return "other";
 }

package/dist/{index-vyaehh67.js → index-sjntc4az.js}

@@ -2,10 +2,8 @@ import {
   loadDarwinBinding
 } from "./index-2kbysk9s.js";
 import {
-  NativeCommandError2,
-  CommandStopped,
-  startNativeCommand
-} from "./index-k0kzhdw9.js";
+  NativeCommandError2
+} from "./index-dj1aycxw.js";
 import {
   probeAgentProcessSandboxOutcome,
   missingSandboxRestrictions2,
@@ -13,6 +11,10 @@ import {
   codingPathRefusal,
   refuseMissingCodingPath
 } from "./index-8ks9b85e.js";
+import {
+  CommandStopped,
+  startNativeCommand
+} from "./index-dasy32c8.js";
 import {
   NumericFileHandle,
   descriptorPath,
@@ -923,7 +925,8 @@ async function editFile(config, limits, input) {
         });
       }
       const replacements = input.replaceAll ? count : 1;
-      const changed = input.replaceAll ? source.replaceAll(input.oldText, input.newText) : source.replace(input.oldText, () => input.newText);
+      const literalReplacement = () => input.newText;
+      const changed = input.replaceAll ? source.replaceAll(input.oldText, literalReplacement) : source.replace(input.oldText, literalReplacement);
       const bytes = Buffer.byteLength(changed);
       const resultSha256 = sha256(changed);
       if (bytes > limits.maxWriteBytes) {