stitchkit 0.103.8 → 0.103.10

package/dist/{index-5vyd0fkb.js → index-ary5s7k0.js}

@@ -1,3 +1,10 @@
+import {
+  isJsonData
+} from "./index-c1jmtxa0.js";
+import {
+  raceAbort
+} from "./index-mbnnw3f2.js";
+
 // src/durability/contract.ts
 import { z } from "zod";
 var DURABILITY_STEP_EVENT_KIND2 = "durability/step";
@@ -93,44 +100,12 @@ class ParkAbortedError2 extends Error {
 
 // src/durability/json.ts
 import { z as z2 } from "zod";
-function losslessJson(value, ancestors = new Set, depth = 0) {
-  if (depth > 100)
-    return false;
-  if (value === null || typeof value === "string" || typeof value === "boolean")
-    return true;
-  if (typeof value === "number")
-    return Number.isFinite(value) && !Object.is(value, -0);
-  if (typeof value !== "object" || ancestors.has(value))
-    return false;
-  const array = Array.isArray(value);
-  const prototype = Object.getPrototypeOf(value);
-  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
-    return false;
-  ancestors.add(value);
-  try {
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    const keys = Reflect.ownKeys(descriptors);
-    if (array && keys.length !== value.length + 1)
-      return false;
-    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) >= value.length))
-        return false;
-      const descriptor = descriptors[key];
-      if (!descriptor?.enumerable || !("value" in descriptor))
-        return false;
-      if (!losslessJson(descriptor.value, ancestors, depth + 1))
-        return false;
-    }
-    return true;
-  } finally {
-    ancestors.delete(value);
-  }
-}
-var DurableJsonSchema = z2.custom((value) => losslessJson(value), "Expected lossless JSON data (finite numbers, plain objects and dense arrays; no accessors)");
+var DurableJsonSchema = z2.custom((value) => isJsonData(value, {
+  maxDepth: 100,
+  maxNodes: Number.MAX_SAFE_INTEGER,
+  maxBytes: Number.MAX_SAFE_INTEGER,
+  omitObjectUndefined: false
+}), "Expected lossless JSON data (finite numbers, plain objects and dense arrays; no accessors)");
 
 // src/durability/ledger.ts
 function stepKey(conversationId, runId, stepName) {
@@ -292,30 +267,25 @@ async function append(context, payload, name) {
     payload: { runId: context.runId, effectName: name, ...payload }
   });
 }
-async function reconcile(context, name, handlers, timeoutMs) {
+async function reconcile(context, name, handlers, timeoutMs, outerSignal) {
+  const caller = [context.signal, outerSignal].filter((signal) => signal !== undefined);
   const controller = new AbortController;
-  let timer;
-  const deadline = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      controller.abort(new Error(`reconcile did not finish within ${timeoutMs} ms`));
-      resolve("timeout");
-    }, timeoutMs);
-  });
+  const timeout = setTimeout(() => controller.abort(new Error(`reconcile did not finish within ${timeoutMs} ms`)), timeoutMs);
+  const signal = AbortSignal.any([...caller, controller.signal]);
   let found;
   try {
-    found = await Promise.race([
-      Promise.resolve().then(() => handlers.reconcile(controller.signal)),
-      deadline
-    ]);
+    found = await raceAbort(Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return handlers.reconcile(signal);
+    }), signal);
+    signal.throwIfAborted();
   } catch (cause) {
-    throw new EffectUnresolvedError2(name, "reconcile-failed", { cause });
+    if (caller.some((signal) => signal.aborted))
+      throw new StepAbortedError2(name);
+    throw new EffectUnresolvedError2(name, controller.signal.aborted ? "reconcile-timeout" : "reconcile-failed", { cause });
   } finally {
-    clearTimeout(timer);
-  }
-  if (found === "timeout") {
-    throw new EffectUnresolvedError2(name, "reconcile-timeout", {
-      cause: controller.signal.reason
-    });
+    clearTimeout(timeout);
+    controller.abort(new Error("Reconciliation completed"));
   }
   if (found === null) {
     await append(context, { phase: "uncertain" }, name);
@@ -327,8 +297,8 @@ async function reconcile(context, name, handlers, timeoutMs) {
 }
 async function executeEffect(context, name, handlers, options) {
   const timeoutMs = options?.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new TypeError(`reconcileTimeoutMs must be a positive finite number, got ${timeoutMs}`);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new TypeError(`reconcileTimeoutMs must be a positive finite number at most 2147483647, got ${timeoutMs}`);
   }
   const key = effectKey(context.conversationId, context.runId, name);
   const recorded = (await context.readLedger()).effects.get(key);
@@ -340,7 +310,7 @@ async function executeEffect(context, name, handlers, options) {
   if (options?.signal?.aborted || context.signal?.aborted)
     throw new StepAbortedError2(name);
   if (recorded)
-    return reconcile(context, name, handlers, timeoutMs);
+    return reconcile(context, name, handlers, timeoutMs, options?.signal);
   await append(context, { phase: "intent" }, name);
   let proof;
   try {
@@ -581,7 +551,16 @@ function createLocalStepDurability2(options) {
     const key = effectKey(conversationId, runId, name);
     const existing = inFlightEffects.get(key);
     if (existing) {
-      return detachedResult(existing);
+      const signals = [options.signal, runOptions?.signal].filter((signal) => signal !== undefined);
+      const result = detachedResult(existing);
+      if (signals.length === 0)
+        return result;
+      const signal = AbortSignal.any(signals);
+      return raceAbort(result, signal).catch((error) => {
+        if (signal.aborted)
+          throw new StepAbortedError2(name);
+        throw error;
+      });
     }
     const pending = executeEffect({ store, conversationId, runId, signal: options.signal, readLedger }, name, handlers, runOptions);
     inFlightEffects.set(key, pending);

package/dist/index-c1jmtxa0.js

@@ -0,0 +1,74 @@
+// 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

@@ -0,0 +1,184 @@
+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 };

package/dist/index-mbnnw3f2.js

@@ -0,0 +1,25 @@
+// src/internal/abort-race.ts
+function raceAbort(operation, signal) {
+  if (signal.aborted) {
+    operation.catch(() => {
+      return;
+    });
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    operation.then((value) => {
+      signal.removeEventListener("abort", abort);
+      resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+  });
+}
+
+export { raceAbort };

package/dist/index-nybn2err.js

@@ -0,0 +1,213 @@
+import {
+  loadDarwinBinding
+} from "./index-d4pa2bgs.js";
+import {
+  isRecord
+} from "./index-9jfdm5tg.js";
+
+// src/internal/process-instance.ts
+import { readFile as readFile2, readlink } from "node:fs/promises";
+import { platform as platform2 } from "node:os";
+import { z } from "zod";
+
+// src/internal/process-identity.ts
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { platform } from "node:os";
+import { promisify } from "node:util";
+var detectedIdentity;
+async function firstReadableLine(paths) {
+  for (const path of paths) {
+    try {
+      const text = (await readFile(path, "utf8")).trim();
+      if (text.length > 0)
+        return text;
+    } catch {}
+  }
+  return null;
+}
+var run = promisify(execFile);
+function parsePlatformUuid(dump) {
+  return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(dump)?.[1] ?? null;
+}
+async function readDarwinPlatformUuid(command = "ioreg") {
+  try {
+    const { stdout } = await run(command, ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      timeout: 2000,
+      maxBuffer: 1 << 20,
+      encoding: "utf8"
+    });
+    return parsePlatformUuid(stdout);
+  } catch {
+    return null;
+  }
+}
+async function machineIdentity(declared) {
+  if (declared !== undefined)
+    return declared;
+  if (detectedIdentity !== undefined)
+    return detectedIdentity;
+  detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
+  return detectedIdentity;
+}
+async function probeLiveness(pid, reach = (target) => process.kill(target, 0)) {
+  try {
+    reach(pid);
+  } catch (error) {
+    return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
+  }
+  return await isZombieProcess(pid) ? "gone" : "alive";
+}
+async function isZombieProcess(pid, seam = {}) {
+  const { procRoot = "/proc", psCommand = "ps" } = seam;
+  try {
+    const stat = await readFile(`${procRoot}/${pid}/stat`, "utf8");
+    return stat.slice(stat.lastIndexOf(")") + 1).trimStart().startsWith("Z");
+  } catch {}
+  try {
+    const { stdout } = await run(psCommand, ["-o", "state=", "-p", String(pid)], {
+      timeout: 2000,
+      maxBuffer: 1 << 16,
+      encoding: "utf8"
+    });
+    return stdout.trim().startsWith("Z");
+  } catch {
+    return false;
+  }
+}
+
+// src/internal/process-instance.ts
+var ProcessInstanceSchema2 = z.object({
+  platform: z.enum(["linux", "darwin"]),
+  bootId: z.string().min(1),
+  namespace: z.string().min(1),
+  startId: z.string().regex(/^\d+$/)
+}).strict();
+var ProcessInstanceObservationSchema = z.discriminatedUnion("state", [
+  z.object({ state: z.literal("observed"), instance: ProcessInstanceSchema2 }),
+  z.object({ state: z.literal("unavailable"), cause: z.unknown() })
+]);
+async function observeProcessInstance2(pid) {
+  z.number().int().positive().max(2147483647).parse(pid);
+  return observeProcessInstanceAt(pid, "/proc");
+}
+function linuxProcessStart(stat, pid) {
+  if (!stat.startsWith(`${pid} (`))
+    return null;
+  const end = stat.lastIndexOf(")");
+  if (end < 0)
+    return null;
+  const start = stat.slice(end + 1).trim().split(/\s+/)[19];
+  return start !== undefined && /^\d+$/.test(start) ? start : null;
+}
+async function readProcessInstance(pid, procRoot = "/proc") {
+  const result = await observeProcessInstanceAt(pid, procRoot);
+  return result.state === "observed" ? result.instance : null;
+}
+async function observeProcessInstanceAt(pid, procRoot) {
+  try {
+    if (platform2() === "darwin") {
+      return {
+        state: "observed",
+        instance: ProcessInstanceSchema2.parse(loadDarwinBinding().processIdentity(pid))
+      };
+    }
+    if (platform2() !== "linux")
+      throw new Error("Process lifetime observation requires Linux or Darwin");
+    const [bootId, namespace, ownStatus, timeNamespace, ownStat, stat] = await Promise.all([
+      readFile2(`${procRoot}/sys/kernel/random/boot_id`, "utf8"),
+      readlink(`${procRoot}/self/ns/pid`),
+      readFile2(`${procRoot}/self/status`, "utf8"),
+      readlink(`${procRoot}/self/ns/time`).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+          return "";
+        throw error;
+      }),
+      readFile2(`${procRoot}/self/stat`, "utf8"),
+      readFile2(`${procRoot}/${pid}/stat`, "utf8")
+    ]);
+    const namespacePids = ownStatus.match(/^NStgid:[ \t]*(.*)$/m)?.[1]?.trim().split(/\s+/);
+    if (namespacePids?.length !== 1 || namespacePids[0] !== String(process.pid) || linuxProcessStart(ownStat, process.pid) === null)
+      throw new Error("Process namespace evidence is partial or belongs to a foreign proc mount");
+    const startId = linuxProcessStart(stat, pid);
+    if (startId === null || !bootId.trim())
+      throw new Error("Process boot/start evidence is incomplete");
+    return {
+      state: "observed",
+      instance: {
+        platform: "linux",
+        bootId: bootId.trim(),
+        namespace: `${namespace};${timeNamespace}`,
+        startId
+      }
+    };
+  } catch (cause) {
+    return { state: "unavailable", cause };
+  }
+}
+var ProcessOwnerEvidenceSchema = z.object({
+  liveness: z.enum(["alive", "gone", "not-probed"]),
+  identity: z.enum([
+    "matched",
+    "different-boot",
+    "reused-pid",
+    "pid-gone",
+    "legacy",
+    "unavailable"
+  ]),
+  cause: z.unknown().optional()
+});
+async function probeProcessOwner2(pid, recorded) {
+  z.number().int().positive().max(2147483647).parse(pid);
+  if (recorded != null)
+    ProcessInstanceSchema2.parse(recorded);
+  return probeProcessOwnerWith(pid, recorded, {
+    read: readProcessInstance,
+    observe: observeProcessInstance2,
+    liveness: probeLiveness
+  });
+}
+async function probeProcessOwnerWith(pid, recorded, probes = { read: readProcessInstance, liveness: probeLiveness }) {
+  if (recorded === undefined)
+    return { liveness: await probes.liveness(pid), identity: "legacy" };
+  const unavailable = (cause) => ({
+    liveness: "not-probed",
+    identity: "unavailable",
+    cause
+  });
+  if (recorded === null)
+    return unavailable(new Error("Recorded process lifetime is unavailable"));
+  const observe = async (target) => {
+    if (probes.observe)
+      return probes.observe(target);
+    const instance = await probes.read(target);
+    return instance ? { state: "observed", instance } : {
+      state: "unavailable",
+      cause: new Error("Process lifetime reader returned no evidence")
+    };
+  };
+  const own = await observe(process.pid);
+  if (own.state === "unavailable")
+    return unavailable(own.cause);
+  const current = own.instance;
+  if (recorded.platform !== current.platform)
+    return unavailable(new Error("Process platforms differ"));
+  if (recorded.bootId !== current.bootId)
+    return { liveness: "gone", identity: "different-boot" };
+  if (recorded.namespace !== current.namespace)
+    return unavailable(new Error("Process namespaces differ"));
+  const liveness = await probes.liveness(pid);
+  if (liveness === "gone")
+    return { liveness, identity: "pid-gone" };
+  const observation = await observe(pid);
+  if (observation.state === "unavailable")
+    return unavailable(observation.cause);
+  const observed = observation.instance;
+  if (!observed || observed.bootId !== current.bootId || observed.namespace !== current.namespace)
+    return unavailable(new Error("Observed boot or namespace changed during probe"));
+  if (recorded.startId !== observed.startId)
+    return { liveness: "gone", identity: "reused-pid" };
+  return { liveness: "alive", identity: "matched" };
+}
+
+export { machineIdentity, ProcessInstanceSchema2, observeProcessInstance2, readProcessInstance, probeProcessOwner2 };