stitchkit 0.103.12 → 0.104.0

package/dist/{index-tgzhq07n.js → index-cvda079a.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-x87j7csh.js";
+} from "./index-77nxk6ay.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool2(definition) {

package/dist/{index-n2gre124.js → index-fa4wg312.js}

@@ -1,16 +1,16 @@
 import {
   AppError2
-} from "./index-n53mswt3.js";
+} from "./index-x928baz2.js";
 import {
   toolErrorFromResult
-} from "./index-m2xqkv55.js";
+} from "./index-2vnh05w4.js";
 import {
   assertUniqueToolName
-} from "./index-x87j7csh.js";
+} from "./index-77nxk6ay.js";
 import {
   collectTools2,
   createToolRunner
-} from "./index-r956rndn.js";
+} from "./index-2hyavjjj.js";
 
 // src/tools/invoker.ts
 function createToolInvoker2(services, config) {

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

@@ -14,13 +14,13 @@ import {
 import {
   ToolExecutionControlError2,
   isToolExecutionControlError2
-} from "./index-m2xqkv55.js";
+} from "./index-2vnh05w4.js";
 import {
   agentDurableEventId2
 } from "./index-mnkk1ffz.js";
 import {
   createLocalStepDurability2
-} from "./index-69nvze1q.js";
+} from "./index-pptyv13k.js";
 import {
   isAgentToolError2,
   createToolDurabilityContext

package/dist/{index-afjvjyck.js → index-g2j7pnak.js}

@@ -1,6 +1,6 @@
 import {
   AppError2
-} from "./index-n53mswt3.js";
+} from "./index-x928baz2.js";
 import {
   contractMethodFields
 } from "./index-1bx1xv1k.js";
@@ -9,109 +9,6 @@ import {
   callRuntimeHandler
 } from "./index-9jfdm5tg.js";
 
-// src/server/middleware/cors.ts
-var DEFAULT_CORS_ALLOW_HEADERS2 = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
-var DEFAULT_CORS_EXPOSE_HEADERS2 = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id, X-Build-Id";
-function assertCorsConfig(config) {
-  if (config.credentials && (config.origin === undefined || config.origin === "*")) {
-    throw new Error("[stitchkit] cors: `credentials: true` cannot be combined with a wildcard origin. " + "Set `origin` to an explicit string or list.");
-  }
-  if (config.origin === undefined) {
-    throw new Error("[stitchkit] cors: `origin` is required. Pass an explicit origin (or list), or '*' to deliberately allow every origin — omit `cors` entirely to emit no CORS headers.");
-  }
-  if (Array.isArray(config.origin) && config.origin.length === 0) {
-    throw new Error("[stitchkit] cors: `origin` cannot be an empty list. Pass explicit origins, or '*' to deliberately allow every origin.");
-  }
-}
-function resolveOrigin(config, requestOrigin) {
-  if (config.origin === undefined)
-    return;
-  if (config.origin === "*") {
-    return "*";
-  }
-  if (Array.isArray(config.origin)) {
-    if (!requestOrigin)
-      return;
-    const lower = requestOrigin.toLowerCase();
-    return config.origin.some((o) => o.toLowerCase() === lower) ? requestOrigin : undefined;
-  }
-  return config.origin;
-}
-function isOriginAllowed(config, requestOrigin) {
-  if (!config || config.origin === undefined || config.origin === "*")
-    return false;
-  if (!requestOrigin || requestOrigin === "null")
-    return false;
-  const lower = requestOrigin.toLowerCase();
-  const allowed = Array.isArray(config.origin) ? config.origin : [config.origin];
-  return allowed.some((origin) => origin.toLowerCase() === lower);
-}
-function corsHeaders2(config, requestOrigin) {
-  const allowOrigin = resolveOrigin(config, requestOrigin);
-  const headers = {
-    "Access-Control-Allow-Methods": config.methods ?? "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS",
-    "Access-Control-Allow-Headers": config.headers ?? DEFAULT_CORS_ALLOW_HEADERS2
-  };
-  const expose = Array.isArray(config.exposeHeaders) ? config.exposeHeaders.join(", ") : config.exposeHeaders ?? DEFAULT_CORS_EXPOSE_HEADERS2;
-  if (expose !== "") {
-    headers["Access-Control-Expose-Headers"] = expose;
-  }
-  if (allowOrigin !== undefined) {
-    headers["Access-Control-Allow-Origin"] = allowOrigin;
-    if (config.credentials) {
-      headers["Access-Control-Allow-Credentials"] = "true";
-    }
-  }
-  if (Array.isArray(config.origin)) {
-    headers.Vary = "Origin";
-  }
-  return headers;
-}
-function corsPreflightResponse2(config, req) {
-  return new Response(null, {
-    status: 204,
-    headers: corsHeaders2(config, req.headers.get("origin"))
-  });
-}
-function requestCorsHeaders(cors, req) {
-  if (!cors)
-    return {};
-  return corsHeaders2(cors, req.headers.get("origin"));
-}
-function applyCors(res, cors, req) {
-  const extra = requestCorsHeaders(cors, req);
-  if (Object.keys(extra).length === 0)
-    return res;
-  try {
-    for (const [key, value] of Object.entries(extra))
-      setCorsHeader(res.headers, key, value);
-    return res;
-  } catch {
-    const headers = new Headers(res.headers);
-    for (const [key, value] of Object.entries(extra))
-      setCorsHeader(headers, key, value);
-    return new Response(res.body, {
-      status: res.status,
-      statusText: res.statusText,
-      headers
-    });
-  }
-}
-function setCorsHeader(headers, key, value) {
-  if (key !== "Vary") {
-    headers.set(key, value);
-    return;
-  }
-  const existing = headers.get("Vary");
-  if (existing === null || existing.trim() === "") {
-    headers.set("Vary", value);
-    return;
-  }
-  const present = existing.split(",").some((field) => field.trim().toLowerCase() === "origin");
-  if (!present)
-    headers.set("Vary", `${existing}, ${value}`);
-}
-
 // src/server/implement.ts
 function isStreamingImplementation(value) {
   return typeof value === "object" && value !== null && "kind" in value && value.kind === "stitchkit.multipart.stream";
@@ -229,38 +126,9 @@ function createScopedImplement2() {
   return Object.assign(implementScoped, { stream, declare });
 }
 
-// src/server/process-signal-common.ts
-var DEFAULT_PROCESS_SIGNALS = ["SIGINT", "SIGTERM"];
-var defaultSignalSource = {
-  on: (signal, handler) => {
-    process.on(signal, handler);
-  },
-  off: (signal, handler) => {
-    process.off(signal, handler);
-  },
-  raiseDefault: (signal) => {
-    if (process.listenerCount(signal) > 0)
-      return false;
-    process.kill(process.pid, signal);
-    return true;
-  }
-};
-function reportSignalError(phase, error, onError) {
-  try {
-    onError?.(phase, error);
-  } catch {}
-}
-function guardSignalCallback(run, phase, onError) {
-  try {
-    run();
-  } catch (error) {
-    reportSignalError(phase, error, onError);
-  }
-}
-
 // src/internal/media-type.ts
 function mediaTypeEssence(contentType) {
   return (contentType ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
 }
 
-export { DEFAULT_CORS_ALLOW_HEADERS2, DEFAULT_CORS_EXPOSE_HEADERS2, assertCorsConfig, isOriginAllowed, corsHeaders2, corsPreflightResponse2, requestCorsHeaders, applyCors, defineMultipartStream2, createMultipartStream2, contractOnlyService, bindContract, implement2, createImplement2, createScopedImplement2, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, mediaTypeEssence };
+export { defineMultipartStream2, createMultipartStream2, contractOnlyService, bindContract, implement2, createImplement2, createScopedImplement2, mediaTypeEssence };

package/dist/index-g95fk660.js

@@ -0,0 +1,116 @@
+import {
+  attemptExclusiveLock
+} from "./index-za6j7nwy.js";
+
+// src/internal/with-exclusive-lock.ts
+class ExclusiveLockError2 extends Error {
+  code;
+  label;
+  holder;
+  name = "ExclusiveLockError";
+  constructor(code, label, holder, message, options) {
+    super(message, options);
+    this.code = code;
+    this.label = label;
+    this.holder = holder;
+  }
+}
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_OWNERLESS_GRACE_MS = 5000;
+var FIRST_RETRY_MS = 10;
+var MAX_RETRY_MS = 100;
+function nonNegative(name, value, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new RangeError(`[stitchkit] withExclusiveLock: ${name} must be a finite number ≥ 0`);
+  }
+  return value;
+}
+function describeHolder(holder) {
+  if (!holder)
+    return "a holder that recorded no owner";
+  const machine = holder.machine === undefined ? "" : `, machine ${holder.machine}`;
+  return `pid ${holder.pid} on ${holder.host}${machine} since ${holder.acquiredAt}`;
+}
+function describeEvidence(diagnosis) {
+  if (!diagnosis)
+    return "";
+  const identity = diagnosis.identity === undefined ? "" : `, identity ${diagnosis.identity}`;
+  return ` (${diagnosis.attribution}, liveness ${diagnosis.liveness}${identity})`;
+}
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+async function withExclusiveLock2(path, run, options = {}) {
+  const label = options.label ?? path;
+  const timeoutMs = nonNegative("timeoutMs", options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const ownerlessGraceMs = options.ownerlessGraceMs === null ? null : nonNegative("ownerlessGraceMs", options.ownerlessGraceMs, DEFAULT_OWNERLESS_GRACE_MS);
+  const mode = options.mode ?? 384;
+  if (!Number.isInteger(mode) || mode < 0 || mode > 511)
+    throw new RangeError("[stitchkit] withExclusiveLock: mode must be permission bits from 0000 to 0777");
+  const { signal } = options;
+  const deadline = performance.now() + timeoutMs;
+  let delay = FIRST_RETRY_MS;
+  for (;; ) {
+    if (signal?.aborted) {
+      throw new ExclusiveLockError2("LOCK_ABORTED", label, null, `[stitchkit] waiting for the lock on "${label}" was cancelled`, { cause: signal.reason });
+    }
+    const attempt = await attemptExclusiveLock(path, {
+      mode,
+      reclaim: true,
+      signal,
+      ownerlessGraceMs,
+      ...options.machineIdentity !== undefined && {
+        machineIdentity: options.machineIdentity
+      }
+    });
+    if ("held" in attempt) {
+      const { held } = attempt;
+      let result;
+      try {
+        if (signal?.aborted) {
+          throw new ExclusiveLockError2("LOCK_ABORTED", label, null, `[stitchkit] waiting for the lock on "${label}" was cancelled`, { cause: signal.reason });
+        }
+        result = await run({
+          path: held.path,
+          owner: held.owner,
+          reclaimed: held.reclaimed,
+          async assertHeld() {
+            try {
+              await held.assertHeld();
+            } catch (cause) {
+              throw new ExclusiveLockError2("LOCK_LOST", label, held.owner, `[stitchkit] the held lock on "${label}" changed or was released`, { cause });
+            }
+          }
+        });
+      } catch (error) {
+        await held.release().catch(() => {
+          return;
+        });
+        throw error;
+      }
+      await held.release();
+      return result;
+    }
+    if (signal?.aborted)
+      continue;
+    const remaining = deadline - performance.now();
+    if (remaining <= 0) {
+      const holder = attempt.diagnosis?.owner ?? null;
+      throw new ExclusiveLockError2("LOCK_TIMEOUT", label, holder, `[stitchkit] the lock on "${label}" is held by ${describeHolder(holder)}${describeEvidence(attempt.diagnosis)}; gave up after ${timeoutMs} ms`, { cause: attempt.diagnosis?.cause ?? attempt.error });
+    }
+    await pause(Math.min(delay * (0.5 + Math.random() / 2), remaining), signal);
+    delay = Math.min(delay * 2, MAX_RETRY_MS);
+  }
+}
+
+export { ExclusiveLockError2, withExclusiveLock2 };

package/dist/{index-ej331hah.js → index-gxm9rc97.js}

@@ -1,6 +1,6 @@
 import {
   loadDarwinBinding
-} from "./index-d4pa2bgs.js";
+} from "./index-v5ee8ath.js";
 
 // src/agent-runtime/contained-scan.ts
 import path2 from "node:path";

package/dist/{index-r5c4fedv.js → index-h2fhjqy7.js}

@@ -9,7 +9,8 @@ var ContractStreamFrameSchema2 = z.discriminatedUnion("type", [
       code: z.string(),
       message: z.string().optional(),
       details: z.unknown().optional(),
-      hint: z.string().optional()
+      hint: z.string().optional(),
+      retryable: z.boolean().optional()
     }).strict()
   }).strict(),
   z.object({ type: z.literal("end") }).strict()

package/dist/{index-sybedc8b.js → index-hbd32c6a.js}

@@ -3,16 +3,20 @@ import {
   ManagedFileRefSchema2
 } from "./index-xqhede6x.js";
 import {
-  AtomicFilePublicationError2,
-  publishAtomicFile
-} from "./index-8a9ksm91.js";
+  BoundedFileReadError,
+  readBoundedFile
+} from "./index-jd470k6q.js";
 import {
   isWithinDir2
 } from "./index-5cc6r990.js";
+import {
+  AtomicFilePublicationError2,
+  publishAtomicFile
+} from "./index-8a9ksm91.js";
 
 // src/files/boundary.ts
 import { randomUUID } from "node:crypto";
-import { constants as constants2 } from "node:fs";
+import { constants } from "node:fs";
 import { mkdir, open as open2, realpath, stat, unlink } from "node:fs/promises";
 import { basename as basename2, dirname, resolve } from "node:path";
 
@@ -71,40 +75,6 @@ function inspectedRef(path, size, inspection, fallback = {}) {
   }
   return parsed.data;
 }
-async function readHandle(handle, maxBytes, signal) {
-  const chunks = [];
-  let total = 0;
-  let ended = false;
-  while (!ended) {
-    const capacity = Math.min(64 * 1024, maxBytes + 1 - total);
-    if (capacity <= 0)
-      throw new ManagedFileError2("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
-    const chunk = new Uint8Array(capacity);
-    let filled = 0;
-    while (filled < capacity) {
-      signal?.throwIfAborted();
-      const { bytesRead } = await handle.read(chunk, filled, capacity - filled);
-      if (bytesRead === 0) {
-        ended = true;
-        break;
-      }
-      filled += bytesRead;
-      total += bytesRead;
-      if (total > maxBytes)
-        throw new ManagedFileError2("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
-    }
-    if (filled > 0)
-      chunks.push(chunk.subarray(0, filled));
-  }
-  signal?.throwIfAborted();
-  const bytes = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return bytes;
-}
 async function writeChunk(handle, chunk) {
   let offset = 0;
   while (offset < chunk.byteLength) {
@@ -161,67 +131,26 @@ async function writeSource(handle, source, maxBytes, inspectionBytes, signal) {
 }
 
 // src/files/read.ts
-import { constants } from "node:fs";
 import { open } from "node:fs/promises";
 import { basename } from "node:path";
 async function readManagedDescriptor(target, path, maxBytes, options, inspection, openDescriptor = open) {
-  if (options.rejectSymlinks && !constants.O_NOFOLLOW)
-    throw new ManagedFileError2("FILE_UNSUPPORTED", "strict leaf nofollow is unavailable");
-  const flags = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0);
-  const handle = await openDescriptor(target, flags);
-  let failed = false;
-  let failure;
   let source;
   try {
-    options.signal?.throwIfAborted();
-    const before = await handle.stat();
-    if (!before.isFile())
-      throw new ManagedFileError2("FILE_NOT_REGULAR", "managed path is not a regular file");
-    if (options.singleLink && before.nlink !== 1)
-      throw new ManagedFileError2("FILE_UNSAFE_LINK", "managed file has multiple links");
-    if (before.size > maxBytes)
-      throw new ManagedFileError2("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
-    const bytes = await readHandle(handle, maxBytes, options.signal);
-    const after = options.stable || options.observe ? await handle.stat() : before;
-    if (options.stable && (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || before.nlink !== after.nlink || bytes.length !== after.size))
-      throw new ManagedFileError2("FILE_CHANGED", "managed file changed during read");
-    options.signal?.throwIfAborted();
-    const inspected = await inspectFile(inspection.inspect, {
-      prefix: bytes.slice(0, inspection.bytes),
-      name: basename(path)
-    }, inspection.timeoutMs, options.signal);
-    source = {
-      ref: inspectedRef(path, bytes.byteLength, inspected),
-      bytes,
-      ...options.observe ? {
-        observation: {
-          dev: after.dev,
-          ino: after.ino,
-          size: after.size,
-          nlink: after.nlink,
-          mtimeMs: after.mtimeMs,
-          ctimeMs: after.ctimeMs
-        }
-      } : {}
-    };
+    source = await readBoundedFile(target, maxBytes, options, openDescriptor);
   } catch (error) {
-    failed = true;
-    failure = error;
-  } finally {
-    try {
-      await handle.close();
-    } catch (error) {
-      if (!failed) {
-        failed = true;
-        failure = error;
-      }
-    }
+    if (error instanceof BoundedFileReadError)
+      throw new ManagedFileError2(error.code, error.message, { cause: error });
+    throw error;
   }
-  if (failed)
-    throw failure;
-  if (source === undefined)
-    throw new Error("Read completed without a result");
-  return source;
+  const inspected = await inspectFile(inspection.inspect, {
+    prefix: source.bytes.slice(0, inspection.bytes),
+    name: basename(path)
+  }, inspection.timeoutMs, options.signal);
+  return {
+    ref: inspectedRef(path, source.bytes.byteLength, inspected),
+    bytes: source.bytes,
+    ...options.observe && { observation: source.observation }
+  };
 }
 
 // src/files/boundary.ts
@@ -230,7 +159,7 @@ var DEFAULT_INSPECTION_BYTES = 64 * 1024;
 var DEFAULT_INSPECTION_TIMEOUT_MS = 15000;
 var nofollowFlag;
 var noFollow = () => {
-  nofollowFlag ??= constants2.O_NOFOLLOW ?? 0;
+  nofollowFlag ??= constants.O_NOFOLLOW ?? 0;
   return nofollowFlag;
 };
 
@@ -387,7 +316,7 @@ async function createManagedFileBoundary2(config) {
       let committed = false;
       let size = 0;
       try {
-        handle = await open2(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY | noFollow(), 384);
+        handle = await open2(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | noFollow(), 384);
         const written = await writeSource(handle, source, maxBytes, inspectionBytes, options.signal);
         size = written.size;
         if (options.durable)

package/dist/index-jd470k6q.js

@@ -0,0 +1,109 @@
+// src/internal/bounded-file-read.ts
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+
+class BoundedFileReadError extends Error {
+  code;
+  observation;
+  constructor(code, message, observation) {
+    super(message);
+    this.code = code;
+    this.observation = observation;
+    this.name = "BoundedFileReadError";
+  }
+}
+var observationOf = (info) => ({
+  dev: info.dev,
+  ino: info.ino,
+  size: info.size,
+  nlink: info.nlink,
+  mtimeMs: info.mtimeMs,
+  ctimeMs: info.ctimeMs
+});
+async function readBoundedFile(target, maxBytes, options = {}, openDescriptor = open) {
+  if (options.rejectSymlinks && !constants.O_NOFOLLOW)
+    throw new BoundedFileReadError("FILE_UNSUPPORTED", "strict leaf nofollow is unavailable");
+  options.signal?.throwIfAborted();
+  const flags = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0);
+  const handle = await openDescriptor(target, flags);
+  let failed = false;
+  let failure;
+  let before;
+  let source;
+  try {
+    options.signal?.throwIfAborted();
+    before = await handle.stat();
+    if (!before.isFile())
+      throw new BoundedFileReadError("FILE_NOT_REGULAR", "managed path is not a regular file");
+    if (options.singleLink && before.nlink !== 1)
+      throw new BoundedFileReadError("FILE_UNSAFE_LINK", "managed file has multiple links");
+    if (before.size > maxBytes)
+      throw new BoundedFileReadError("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
+    const bytes = await readHandle(handle, maxBytes, options.signal);
+    const after = await handle.stat();
+    if (options.stable && (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || before.nlink !== after.nlink || bytes.length !== after.size))
+      throw new BoundedFileReadError("FILE_CHANGED", "managed file changed during read");
+    options.signal?.throwIfAborted();
+    source = { bytes, observation: observationOf(after) };
+  } catch (error) {
+    failed = true;
+    failure = error;
+    if (error instanceof BoundedFileReadError && error.code === "FILE_TOO_LARGE" && before) {
+      const after = await handle.stat().catch(() => {
+        return;
+      });
+      if (after?.isFile() && after.dev === before.dev && after.ino === before.ino && after.nlink === 1)
+        failure = new BoundedFileReadError(error.code, error.message, observationOf(after));
+    }
+  } finally {
+    try {
+      await handle.close();
+    } catch (error) {
+      if (!failed) {
+        failed = true;
+        failure = error;
+      }
+    }
+  }
+  if (failed)
+    throw failure;
+  if (source === undefined)
+    throw new Error("Read completed without a result");
+  return source;
+}
+async function readHandle(handle, maxBytes, signal) {
+  const chunks = [];
+  let total = 0;
+  let ended = false;
+  while (!ended) {
+    const capacity = Math.min(64 * 1024, maxBytes + 1 - total);
+    if (capacity <= 0)
+      throw new BoundedFileReadError("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
+    const chunk = new Uint8Array(capacity);
+    let filled = 0;
+    while (filled < capacity) {
+      signal?.throwIfAborted();
+      const { bytesRead } = await handle.read(chunk, filled, capacity - filled);
+      if (bytesRead === 0) {
+        ended = true;
+        break;
+      }
+      filled += bytesRead;
+      total += bytesRead;
+      if (total > maxBytes)
+        throw new BoundedFileReadError("FILE_TOO_LARGE", `file exceeds the ${maxBytes}-byte cap`);
+    }
+    if (filled > 0)
+      chunks.push(chunk.subarray(0, filled));
+  }
+  signal?.throwIfAborted();
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+
+export { BoundedFileReadError, readBoundedFile };

package/dist/{index-b2bz0kdm.js → index-kb8styz3.js}

@@ -1,6 +1,6 @@
 import {
   AppError2
-} from "./index-n53mswt3.js";
+} from "./index-x928baz2.js";
 import {
   zodIssues2,
   formatZodError2
@@ -28,7 +28,7 @@ function recordedErrorMessage(code, envelopeMessage, thrown) {
   }
   return envelopeMessage;
 }
-function normalizeError2(err) {
+function normalizeError2(err, options = {}) {
   if (AppError2.is(err)) {
     if (err.code === "REALTIME_CONTRACT_VIOLATION") {
       return new AppError2("REALTIME_CONTRACT_VIOLATION", "Realtime contract violation", 500);
@@ -40,7 +40,8 @@ function normalizeError2(err) {
       issues: zodIssues2(err).slice(0, MAX_DETAIL_ISSUES)
     });
   }
-  console.error("[stitchkit] unhandled error:", err);
+  if (options.logUnexpected !== false)
+    console.error("[stitchkit] unhandled error:", err);
   return new AppError2("INTERNAL_SERVER_ERROR", "Internal server error", 500);
 }
 function strippedPaths(before, after, prefix) {