stitchkit 0.103.11 → 0.103.12

package/dist/{index-32jkwkdm.js → index-f330qqyg.js}

@@ -116,22 +116,22 @@ async function signalUntilSettled(pid, signal, deadline) {
       signalGroup(pid, signal);
       return;
     } catch (error) {
-      if (!deniedOnDarwin(error) || Date.now() >= deadline)
+      if (!deniedOnDarwin(error) || performance.now() >= deadline)
         throw error;
-      await new Promise((resolve) => setTimeout(resolve, Math.min(10, deadline - Date.now())));
+      await new Promise((resolve) => setTimeout(resolve, Math.min(10, deadline - performance.now())));
     }
   }
 }
 async function stopCommandGroup(pid, graceMs, cleanupTimeoutMs = 2000, force = false) {
-  const deadline = Date.now() + graceMs + cleanupTimeoutMs;
+  const deadline = performance.now() + graceMs + cleanupTimeoutMs;
   if (force) {
     await signalUntilSettled(pid, "SIGKILL", deadline);
     return;
   }
   await signalUntilSettled(pid, "SIGTERM", deadline);
-  const until = Date.now() + graceMs;
-  while (Date.now() < until && exists(pid))
-    await new Promise((resolve) => setTimeout(resolve, Math.min(10, until - Date.now())));
+  const until = performance.now() + graceMs;
+  while (performance.now() < until && exists(pid))
+    await new Promise((resolve) => setTimeout(resolve, Math.min(10, until - performance.now())));
   await signalUntilSettled(pid, "SIGKILL", deadline);
 }
 function commandCleanupError(cause) {
@@ -144,9 +144,188 @@ function waitForCommandClose(closed, timeoutMs) {
   return raceAbort(closed, deadline.signal).finally(() => deadline.cancel());
 }
 
+// src/process/cleanup.ts
+async function cleanupNativeCommand(input) {
+  const cleanup = await Promise.allSettled([
+    input.settle(input.event ?? { kind: "error", cause: input.error }),
+    Promise.resolve().then(() => input.transport?.destroy()),
+    Promise.resolve().then(input.signal).then(async () => {
+      if (!input.transport)
+        return;
+      try {
+        await waitForCommandClose(input.transport.released, input.timeoutMs);
+      } catch (cause) {
+        throw new Error(`Command handles remained open: ${[...input.transport.pendingHandles].join(", ")}`, { cause });
+      }
+    })
+  ]);
+  const failures = cleanup.flatMap((item) => item.status === "rejected" && item.reason !== input.error ? [item.reason] : []);
+  if (failures.length)
+    throw commandCleanupError(new AggregateError([input.error, ...failures], "Command failed and cleanup failed"));
+}
+
+// src/process/command-lifetime.ts
+function createCommandLifetime(input) {
+  const acceptSettlement = (error) => {
+    if (error instanceof NativeCommandError2 && error.code === "COMMAND_CLEANUP")
+      throw error;
+  };
+  return {
+    result: input.result,
+    async terminate() {
+      let refused = false;
+      let refusal;
+      if (!input.finished()) {
+        try {
+          await input.signal();
+        } catch (error) {
+          refused = true;
+          refusal = error;
+          input.controller.abort(error);
+        }
+        try {
+          await waitForCommandClose(input.result, input.cleanupTimeoutMs);
+        } catch (error) {
+          if (!input.finished())
+            input.controller.abort(error);
+        }
+      }
+      await input.result.then(() => {
+        return;
+      }, acceptSettlement);
+      if (refused)
+        throw commandCleanupError(refusal);
+    },
+    async stop() {
+      if (!input.finished())
+        input.controller.abort(new DOMException("Command stopped", "AbortError"));
+      await input.result.then(() => {
+        return;
+      }, acceptSettlement);
+    }
+  };
+}
+
 // src/process/launch.ts
+import { Readable as Readable2 } from "node:stream";
+
+// src/process/owned-child.ts
 import { spawn } from "node:child_process";
+var groups = new WeakSet;
+function spawnOwnedCommand(input) {
+  const child = spawn(input.executable, [...input.args], {
+    cwd: input.cwd,
+    env: input.env,
+    detached: input.group,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (input.group)
+    groups.add(child);
+  return child;
+}
+function ownsCommandGroup(child) {
+  return groups.has(child);
+}
+
+// src/process/transport.ts
 import { Readable, Writable } from "node:stream";
+function createCommandTransport(child) {
+  const leader = Promise.withResolvers();
+  const closed = Promise.withResolvers();
+  const released = Promise.withResolvers();
+  const pendingHandles = new Set(["leader", "launcher", "stdout", "stderr"]);
+  const destructors = new Map;
+  let stdout;
+  let stderr;
+  let stdin;
+  let isClosed = false;
+  const release = (name) => {
+    pendingHandles.delete(name);
+    if (pendingHandles.size === 0)
+      released.resolve();
+  };
+  const settled = (event) => {
+    leader.resolve(event);
+    release("leader");
+  };
+  const pipe = (name, source) => {
+    if (isClosed || source.closed)
+      release(name);
+    else
+      source.once("close", () => release(name));
+  };
+  return {
+    child,
+    leader: leader.promise,
+    closed: closed.promise,
+    released: released.promise,
+    pendingHandles,
+    get stdin() {
+      return stdin;
+    },
+    observe(onFailure) {
+      child.on("close", (exitCode, signal) => {
+        isClosed = true;
+        closed.resolve({ exitCode, signal });
+        settled({ kind: "exit", exitCode, signal });
+        pendingHandles.clear();
+        released.resolve();
+      });
+      child.on("error", (cause) => {
+        settled({ kind: "error", cause });
+        onFailure(cause);
+      });
+      child.on("exit", (exitCode, signal) => settled({ kind: "exit", exitCode, signal }));
+      if (child.exitCode !== null || child.signalCode !== null)
+        settled({ kind: "exit", exitCode: child.exitCode, signal: child.signalCode });
+    },
+    capture() {
+      stdout = child.stdout;
+      destructors.set("stdout", () => stdout?.destroy());
+      stderr = child.stderr;
+      destructors.set("stderr", () => stderr?.destroy());
+      const input = "stdin" in child ? child.stdin : undefined;
+      if (input instanceof Writable) {
+        stdin = input;
+        pendingHandles.add("stdin");
+        destructors.set("stdin", () => input.destroy());
+        pipe("stdin", input);
+      }
+      if (stdout instanceof Readable)
+        pipe("stdout", stdout);
+      if (stderr instanceof Readable)
+        pipe("stderr", stderr);
+      if (stdout instanceof Readable && stderr instanceof Readable)
+        release("launcher");
+      return { stdout, stderr };
+    },
+    pipeDestructor(name, destroy) {
+      destructors.set(name, destroy);
+    },
+    destroy() {
+      const failures = [];
+      for (const name of ["stdin", "stdout", "stderr"]) {
+        try {
+          const destroy = destructors.get(name);
+          if (destroy)
+            destroy();
+          else if (name === "stdout")
+            child.stdout.destroy();
+          else if (name === "stderr")
+            child.stderr.destroy();
+          else if ("stdin" in child && child.stdin instanceof Writable)
+            child.stdin.destroy();
+        } catch (cause) {
+          failures.push(cause);
+        }
+      }
+      if (failures.length)
+        throw new AggregateError(failures, "Command pipe teardown failed");
+    }
+  };
+}
+
+// src/process/launch.ts
 function nativeCommandBudgets(options, driver) {
   const cleanupTimeoutMs = driver?.cleanupTimeoutMs ?? options.cleanupTimeoutMs;
   const timeoutMs = driver?.timeoutMs ?? options.timeoutMs;
@@ -167,10 +346,9 @@ function nativeCommandOwner(child) {
   return owners.get(child);
 }
 function outputStream(source, closed, maxBufferedBytes) {
-  if (source instanceof Readable)
+  if (source instanceof Readable2)
     return {
       bytes: source,
-      released: new Promise((resolve) => source.closed ? resolve() : source.once("close", resolve)),
       destroy() {
         source.destroy();
       }
@@ -227,9 +405,6 @@ function outputStream(source, closed, maxBufferedBytes) {
         }
       }
     },
-    released: closed.then(() => {
-      return;
-    }),
     destroy() {
       ended = true;
       queue.length = 0;
@@ -239,80 +414,41 @@ function outputStream(source, closed, maxBufferedBytes) {
     }
   };
 }
-function launchNativeCommand(options, driver, onSpawn, onFailure, onInputFailure) {
+function launchNativeCommand(options, driver, onSpawn, onFailure, onInputFailure, onAcquired) {
   let native;
   const launch = driver?.launch;
   if (!launch)
-    native = spawn(options.executable, options.args, {
+    native = spawnOwnedCommand({
+      executable: options.executable,
+      args: options.args,
       cwd: options.cwd,
       env: options.envPolicy === "ambient" ? { ...process.env, ...options.env } : options.env ?? {},
-      detached: driver?.group ?? true,
-      stdio: ["pipe", "pipe", "pipe"]
+      group: driver?.group ?? true
     });
   const child = launch ? launch() : native;
   if (!child)
     throw new Error("Native command launcher did not supply a process");
-  const pendingHandles = new Set(["leader"]);
-  const leader = new Promise((resolve) => {
-    child.on("exit", (exitCode, signal) => resolve({ kind: "exit", exitCode, signal }));
-    child.on("error", (cause) => resolve({ kind: "error", cause }));
-    if (child.exitCode !== null || child.signalCode !== null)
-      resolve({ kind: "exit", exitCode: child.exitCode, signal: child.signalCode });
-  });
-  const closed = new Promise((resolve) => {
-    child.on("error", onFailure);
-    child.on("close", (exitCode, signal) => resolve({ exitCode, signal }));
-  });
-  const stdout = outputStream(child.stdout, closed, driver?.maxBufferedBytes ?? 1024 * 1024);
-  const stderr = outputStream(child.stderr, closed, driver?.maxBufferedBytes ?? 1024 * 1024);
-  const stdin = "stdin" in child && child.stdin instanceof Writable ? child.stdin : undefined;
-  const handles = [
-    ["stdout", stdout.released],
-    ["stderr", stderr.released]
-  ];
-  if (stdin)
-    handles.push([
-      "stdin",
-      new Promise((resolve) => stdin.closed ? resolve() : stdin.once("close", resolve))
-    ]);
-  const released = Promise.all([
-    leader.then(() => pendingHandles.delete("leader")),
-    ...handles.map(([name, released]) => {
-      pendingHandles.add(name);
-      return released.then(() => pendingHandles.delete(name));
-    }),
-    ...child.stdout instanceof Readable && child.stderr instanceof Readable ? [] : [closed.then(() => pendingHandles.delete("launcher"))]
-  ]);
-  if (!(child.stdout instanceof Readable && child.stderr instanceof Readable))
-    pendingHandles.add("launcher");
+  const transport = createCommandTransport(child);
+  onAcquired(transport);
+  transport.observe(onFailure);
+  const pipes = transport.capture();
+  const stdout = outputStream(pipes.stdout, transport.closed, driver?.maxBufferedBytes ?? 1024 * 1024);
+  transport.pipeDestructor("stdout", () => stdout.destroy());
+  const stderr = outputStream(pipes.stderr, transport.closed, driver?.maxBufferedBytes ?? 1024 * 1024);
+  transport.pipeDestructor("stderr", () => stderr.destroy());
+  const stdin = transport.stdin;
   stdin?.on("error", (error) => {
     if (!(("code" in error) && error.code === "EPIPE"))
       onInputFailure(error);
   });
   return {
-    child,
+    ...transport,
     stdout: stdout.bytes,
     stderr: stderr.bytes,
-    leader,
-    closed,
-    released,
-    pendingHandles,
     start() {
       if (native)
         onSpawn?.(native);
       stdin?.end(options.stdin);
-    },
-    destroy() {
-      const failures = [];
-      for (const handle of [stdin, stdout, stderr]) {
-        try {
-          handle?.destroy();
-        } catch (cause) {
-          failures.push(cause);
-        }
-      }
-      if (failures.length)
-        throw new AggregateError(failures, "Command pipe teardown failed");
     }
   };
 }
@@ -374,30 +510,12 @@ function createLeaderSettlement(options, signal) {
 }
 
 // src/process/start-failure.ts
-function failedCommandStart(cause, settle) {
+async function failedCommandStart(cause, cleanup) {
   const error = new NativeCommandError2("COMMAND_UNAVAILABLE", "Command could not start", {
     cause
   });
-  const result = (async () => {
-    try {
-      await settle({ kind: "error", cause });
-    } catch (cleanup) {
-      throw commandCleanupError(new AggregateError([error, cleanup], "Command failed and cleanup failed"));
-    }
-    throw error;
-  })();
-  result.catch(() => {
-    return;
-  });
-  return {
-    result,
-    async stop() {
-      await result.catch((failure) => {
-        if (failure instanceof NativeCommandError2 && failure.code === "COMMAND_CLEANUP")
-          throw failure;
-      });
-    }
-  };
+  await cleanup(error);
+  throw error;
 }
 
 // src/process/command-owner.ts
@@ -421,6 +539,31 @@ function startNativeCommand(input, onSpawn, driver) {
   else
     deadline?.signal.addEventListener("abort", expired, { once: true });
   const settle = createLeaderSettlement({ ...options, cleanupTimeoutMs }, controller.signal);
+  let acquired;
+  let finished = false;
+  const completion = Promise.withResolvers();
+  const result = completion.promise.finally(() => {
+    finished = true;
+  });
+  result.catch(() => {
+    return;
+  });
+  const signalOwned = (force = driver?.force) => {
+    const child = acquired?.child;
+    if (!child)
+      return Promise.resolve();
+    return driver?.group === false || !ownsCommandGroup(child) ? Promise.resolve().then(() => {
+      if (child.exitCode === null && child.signalCode === null && !child.kill("SIGKILL"))
+        throw new Error("Command leader termination was refused");
+    }) : stopCommandGroup(child.pid, options.killGraceMs, cleanupTimeoutMs, force);
+  };
+  const owner = createCommandLifetime({
+    result,
+    controller,
+    finished: () => finished,
+    signal: () => signalOwned(true),
+    cleanupTimeoutMs
+  });
   let spawnFailure;
   let launched;
   try {
@@ -429,32 +572,30 @@ function startNativeCommand(input, onSpawn, driver) {
         cause: error
       });
       controller.abort(spawnFailure);
-    }, (error) => controller.abort(error));
+    }, (error) => controller.abort(error), (transport) => {
+      acquired = transport;
+      registerNativeCommandOwner(transport.child, owner);
+    });
   } catch (cause) {
     deadline?.cancel();
     deadline?.signal.removeEventListener("abort", expired);
     options.signal?.removeEventListener("abort", abort);
     controller.abort(cause);
-    return failedCommandStart(cause, settle);
+    failedCommandStart(cause, (error) => cleanupNativeCommand({
+      error,
+      transport: acquired,
+      settle,
+      event: { kind: "error", cause },
+      signal: () => signalOwned(),
+      timeoutMs: cleanupTimeoutMs
+    })).then(completion.resolve, completion.reject);
+    return owner;
   }
   const stdout = [];
   const stderr = [];
   let total = 0;
-  let finished = false;
-  const {
-    child,
-    stdout: output,
-    stderr: errorOutput,
-    leader,
-    closed,
-    released,
-    pendingHandles
-  } = launched;
+  const { stdout: output, stderr: errorOutput, leader, closed } = launched;
   const cancelCloseDeadline = createLeaderCloseDeadline(leader, driver?.closeTimeoutMs, controller);
-  const signalOwned = (force = driver?.force) => driver?.group === false || driver?.launch && child.pid === undefined ? Promise.resolve().then(() => {
-    if (child.exitCode === null && child.signalCode === null && !child.kill("SIGKILL"))
-      throw new Error("Command leader termination was refused");
-  }) : stopCommandGroup(child.pid, options.killGraceMs, cleanupTimeoutMs, force);
   const drain = async (stream, channel, captured) => {
     for await (const chunk of stream) {
       controller.signal.throwIfAborted();
@@ -474,7 +615,7 @@ function startNativeCommand(input, onSpawn, driver) {
         }), controller.signal);
     }
   };
-  const result = (async () => {
+  const run = (async () => {
     try {
       launched.start();
       const drains = Promise.all([
@@ -488,23 +629,13 @@ function startNativeCommand(input, onSpawn, driver) {
       return { ...status, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) };
     } catch (error) {
       controller.abort(error);
-      const cleanup = await Promise.allSettled([
-        settle({ kind: "error", cause: error }),
-        Promise.resolve().then(() => launched.destroy()),
-        signalOwned().then(async () => {
-          try {
-            await waitForCommandClose(released, cleanupTimeoutMs);
-          } catch (cause) {
-            throw new Error(`Command handles remained open: ${[...pendingHandles].join(", ")}`, {
-              cause
-            });
-          }
-        })
-      ]);
-      const failures = cleanup.flatMap((item) => item.status === "rejected" && item.reason !== error ? [item.reason] : []);
-      if (failures.length) {
-        throw commandCleanupError(new AggregateError([error, ...failures], "Command failed and cleanup failed"));
-      }
+      await cleanupNativeCommand({
+        error,
+        transport: acquired,
+        settle,
+        signal: () => signalOwned(),
+        timeoutMs: cleanupTimeoutMs
+      });
       throw error;
     } finally {
       finished = true;
@@ -515,51 +646,8 @@ function startNativeCommand(input, onSpawn, driver) {
       controller.abort(new Error("Command completed"));
     }
   })();
-  result.catch(() => {
-    return;
-  });
-  const owner = {
-    result,
-    async terminate() {
-      let refused = false;
-      let refusal;
-      if (!finished) {
-        try {
-          await signalOwned(true);
-        } catch (error) {
-          refused = true;
-          refusal = error;
-          controller.abort(error);
-        }
-        try {
-          await waitForCommandClose(result, cleanupTimeoutMs);
-        } catch (error) {
-          if (!finished)
-            controller.abort(error);
-        }
-      }
-      await result.then(() => {
-        return;
-      }, (error) => {
-        if (error instanceof NativeCommandError2 && error.code === "COMMAND_CLEANUP")
-          throw error;
-      });
-      if (refused)
-        throw commandCleanupError(refusal);
-    },
-    async stop() {
-      if (!finished)
-        controller.abort(new DOMException("Command stopped", "AbortError"));
-      await result.then(() => {
-        return;
-      }, (error) => {
-        if (error instanceof NativeCommandError2 && error.code === "COMMAND_CLEANUP")
-          throw error;
-      });
-    }
-  };
-  registerNativeCommandOwner(child, owner);
+  run.then(completion.resolve, completion.reject);
   return owner;
 }
 
-export { NativeCommandError2, stopCommandGroup, nativeCommandOwner, startNativeCommand };
+export { NativeCommandError2, stopCommandGroup, spawnOwnedCommand, ownsCommandGroup, nativeCommandOwner, startNativeCommand };

package/dist/index-fm1c1a08.js

@@ -0,0 +1,138 @@
+// src/internal/json-string-size.ts
+function jsonStringSize(text, budget) {
+  if (text.length + 2 > budget)
+    return budget + 1;
+  let bytes = 2;
+  for (let index = 0;index < text.length && bytes <= budget; index++) {
+    const unit = text.charCodeAt(index);
+    if (unit === 34 || unit === 92)
+      bytes += 2;
+    else if (unit < 32)
+      bytes += unit === 8 || unit === 9 || unit === 10 || unit === 12 || unit === 13 ? 2 : 6;
+    else if (unit < 128)
+      bytes++;
+    else if (unit < 2048)
+      bytes += 2;
+    else if (unit >= 55296 && unit <= 56319) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index++;
+      } else
+        bytes += 6;
+    } else if (unit >= 56320 && unit <= 57343)
+      bytes += 6;
+    else
+      bytes += 3;
+  }
+  return bytes;
+}
+
+// src/internal/json-data.ts
+function isJsonData(value, limits, snapshot) {
+  const ancestors = new Set;
+  let nodes = 0;
+  let bytes = 0;
+  const byteLimit = limits.maxBytes;
+  const charge = (amount) => {
+    if (byteLimit === undefined)
+      return true;
+    bytes += amount;
+    return bytes <= byteLimit;
+  };
+  const chargeText = (text) => byteLimit === undefined || charge(jsonStringSize(text, byteLimit - bytes));
+  const visit = (item, depth, target, key) => {
+    if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+      return false;
+    let captured = item;
+    if (item === null) {
+      if (!charge(4))
+        return false;
+    } else if (typeof item === "string") {
+      if (!chargeText(item))
+        return false;
+    } else if (typeof item === "boolean") {
+      if (!charge(item ? 4 : 5))
+        return false;
+    } else if (typeof item === "number") {
+      if (!Number.isFinite(item) || Object.is(item, -0))
+        return false;
+      if (byteLimit !== undefined && !charge(String(item).length))
+        return false;
+    } else {
+      if (typeof item !== "object" || ancestors.has(item))
+        return false;
+      const array = Array.isArray(item);
+      const prototype = Object.getPrototypeOf(item);
+      if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+        return false;
+      let length = 0;
+      if (array) {
+        const descriptor = Object.getOwnPropertyDescriptor(item, "length");
+        if (!descriptor || !("value" in descriptor))
+          return false;
+        const capturedLength = descriptor.value;
+        if (typeof capturedLength !== "number" || !Number.isInteger(capturedLength) || capturedLength < 0 || capturedLength > 2 ** 32 - 1)
+          return false;
+        length = capturedLength;
+        if (length > limits.maxNodes - nodes)
+          return false;
+        if (byteLimit !== undefined && Math.max(2, length * 2 + 1) > byteLimit - bytes)
+          return false;
+      }
+      const keys = Reflect.ownKeys(item);
+      if (keys.length > limits.maxNodes - nodes + (array ? 1 : 0))
+        return false;
+      if (array && keys.length !== length + 1)
+        return false;
+      if (!charge(2))
+        return false;
+      const copy = target ? array ? [] : {} : undefined;
+      ancestors.add(item);
+      try {
+        let members = 0;
+        for (const memberKey of keys) {
+          if (array && memberKey === "length")
+            continue;
+          if (typeof memberKey !== "string")
+            return false;
+          if (array && (!/^(0|[1-9][0-9]*)$/.test(memberKey) || Number(memberKey) >= length))
+            return false;
+          const descriptor = Object.getOwnPropertyDescriptor(item, memberKey);
+          if (!descriptor?.enumerable || !("value" in descriptor))
+            return false;
+          const memberValue = descriptor.value;
+          if (!array && limits.omitObjectUndefined && memberValue === undefined) {
+            if (++nodes > limits.maxNodes)
+              return false;
+            continue;
+          }
+          if (members++ > 0 && !charge(1))
+            return false;
+          if (!array && (!chargeText(memberKey) || !charge(1)))
+            return false;
+          if (!visit(memberValue, depth + 1, copy, memberKey))
+            return false;
+        }
+        captured = copy;
+      } finally {
+        ancestors.delete(item);
+      }
+    }
+    if (target && key !== undefined)
+      Object.defineProperty(target, key, {
+        value: captured,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    return true;
+  };
+  try {
+    return visit(value, 0, snapshot, "value");
+  } catch {
+    return false;
+  }
+}
+
+export { isJsonData };