stitchkit 0.104.1 → 0.105.0

package/dist/{index-f330qqyg.js → index-g2vfg7ak.js}

@@ -1,6 +1,13 @@
 import {
   raceAbort
-} from "./index-mbnnw3f2.js";
+} from "./index-b0kddvzw.js";
+import {
+  MAX_TIMER_MS,
+  sleep
+} from "./index-eemvahkc.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
 
 // src/process/contract.ts
 import { z } from "zod";
@@ -12,6 +19,14 @@ var NativeCommandSettlementSchema = z.discriminatedUnion("kind", [
   }),
   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 NativeCommandOptionsSchema = z.strictObject({
   executable: z.string().min(1),
   args: z.array(z.string()).default([]),
@@ -19,25 +34,40 @@ var NativeCommandOptionsSchema = z.strictObject({
   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(),
+  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(),
-  killGraceMs: z.number().int().nonnegative().max(1e4).default(100),
-  cleanupTimeoutMs: z.number().int().positive().max(30000).default(2000)
-}).superRefine((input, ctx) => {
+  stop: NativeCommandStopPolicySchema.default({
+    target: "group",
+    signal: "SIGTERM",
+    graceMs: 100
+  }),
+  descendants: z.enum(["terminate-after-leader", "leave"]).default("terminate-after-leader"),
+  cleanupTimeoutMs: z.number().int().positive().max(30000).default(COMMAND_CLEANUP_TIMEOUT_MS)
+}).check((ctx) => {
+  const input = ctx.value;
   if (!input.signal && input.timeoutMs === undefined)
-    ctx.addIssue({ code: "custom", message: "Declare a caller signal or a finite timeout" });
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "Declare a caller signal or a finite timeout"
+    });
   if (input.capture && input.maxOutputBytes === undefined)
-    ctx.addIssue({
+    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.addIssue({ code: "custom", message: "stdin exceeds maxStdinBytes" });
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "stdin exceeds maxStdinBytes"
+    });
 });
 var NativeCommandResultSchema = z.object({
   exitCode: z.number().int().nullable(),
@@ -62,8 +92,7 @@ class NativeCommandError2 extends Error {
 
 // src/process/group.ts
 function createCommandDeadline(timeoutMs, reason) {
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)
-    throw new RangeError("Command deadline must be a positive safe integer");
+  assertPositiveSafeInteger("Command deadline", timeoutMs, RangeError);
   const controller = new AbortController;
   const deadline = performance.now() + timeoutMs;
   let timer;
@@ -72,7 +101,7 @@ function createCommandDeadline(timeoutMs, reason) {
     if (remaining <= 0)
       controller.abort(reason);
     else
-      timer = setTimeout(schedule, Math.min(remaining, 2147483647));
+      timer = setTimeout(schedule, Math.min(remaining, MAX_TIMER_MS));
   };
   schedule();
   return {
@@ -86,14 +115,19 @@ function createCommandDeadline(timeoutMs, reason) {
 function deniedOnDarwin(error) {
   return process.platform === "darwin" && error instanceof Error && "code" in error && error.code === "EPERM";
 }
+function isErrno(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
 function signalGroup(pid, signal) {
   if (pid === undefined)
-    return;
+    return false;
   try {
     process.kill(-pid, signal);
+    return true;
   } catch (error) {
-    if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
-      throw error;
+    if (isErrno(error, "ESRCH"))
+      return false;
+    throw error;
   }
 }
 function exists(pid) {
@@ -103,7 +137,7 @@ function exists(pid) {
     process.kill(-pid, 0);
     return true;
   } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ESRCH")
+    if (isErrno(error, "ESRCH"))
       return false;
     if (deniedOnDarwin(error))
       return true;
@@ -113,8 +147,7 @@ function exists(pid) {
 async function signalUntilSettled(pid, signal, deadline) {
   for (;; ) {
     try {
-      signalGroup(pid, signal);
-      return;
+      return signalGroup(pid, signal);
     } catch (error) {
       if (!deniedOnDarwin(error) || performance.now() >= deadline)
         throw error;
@@ -122,16 +155,49 @@ async function signalUntilSettled(pid, signal, deadline) {
     }
   }
 }
-async function stopCommandGroup(pid, graceMs, cleanupTimeoutMs = 2000, force = false) {
-  const deadline = performance.now() + graceMs + cleanupTimeoutMs;
-  if (force) {
+async function stopCommandGroup(stop) {
+  const { pid, policy } = stop;
+  const deadline = performance.now() + policy.graceMs + stop.cleanupTimeoutMs;
+  if (stop.force || policy.killOn?.aborted) {
     await signalUntilSettled(pid, "SIGKILL", deadline);
     return;
   }
-  await signalUntilSettled(pid, "SIGTERM", deadline);
-  const until = performance.now() + graceMs;
-  while (performance.now() < until && exists(pid))
-    await new Promise((resolve) => setTimeout(resolve, Math.min(10, until - performance.now())));
+  if (!await signalUntilSettled(pid, policy.signal, deadline))
+    return;
+  const until = performance.now() + policy.graceMs;
+  let interval = 10;
+  let present = exists(pid);
+  while (present && !policy.killOn?.aborted && performance.now() < until) {
+    await sleep(Math.min(interval, until - performance.now()), policy.killOn).catch(() => {
+      return;
+    });
+    interval = Math.min(interval * 2, 250);
+    present = exists(pid);
+  }
+  if (present)
+    await signalUntilSettled(pid, "SIGKILL", deadline);
+}
+async function stopCommandLeader(stop) {
+  const { pid, policy, leader } = stop;
+  const deadline = performance.now() + policy.graceMs + stop.cleanupTimeoutMs;
+  const running = () => leader.exitCode === null && leader.signalCode === null;
+  if (!stop.force && !policy.killOn?.aborted && pid !== undefined && running()) {
+    try {
+      process.kill(pid, policy.signal);
+    } catch (error) {
+      if (!isErrno(error, "ESRCH"))
+        throw error;
+    }
+    const grace = new AbortController;
+    const end = () => grace.abort();
+    policy.killOn?.addEventListener("abort", end, { once: true });
+    stop.leaderExit.then(end, end);
+    await sleep(policy.graceMs, grace.signal).catch(() => {
+      return;
+    });
+    policy.killOn?.removeEventListener("abort", end);
+    grace.abort();
+  }
   await signalUntilSettled(pid, "SIGKILL", deadline);
 }
 function commandCleanupError(cause) {
@@ -146,18 +212,26 @@ function waitForCommandClose(closed, timeoutMs) {
 
 // src/process/cleanup.ts
 async function cleanupNativeCommand(input) {
+  const signalled = Promise.resolve().then(input.signal);
+  const teardown = () => input.transport?.destroy();
+  const destroyed = signalled.then(teardown, teardown);
+  const awaitRelease = 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 released = signalled.then(awaitRelease, () => {
+    return;
+  });
   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 });
-      }
-    })
+    destroyed,
+    signalled,
+    released
   ]);
   const failures = cleanup.flatMap((item) => item.status === "rejected" && item.reason !== input.error ? [item.reason] : []);
   if (failures.length)
@@ -165,6 +239,11 @@ async function cleanupNativeCommand(input) {
 }
 
 // src/process/command-lifetime.ts
+class CommandStopped extends DOMException {
+  constructor() {
+    super("Command stopped", "AbortError");
+  }
+}
 function createCommandLifetime(input) {
   const acceptSettlement = (error) => {
     if (error instanceof NativeCommandError2 && error.code === "COMMAND_CLEANUP")
@@ -198,7 +277,7 @@ function createCommandLifetime(input) {
     },
     async stop() {
       if (!input.finished())
-        input.controller.abort(new DOMException("Command stopped", "AbortError"));
+        input.controller.abort(new CommandStopped);
       await input.result.then(() => {
         return;
       }, acceptSettlement);
@@ -329,13 +408,13 @@ function createCommandTransport(child) {
 function nativeCommandBudgets(options, driver) {
   const cleanupTimeoutMs = driver?.cleanupTimeoutMs ?? options.cleanupTimeoutMs;
   const timeoutMs = driver?.timeoutMs ?? options.timeoutMs;
-  for (const [name, value] of [
+  const budgets = [
     ["cleanup", cleanupTimeoutMs],
     ["execution", timeoutMs],
     ["close", driver?.closeTimeoutMs]
-  ])
-    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0))
-      throw new RangeError(`Command ${name} deadline must be a positive safe integer`);
+  ];
+  for (const [name, value] of budgets)
+    assertPositiveSafeInteger(`Command ${name} deadline`, value, RangeError);
   return { cleanupTimeoutMs, timeoutMs };
 }
 var owners = new WeakMap;
@@ -414,7 +493,14 @@ function outputStream(source, closed, maxBufferedBytes) {
     }
   };
 }
-function launchNativeCommand(options, driver, onSpawn, onFailure, onInputFailure, onAcquired) {
+function launchNativeCommand({
+  options,
+  driver,
+  onSpawn,
+  onFailure,
+  onInputFailure,
+  onAcquired
+}) {
   let native;
   const launch = driver?.launch;
   if (!launch)
@@ -518,10 +604,45 @@ async function failedCommandStart(cause, cleanup) {
   throw error;
 }
 
+// src/process/terminate.ts
+function signalCommandChild(child, input) {
+  if (input.group && ownsCommandGroup(child)) {
+    const stop = {
+      pid: child.pid,
+      policy: input.policy,
+      cleanupTimeoutMs: input.cleanupTimeoutMs,
+      force: input.force
+    };
+    return input.policy.target === "leader" ? stopCommandLeader({ ...stop, leader: child, leaderExit: input.leaderExit }) : stopCommandGroup(stop);
+  }
+  return Promise.resolve().then(() => {
+    if (child.exitCode === null && child.signalCode === null && !child.kill("SIGKILL"))
+      throw new Error("Command leader termination was refused");
+  });
+}
+async function terminateOwnedGroup(child, closed, cleanupTimeoutMs) {
+  try {
+    await signalCommandChild(child, {
+      group: true,
+      policy: { target: "group", signal: "SIGTERM", graceMs: 0 },
+      leaderExit: closed,
+      cleanupTimeoutMs,
+      force: true
+    });
+    await waitForCommandClose(closed, cleanupTimeoutMs);
+  } catch (cause) {
+    for (const pipe of [child.stdin, child.stdout, child.stderr])
+      pipe.destroy();
+    throw commandCleanupError(cause);
+  }
+}
+
 // src/process/command-owner.ts
 function startNativeCommand(input, onSpawn, driver) {
   const options = NativeCommandOptionsSchema.parse(input);
   options.signal?.throwIfAborted();
+  const { killOn } = options.stop;
+  killOn?.throwIfAborted();
   if (process.platform === "win32" && driver?.group !== false)
     throw new NativeCommandError2("COMMAND_UNAVAILABLE", "POSIX process groups are required");
   const { cleanupTimeoutMs, timeoutMs } = nativeCommandBudgets(options, driver);
@@ -530,6 +651,12 @@ function startNativeCommand(input, onSpawn, driver) {
   options.signal?.addEventListener("abort", abort, { once: true });
   if (options.signal?.aborted)
     abort();
+  const kill = () => controller.abort(killOn?.reason);
+  killOn?.addEventListener("abort", kill, { once: true });
+  const release = () => {
+    options.signal?.removeEventListener("abort", abort);
+    killOn?.removeEventListener("abort", kill);
+  };
   const deadline = timeoutMs === undefined ? undefined : createCommandDeadline(timeoutMs, new NativeCommandError2("COMMAND_LIMIT", "Command deadline exceeded", {
     reason: "deadline"
   }));
@@ -549,13 +676,15 @@ function startNativeCommand(input, onSpawn, driver) {
     return;
   });
   const signalOwned = (force = driver?.force) => {
-    const child = acquired?.child;
-    if (!child)
+    if (!acquired)
       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);
+    return signalCommandChild(acquired.child, {
+      group: driver?.group !== false,
+      policy: options.stop,
+      leaderExit: acquired.leader,
+      cleanupTimeoutMs,
+      force: force === true
+    });
   };
   const owner = createCommandLifetime({
     result,
@@ -567,19 +696,26 @@ function startNativeCommand(input, onSpawn, driver) {
   let spawnFailure;
   let launched;
   try {
-    launched = launchNativeCommand(options, driver, onSpawn, (error) => {
-      spawnFailure = new NativeCommandError2("COMMAND_UNAVAILABLE", "Command could not start", {
-        cause: error
-      });
-      controller.abort(spawnFailure);
-    }, (error) => controller.abort(error), (transport) => {
-      acquired = transport;
-      registerNativeCommandOwner(transport.child, owner);
+    launched = launchNativeCommand({
+      options,
+      driver,
+      onSpawn,
+      onFailure: (error) => {
+        spawnFailure = new NativeCommandError2("COMMAND_UNAVAILABLE", "Command could not start", {
+          cause: error
+        });
+        controller.abort(spawnFailure);
+      },
+      onInputFailure: (error) => controller.abort(error),
+      onAcquired: (transport) => {
+        acquired = transport;
+        registerNativeCommandOwner(transport.child, owner);
+      }
     });
   } catch (cause) {
     deadline?.cancel();
     deadline?.signal.removeEventListener("abort", expired);
-    options.signal?.removeEventListener("abort", abort);
+    release();
     controller.abort(cause);
     failedCommandStart(cause, (error) => cleanupNativeCommand({
       error,
@@ -598,7 +734,8 @@ function startNativeCommand(input, onSpawn, driver) {
   const cancelCloseDeadline = createLeaderCloseDeadline(leader, driver?.closeTimeoutMs, controller);
   const drain = async (stream, channel, captured) => {
     for await (const chunk of stream) {
-      controller.signal.throwIfAborted();
+      if (controller.signal.aborted)
+        continue;
       if (!(chunk instanceof Uint8Array))
         throw new TypeError("Expected binary command output");
       total += chunk.byteLength;
@@ -609,10 +746,27 @@ function startNativeCommand(input, onSpawn, driver) {
       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);
+        try {
+          await raceAbort(Promise.resolve().then(() => {
+            controller.signal.throwIfAborted();
+            return options.onOutput?.(chunk, channel, controller.signal);
+          }), controller.signal);
+        } catch (error) {
+          if (!controller.signal.aborted || error !== controller.signal.reason)
+            throw error;
+        }
+    }
+  };
+  const settleLeader = async (event) => {
+    await settle(event);
+    if (controller.signal.aborted)
+      return;
+    if (options.descendants !== "terminate-after-leader" || event.kind !== "exit")
+      return;
+    try {
+      await signalOwned();
+    } catch (cause) {
+      throw commandCleanupError(cause);
     }
   };
   const run = (async () => {
@@ -622,7 +776,7 @@ function startNativeCommand(input, onSpawn, driver) {
         drain(output, "stdout", stdout),
         drain(errorOutput, "stderr", stderr)
       ]);
-      await raceAbort(Promise.all([drains, leader.then(settle)]), controller.signal);
+      await raceAbort(Promise.all([drains, leader.then(settleLeader)]), controller.signal);
       const status = await raceAbort(closed, controller.signal);
       if (spawnFailure !== undefined)
         throw spawnFailure;
@@ -642,7 +796,7 @@ function startNativeCommand(input, onSpawn, driver) {
       cancelCloseDeadline();
       deadline?.cancel();
       deadline?.signal.removeEventListener("abort", expired);
-      options.signal?.removeEventListener("abort", abort);
+      release();
       controller.abort(new Error("Command completed"));
     }
   })();
@@ -650,4 +804,4 @@ function startNativeCommand(input, onSpawn, driver) {
   return owner;
 }
 
-export { NativeCommandError2, stopCommandGroup, spawnOwnedCommand, ownsCommandGroup, nativeCommandOwner, startNativeCommand };
+export { COMMAND_CLEANUP_TIMEOUT_MS, NativeCommandError2, CommandStopped, spawnOwnedCommand, nativeCommandOwner, terminateOwnedGroup, startNativeCommand };

package/dist/{index-fk18k56k.js → index-gr5g3xfw.js}

@@ -14,17 +14,15 @@ import {
 import {
   ToolExecutionControlError2,
   isToolExecutionControlError2
-} from "./index-2vnh05w4.js";
+} from "./index-2k91mewf.js";
 import {
   agentDurableEventId2
 } from "./index-mnkk1ffz.js";
 import {
-  createLocalStepDurability2
-} from "./index-pptyv13k.js";
-import {
+  createLocalStepDurability2,
   isAgentToolError2,
   createToolDurabilityContext
-} from "./index-nggfa2yn.js";
+} from "./index-c17xcx4k.js";
 import {
   canonicalAgentJson2,
   createToolChronology,
@@ -33,13 +31,16 @@ import {
   isAssistantHistoryEvidence2,
   isCompleteAgentHistoryTurn,
   assistantStatus
-} from "./index-r5hsgkz5.js";
+} from "./index-0gs4ymfj.js";
 import {
   messageOf
 } from "./index-g149e9pk.js";
 import {
   createMutationQueue
 } from "./index-sykb5ag7.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
 import {
   serializeCanonicalJson
 } from "./index-zsvzhjtk.js";
@@ -2129,9 +2130,7 @@ async function recoverAgentRuns(state, options) {
   if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
     throw new TypeError("Recovery pageSize must be an integer between 1 and 1000");
   }
-  if (!Number.isSafeInteger(maxRuns) || maxRuns < 1) {
-    throw new TypeError("Recovery maxRuns must be a positive safe integer");
-  }
+  assertPositiveSafeInteger("Recovery maxRuns", maxRuns);
   const ordered = await collectRecoverable(state, options, pageSize, maxRuns);
   const outcomes = [];
   const scheduledRuns = new Map;
@@ -3914,15 +3913,9 @@ function resolveLoopLimits(config) {
   const maxSteps = config.loop?.maxSteps ?? 50;
   const declaredIdleTimeoutMs = config.loop?.idleTimeoutMs;
   const idleTimeoutMs = declaredIdleTimeoutMs === null ? undefined : declaredIdleTimeoutMs ?? 60000;
-  if (!Number.isSafeInteger(checkpointEveryEvents) || checkpointEveryEvents < 1) {
-    throw new TypeError("checkpointEveryEvents must be a positive safe integer");
-  }
-  if (!Number.isSafeInteger(maxSteps) || maxSteps < 1) {
-    throw new TypeError("maxSteps must be a positive safe integer");
-  }
-  if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
-    throw new TypeError("idleTimeoutMs must be a positive safe integer");
-  }
+  assertPositiveSafeInteger("checkpointEveryEvents", checkpointEveryEvents);
+  assertPositiveSafeInteger("maxSteps", maxSteps);
+  assertPositiveSafeInteger("idleTimeoutMs", idleTimeoutMs);
   const policyNames = new Set(["max-steps"]);
   for (const policy of config.loop?.stopPolicies ?? []) {
     if (!policy.name || policyNames.has(policy.name)) {

package/dist/{index-jn9g8xdt.js → index-hjvje0pf.js}

@@ -1,10 +1,13 @@
 import {
   AgentControlRequestSchema2,
   AgentControlResponseSchema2
-} from "./index-n5yqxd3d.js";
+} from "./index-b0w7rbpt.js";
 import {
   createAgentRuntimeEventSink2
-} from "./index-vgkbcnkc.js";
+} from "./index-299sm5tr.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
 
 // src/agent-runtime/harness-control.ts
 async function runControlledOperation(harness, request) {
@@ -64,8 +67,7 @@ function controlFailure(requestId, code, message) {
 }
 function attachmentLimit(config) {
   const limit = config.maxPendingAttachments ?? 32;
-  if (!Number.isSafeInteger(limit) || limit <= 0)
-    throw new TypeError("maxPendingAttachments must be a positive safe integer");
+  assertPositiveSafeInteger("maxPendingAttachments", limit);
   return limit;
 }
 function connectionState(config, {

package/dist/{index-x928baz2.js → index-j9gxbztg.js}

@@ -8,15 +8,15 @@ class AppError2 extends Error {
   hint;
   traceId;
   retryable;
-  constructor(code, message, status = 500, details, hint, traceId, retryable) {
-    super(message ?? code);
+  constructor(code, options = {}) {
+    super(options.message ?? code, "cause" in options ? { cause: options.cause } : undefined);
     this.code = code;
-    this.status = status;
-    this.details = details;
-    this.hint = hint;
-    this.traceId = traceId;
-    this.retryable = retryable;
     this.name = "AppError";
+    this.status = options.status ?? 500;
+    this.details = options.details;
+    this.hint = options.hint;
+    this.traceId = options.traceId;
+    this.retryable = options.retryable;
     Object.defineProperty(this, APP_ERROR_BRAND, { value: true });
   }
   static is(err) {
@@ -35,22 +35,22 @@ class AppError2 extends Error {
   }
 }
 function notFound2(message = "Not found") {
-  throw new AppError2("NOT_FOUND", message, 404);
+  throw new AppError2("NOT_FOUND", { message, status: 404 });
 }
 function badRequest2(message, details) {
-  throw new AppError2("BAD_REQUEST", message, 400, details);
+  throw new AppError2("BAD_REQUEST", { message, status: 400, details });
 }
 function unauthorized2(message = "Unauthorized") {
-  throw new AppError2("UNAUTHORIZED", message, 401);
+  throw new AppError2("UNAUTHORIZED", { message, status: 401 });
 }
 function forbidden2(message = "Forbidden") {
-  throw new AppError2("FORBIDDEN", message, 403);
+  throw new AppError2("FORBIDDEN", { message, status: 403 });
 }
 function conflict2(message = "Conflict", details) {
-  throw new AppError2("CONFLICT", message, 409, details);
+  throw new AppError2("CONFLICT", { message, status: 409, details });
 }
 function rateLimited2(message = "Too many requests") {
-  throw new AppError2("RATE_LIMITED", message, 429);
+  throw new AppError2("RATE_LIMITED", { message, status: 429 });
 }
 var STITCH_ERROR_STATUS2 = {
   BAD_REQUEST: 400,
@@ -99,7 +99,11 @@ function isStitchErrorCode2(code) {
   return Object.hasOwn(STITCH_ERROR_STATUS2, code);
 }
 function appError2(code, message, details) {
-  throw new AppError2(code, message, isStitchErrorCode2(code) ? STITCH_ERROR_STATUS2[code] : 500, details);
+  throw new AppError2(code, {
+    message,
+    status: isStitchErrorCode2(code) ? STITCH_ERROR_STATUS2[code] : 500,
+    details
+  });
 }
 
 export { AppError2, notFound2, badRequest2, unauthorized2, forbidden2, conflict2, rateLimited2, STITCH_ERROR_STATUS2, isRetryableStatus2, isStitchErrorCode2, appError2 };

package/dist/index-kfjkb396.js

@@ -0,0 +1,37 @@
+// src/browser/api-error.ts
+var API_ERROR_BRAND = Symbol.for("stitchkit.ApiError");
+function messageForCode(code, message) {
+  return message !== undefined && message.length > 0 ? message : `${code} (no message supplied)`;
+}
+
+class ApiError2 extends Error {
+  code;
+  status;
+  details;
+  hint;
+  traceId;
+  retryable;
+  constructor(code, options = {}) {
+    super(messageForCode(code, options.message), "cause" in options ? { cause: options.cause } : undefined);
+    this.code = code;
+    this.name = "ApiError";
+    this.status = options.status ?? 0;
+    this.details = options.details;
+    this.hint = options.hint;
+    this.traceId = options.traceId;
+    this.retryable = options.retryable;
+    Object.defineProperty(this, API_ERROR_BRAND, { value: true });
+  }
+  static is(error) {
+    return typeof error === "object" && error !== null && API_ERROR_BRAND in error;
+  }
+}
+function refuseLocally(path, message) {
+  return new ApiError2("VALIDATION_ERROR", {
+    status: 0,
+    details: { issues: [{ path, code: "invalid_type", message }] },
+    message
+  });
+}
+
+export { ApiError2, refuseLocally };