stitchkit 0.103.10 → 0.103.12

package/dist/index-6m6a9ty4.js

@@ -1,285 +0,0 @@
-import {
-  raceAbort
-} from "./index-mbnnw3f2.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("error"), cause: z.unknown() })
-]);
-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(2147483647).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(),
-  killGraceMs: z.number().int().nonnegative().max(1e4).default(100),
-  cleanupTimeoutMs: z.number().int().positive().max(30000).default(2000)
-}).superRefine((input, ctx) => {
-  if (!input.signal && input.timeoutMs === undefined)
-    ctx.addIssue({ code: "custom", message: "Declare a caller signal or a finite timeout" });
-  if (input.capture && input.maxOutputBytes === undefined)
-    ctx.addIssue({
-      code: "custom",
-      message: "Capture requires a finite combined output budget"
-    });
-  if (input.stdin && input.stdin.byteLength > input.maxStdinBytes)
-    ctx.addIssue({ code: "custom", message: "stdin exceeds maxStdinBytes" });
-});
-var NativeCommandResultSchema = z.object({
-  exitCode: z.number().int().nullable(),
-  signal: z.string().nullable(),
-  stdout: z.instanceof(Uint8Array),
-  stderr: z.instanceof(Uint8Array)
-});
-
-class NativeCommandError2 extends Error {
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.code = code;
-    this.name = "NativeCommandError";
-  }
-}
-
-// src/process/command-owner.ts
-import { spawn } from "node:child_process";
-
-// src/process/group.ts
-function deniedOnDarwin(error) {
-  return process.platform === "darwin" && error instanceof Error && "code" in error && error.code === "EPERM";
-}
-function signalGroup(pid, signal) {
-  if (pid === undefined)
-    return;
-  try {
-    process.kill(-pid, signal);
-  } catch (error) {
-    if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
-      throw error;
-  }
-}
-function exists(pid) {
-  if (pid === undefined)
-    return false;
-  try {
-    process.kill(-pid, 0);
-    return true;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ESRCH")
-      return false;
-    if (deniedOnDarwin(error))
-      return true;
-    throw error;
-  }
-}
-async function signalUntilSettled(pid, signal, deadline) {
-  for (;; ) {
-    try {
-      signalGroup(pid, signal);
-      return;
-    } catch (error) {
-      if (!deniedOnDarwin(error) || Date.now() >= deadline)
-        throw error;
-      await new Promise((resolve) => setTimeout(resolve, Math.min(10, deadline - Date.now())));
-    }
-  }
-}
-async function stopCommandGroup(pid, graceMs, cleanupTimeoutMs = 2000) {
-  const deadline = Date.now() + graceMs + cleanupTimeoutMs;
-  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())));
-  await signalUntilSettled(pid, "SIGKILL", deadline);
-}
-function commandCleanupError(cause) {
-  return new NativeCommandError2("COMMAND_CLEANUP", "Command cleanup did not complete", {
-    cause
-  });
-}
-function waitForCommandClose(closed, timeoutMs) {
-  return raceAbort(closed, AbortSignal.timeout(timeoutMs));
-}
-
-// src/process/leader-settlement.ts
-function createLeaderSettlement(options, signal) {
-  let pending;
-  return (event) => {
-    if (pending)
-      return pending;
-    pending = (async () => {
-      if (!options.onLeaderSettled)
-        return;
-      const controller = new AbortController;
-      const timer = setTimeout(() => controller.abort(new Error("Leader settlement deadline exceeded")), options.cleanupTimeoutMs);
-      const abort = () => controller.abort(signal.reason);
-      if (!signal.aborted)
-        signal.addEventListener("abort", abort, { once: true });
-      try {
-        await raceAbort(Promise.resolve(options.onLeaderSettled(event, controller.signal)), controller.signal);
-      } catch (cause) {
-        if (signal.aborted && cause === signal.reason)
-          throw cause;
-        throw commandCleanupError(new AggregateError([event, cause], "Leader settlement failed"));
-      } finally {
-        clearTimeout(timer);
-        signal.removeEventListener("abort", abort);
-        controller.abort(new Error("Leader settlement completed"));
-      }
-    })();
-    pending.catch(() => {
-      return;
-    });
-    return pending;
-  };
-}
-
-// src/process/command-owner.ts
-function startNativeCommand(input, onSpawn) {
-  const options = NativeCommandOptionsSchema.parse(input);
-  options.signal?.throwIfAborted();
-  if (process.platform === "win32")
-    throw new NativeCommandError2("COMMAND_UNAVAILABLE", "POSIX process groups are required");
-  const controller = new AbortController;
-  const abort = () => controller.abort(options.signal?.reason);
-  options.signal?.addEventListener("abort", abort, { once: true });
-  if (options.signal?.aborted)
-    abort();
-  const timer = options.timeoutMs === undefined ? undefined : setTimeout(() => controller.abort(new NativeCommandError2("COMMAND_LIMIT", "Command deadline exceeded")), options.timeoutMs);
-  let child;
-  try {
-    child = spawn(options.executable, options.args, {
-      cwd: options.cwd,
-      env: options.envPolicy === "ambient" ? { ...process.env, ...options.env } : options.env ?? {},
-      detached: true,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch (cause) {
-    if (timer !== undefined)
-      clearTimeout(timer);
-    options.signal?.removeEventListener("abort", abort);
-    throw new NativeCommandError2("COMMAND_UNAVAILABLE", "Command could not start", { cause });
-  }
-  const stdout = [];
-  const stderr = [];
-  let total = 0;
-  let finished = false;
-  let spawnFailure;
-  const settle = createLeaderSettlement(options, controller.signal);
-  const leader = new Promise((resolve) => {
-    child.once("exit", (exitCode, signal) => resolve({ kind: "exit", exitCode, signal }));
-    child.once("error", (cause) => resolve({ kind: "error", cause }));
-  });
-  const pendingHandles = new Set(["leader", "stdin", "stdout", "stderr"]);
-  const released = Promise.all([
-    leader.then(() => pendingHandles.delete("leader")),
-    ...["stdin", "stdout", "stderr"].map((name) => new Promise((resolve) => child[name].once("close", () => {
-      pendingHandles.delete(name);
-      resolve();
-    })))
-  ]);
-  const closed = new Promise((resolve) => {
-    child.once("error", (error) => {
-      spawnFailure = new NativeCommandError2("COMMAND_UNAVAILABLE", "Command could not start", {
-        cause: error
-      });
-      controller.abort(spawnFailure);
-    });
-    child.once("close", (exitCode, signal) => resolve({ exitCode, signal }));
-  });
-  child.stdin.on("error", (error) => {
-    if (!(("code" in error) && error.code === "EPIPE"))
-      controller.abort(error);
-  });
-  const drain = async (stream, channel, captured) => {
-    for await (const chunk of stream) {
-      controller.signal.throwIfAborted();
-      if (!(chunk instanceof Uint8Array))
-        throw new TypeError("Expected binary command output");
-      total += chunk.byteLength;
-      if (options.maxOutputBytes !== undefined && total > options.maxOutputBytes)
-        throw new NativeCommandError2("COMMAND_LIMIT", "Command output budget exceeded");
-      if (options.capture)
-        captured.push(Uint8Array.from(chunk));
-      if (options.onOutput)
-        await raceAbort(Promise.resolve().then(() => {
-          controller.signal.throwIfAborted();
-          return options.onOutput?.(chunk, channel, controller.signal);
-        }), controller.signal);
-    }
-  };
-  const result = (async () => {
-    try {
-      onSpawn?.(child);
-      child.stdin.end(options.stdin);
-      const drains = Promise.all([
-        drain(child.stdout, "stdout", stdout),
-        drain(child.stderr, "stderr", stderr)
-      ]);
-      await raceAbort(Promise.all([drains, leader.then(settle)]), controller.signal);
-      const status = await raceAbort(closed, controller.signal);
-      if (spawnFailure !== undefined)
-        throw spawnFailure;
-      return { ...status, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) };
-    } catch (error) {
-      controller.abort(error);
-      child.stdin.destroy();
-      child.stdout.destroy();
-      child.stderr.destroy();
-      const cleanup = await Promise.allSettled([
-        settle({ kind: "error", cause: error }),
-        stopCommandGroup(child.pid, options.killGraceMs, options.cleanupTimeoutMs).then(async () => {
-          try {
-            await waitForCommandClose(released, options.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"));
-      }
-      throw error;
-    } finally {
-      finished = true;
-      if (timer !== undefined)
-        clearTimeout(timer);
-      options.signal?.removeEventListener("abort", abort);
-      controller.abort(new Error("Command completed"));
-    }
-  })();
-  result.catch(() => {
-    return;
-  });
-  return {
-    result,
-    async stop() {
-      if (!finished)
-        controller.abort(new DOMException("Command stopped", "AbortError"));
-      await result.then(() => {
-        return;
-      }, () => {
-        return;
-      });
-    }
-  };
-}
-
-export { NativeCommandError2, startNativeCommand };

package/dist/index-c1jmtxa0.js

@@ -1,74 +0,0 @@
-// src/internal/json-data.ts
-function isJsonData(value, limits) {
-  const ancestors = new Set;
-  let nodes = 0;
-  let bytes = 0;
-  const charge = (amount) => {
-    bytes += amount;
-    return bytes <= limits.maxBytes;
-  };
-  const textSize = (text) => {
-    if (text.length > limits.maxBytes)
-      return limits.maxBytes + 1;
-    return new TextEncoder().encode(JSON.stringify(text)).byteLength;
-  };
-  const visit = (item, depth) => {
-    if (++nodes > limits.maxNodes || depth > limits.maxDepth)
-      return false;
-    if (item === null)
-      return charge(4);
-    if (typeof item === "string")
-      return charge(textSize(item));
-    if (typeof item === "boolean")
-      return charge(item ? 4 : 5);
-    if (typeof item === "number")
-      return Number.isFinite(item) && !Object.is(item, -0) && charge(String(item).length);
-    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;
-    if (array && item.length > limits.maxNodes - nodes)
-      return false;
-    const keys = Reflect.ownKeys(item);
-    if (keys.length > limits.maxNodes - nodes + (array ? 1 : 0))
-      return false;
-    if (array && keys.length !== item.length + 1)
-      return false;
-    ancestors.add(item);
-    try {
-      if (!charge(2))
-        return false;
-      let members = 0;
-      for (const key of keys) {
-        if (array && key === "length")
-          continue;
-        if (typeof key !== "string")
-          return false;
-        if (array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= item.length))
-          return false;
-        const descriptor = Object.getOwnPropertyDescriptor(item, key);
-        if (!descriptor?.enumerable || !("value" in descriptor))
-          return false;
-        if (!array && limits.omitObjectUndefined && descriptor.value === undefined) {
-          if (++nodes > limits.maxNodes)
-            return false;
-          continue;
-        }
-        if (members++ > 0 && !charge(1))
-          return false;
-        if (!array && !charge(textSize(key) + 1))
-          return false;
-        if (!visit(descriptor.value, depth + 1))
-          return false;
-      }
-      return true;
-    } finally {
-      ancestors.delete(item);
-    }
-  };
-  return visit(value, 0);
-}
-
-export { isJsonData };

package/dist/index-ga597cvy.js

@@ -1,184 +0,0 @@
-import {
-  machineIdentity,
-  ProcessInstanceSchema2,
-  readProcessInstance,
-  probeProcessOwner2
-} from "./index-nybn2err.js";
-import {
-  isRecord
-} from "./index-9jfdm5tg.js";
-
-// src/internal/exclusive-lock.ts
-import { constants } from "node:fs";
-import { lstat, open, unlink } from "node:fs/promises";
-import { hostname } from "node:os";
-import { z } from "zod";
-var ExclusiveLockOwnerSchema = z.object({
-  pid: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  host: z.string().min(1),
-  acquiredAt: z.string(),
-  machine: z.string().min(1).optional().catch(undefined),
-  process: ProcessInstanceSchema2.nullable().optional().catch(null)
-});
-function isCode(error, code) {
-  return isRecord(error) && error.code === code;
-}
-function readOwner(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return;
-  }
-  const owner = ExclusiveLockOwnerSchema.safeParse(parsed);
-  return owner.success ? owner.data : undefined;
-}
-function attribute(owner, identity) {
-  if (identity !== null && owner.machine !== undefined) {
-    return owner.machine === identity ? "this-machine" : "another-machine";
-  }
-  return owner.host === hostname() ? "this-machine" : "unattributable";
-}
-async function diagnose(owner, declaredIdentity) {
-  if (!owner)
-    return { attribution: "unattributable", liveness: "not-probed", owner: null };
-  const attribution = attribute(owner, await machineIdentity(declaredIdentity));
-  if (attribution !== "this-machine")
-    return { attribution, liveness: "not-probed", owner };
-  return { attribution, ...await probeProcessOwner2(owner.pid, owner.process), owner };
-}
-async function readLockFile(path, onFailure) {
-  let handle;
-  try {
-    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    const info = await handle.stat();
-    return {
-      owner: readOwner(await handle.readFile("utf8")),
-      ino: info.ino,
-      mtimeMs: info.mtimeMs
-    };
-  } catch (cause) {
-    if (!isCode(cause, "ENOENT"))
-      onFailure?.(cause);
-    return;
-  } finally {
-    await handle?.close().catch(() => {
-      return;
-    });
-  }
-}
-async function unlinkIfSame(path, ino) {
-  try {
-    if ((await lstat(path)).ino !== ino)
-      return;
-    await unlink(path);
-  } catch (error) {
-    if (!isCode(error, "ENOENT"))
-      throw error;
-  }
-}
-async function createOwned(path, options, reclaimed) {
-  const identity = await machineIdentity(options.machineIdentity);
-  const instance = await readProcessInstance(process.pid);
-  const handle = await open(path, "wx", options.mode);
-  const owner = {
-    pid: process.pid,
-    process: instance,
-    host: hostname(),
-    acquiredAt: new Date().toISOString(),
-    ...identity !== null && { machine: identity }
-  };
-  let ino;
-  try {
-    ino = (await handle.stat()).ino;
-    await handle.chmod(options.mode);
-    await handle.writeFile(`${JSON.stringify(owner)}
-`, "utf8");
-  } catch (error) {
-    await handle.close().catch(() => {
-      return;
-    });
-    if (ino !== undefined)
-      await unlinkIfSame(path, ino).catch(() => {
-        return;
-      });
-    throw error;
-  }
-  const ownedInode = ino;
-  let released = false;
-  return {
-    path,
-    owner,
-    reclaimed,
-    async release() {
-      if (released)
-        return;
-      released = true;
-      try {
-        await handle.close();
-      } finally {
-        await unlinkIfSame(path, ownedInode);
-      }
-    }
-  };
-}
-function reclaimable(state, diagnosis, graceMs) {
-  if (state.owner)
-    return diagnosis.liveness === "gone";
-  return typeof graceMs === "number" && Date.now() - state.mtimeMs >= graceMs;
-}
-async function reclaimUnderGuard(path, options) {
-  const guardPath = `${path}.reclaim`;
-  const acquired = await attemptExclusiveLock(guardPath, {
-    ...options,
-    ownerlessGraceMs: options.ownerlessGraceMs === undefined ? 5000 : options.ownerlessGraceMs
-  });
-  if (!("held" in acquired))
-    return;
-  const guard = acquired.held;
-  try {
-    const state = await readLockFile(path);
-    if (state) {
-      const diagnosis = await diagnose(state.owner, options.machineIdentity);
-      if (!reclaimable(state, diagnosis, options.ownerlessGraceMs))
-        return "refused";
-      await unlinkIfSame(path, state.ino);
-    }
-    return await createOwned(path, options, state !== undefined).catch((error) => {
-      if (isCode(error, "EEXIST"))
-        return "refused";
-      throw error;
-    });
-  } finally {
-    await guard.release().catch(() => {
-      return;
-    });
-  }
-}
-async function attemptExclusiveLock(path, options) {
-  try {
-    return { held: await createOwned(path, options, false) };
-  } catch (error) {
-    if (!isCode(error, "EEXIST"))
-      throw error;
-    if (!options.reclaim)
-      return { error };
-    let readFailure;
-    const state = await readLockFile(path, (cause) => {
-      readFailure = cause;
-    });
-    const diagnosis = {
-      ...await diagnose(state?.owner, options.machineIdentity),
-      ...readFailure !== undefined && { cause: readFailure }
-    };
-    if (!state || !reclaimable(state, diagnosis, options.ownerlessGraceMs)) {
-      return { error, diagnosis };
-    }
-    const reclaimed = await reclaimUnderGuard(path, options);
-    if (reclaimed !== undefined && reclaimed !== "refused")
-      return { held: reclaimed };
-    return { error, diagnosis };
-  }
-}
-
-export { attemptExclusiveLock };