stitchkit 0.104.2 → 0.105.1

package/dist/{index-6d9xaxw1.js → index-8ks9b85e.js}

@@ -1,7 +1,7 @@
 import {
   AppError2,
   STITCH_ERROR_STATUS2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 
 // src/agent-runtime/sandbox.ts
 import { z } from "zod";
@@ -21,16 +21,38 @@ var AgentSandboxGradeSchema2 = z.discriminatedUnion("grade", [
   z.object({ grade: z.literal("unavailable"), reason: z.string().min(1) }).strict()
 ]);
 var probes = new WeakMap;
-function probeAgentProcessSandbox2(sandbox, options = {}) {
+var PROBE_FAILED = "sandbox probe failed";
+var PROBE_INVALID = "sandbox probe returned no valid grade";
+async function runProbe(sandbox) {
+  let value;
+  try {
+    value = await sandbox.probe();
+  } catch (cause) {
+    return { grade: { grade: "unavailable", reason: PROBE_FAILED }, cause };
+  }
+  const parsed = AgentSandboxGradeSchema2.safeParse(value);
+  if (parsed.success)
+    return { grade: parsed.data };
+  return { grade: { grade: "unavailable", reason: PROBE_INVALID }, cause: parsed.error };
+}
+function probeAgentProcessSandboxOutcome(sandbox, options = {}) {
   if (options.refresh)
     probes.delete(sandbox);
   const present = probes.get(sandbox);
   if (present)
     return present;
-  const pending = Promise.resolve(sandbox.probe()).then((grade) => AgentSandboxGradeSchema2.parse(grade));
+  const pending = runProbe(sandbox);
   probes.set(sandbox, pending);
   return pending;
 }
+async function probeAgentProcessSandbox2(sandbox, options = {}) {
+  const fresh = options.refresh === true || !probes.has(sandbox);
+  const outcome = await probeAgentProcessSandboxOutcome(sandbox, options);
+  if (fresh && outcome.cause !== undefined) {
+    process.emitWarning(new Error("Sandbox probe failed", { cause: outcome.cause }));
+  }
+  return outcome.grade;
+}
 function missingSandboxRestrictions2(grade, required) {
   if (grade.grade === "unavailable")
     return required;
@@ -54,7 +76,13 @@ async function recordAgentSandboxProbe2(input) {
 
 // src/agent-runtime/coding-tool-refusals.ts
 function codingRefusal(code, message, options = {}) {
-  throw new AppError2(code, message, STITCH_ERROR_STATUS2[code], { message, ...options.details }, options.hint);
+  throw new AppError2(code, {
+    message,
+    status: STITCH_ERROR_STATUS2[code],
+    details: { message, ...options.details },
+    hint: options.hint,
+    ..."cause" in options && { cause: options.cause }
+  });
 }
 function codingPathRefusal(code, message, path, options = {}) {
   codingRefusal(code, message, {
@@ -98,4 +126,4 @@ function refuseUnknownSpillReference(reference) {
   });
 }
 
-export { AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };
+export { AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandboxOutcome, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };

package/dist/{index-bhb950qs.js → index-916yh4e2.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-ct75c3at.js";
 import {
   AppError2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   resolvePropagationContext2
 } from "./index-yex7eg1v.js";
@@ -14,20 +14,23 @@ import {
   validateResolvedInputRounds,
   presentationMetadata,
   prepareProjectedMcpTools
-} from "./index-77nxk6ay.js";
+} from "./index-r393tnfp.js";
 import {
   parseToolCallArguments,
   toolResultFromError,
   observed
-} from "./index-2vnh05w4.js";
+} from "./index-2k91mewf.js";
 import {
   collectTools2,
   createToolRunner,
   formatToolError
-} from "./index-2hyavjjj.js";
+} from "./index-wbhdzxar.js";
 import {
   redact2
 } from "./index-e6c2spsd.js";
+import {
+  collectToolSurface
+} from "./index-pz3y6b6g.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS2,
   DEFAULT_PROCESS_SIGNALS,
@@ -35,9 +38,6 @@ import {
   reportSignalError,
   guardSignalCallback
 } from "./index-yk4g8805.js";
-import {
-  collectToolSurface
-} from "./index-a0zzh8ak.js";
 import {
   argumentsDigest
 } from "./index-r7a7r7ha.js";
@@ -374,7 +374,7 @@ async function runRoundFailure(tool, rawArgs, runTool, context, code, message) {
       ...tool.method,
       outputSchema: undefined,
       handler: () => {
-        throw new AppError2(code, message, 400);
+        throw new AppError2(code, { message, status: 400 });
       }
     }
   }, rawArgs, context);
@@ -653,15 +653,24 @@ function registerMcpTool(server, presentation, descriptor, config) {
         finalizeOutput: async (data) => {
           const presented = await present(data);
           if (!isRecord(presented)) {
-            throw new AppError2("INTERNAL_SERVER_ERROR", "Runtime MCP presenter did not return a result", 500);
+            throw new AppError2("INTERNAL_SERVER_ERROR", {
+              message: "Runtime MCP presenter did not return a result",
+              status: 500
+            });
           }
           if ("structuredContent" in presented || "isError" in presented) {
-            throw new AppError2("INTERNAL_SERVER_ERROR", "Runtime MCP presenter cannot set framework-owned structuredContent or isError", 500);
+            throw new AppError2("INTERNAL_SERVER_ERROR", {
+              message: "Runtime MCP presenter cannot set framework-owned structuredContent or isError",
+              status: 500
+            });
           }
           const structured = format({ ok: true, data }, descriptor.outputMode, name).structuredContent;
           const response = structured === undefined ? presented : { ...presented, structuredContent: structured };
           if (!isCallToolResult(response)) {
-            throw new AppError2("INTERNAL_SERVER_ERROR", "Runtime MCP presenter returned an invalid CallToolResult", 500);
+            throw new AppError2("INTERNAL_SERVER_ERROR", {
+              message: "Runtime MCP presenter returned an invalid CallToolResult",
+              status: 500
+            });
           }
           return response;
         }
@@ -700,6 +709,9 @@ function registerMcpTool(server, presentation, descriptor, config) {
 }
 
 // src/tools/mcp/runtime-tools.ts
+function isMcpPresenter(value) {
+  return typeof value === "function";
+}
 function mountPreparedRuntimeMcp(server, tools, config) {
   const runTool = createToolRunner({
     source: "mcp",
@@ -711,7 +723,8 @@ function mountPreparedRuntimeMcp(server, tools, config) {
     onOutputStrip: config.onOutputStrip
   });
   for (const { definition, descriptor } of tools) {
-    const present = definition.present?.mcp;
+    const { present: presenters } = definition;
+    const present = isRecord(presenters) && isMcpPresenter(presenters.mcp) ? presenters.mcp : undefined;
     registerMcpTool(server, {
       name: definition.name,
       description: definition.description,

package/dist/index-9tqbxv5p.js

@@ -0,0 +1,44 @@
+import {
+  MAX_TIMER_MS
+} from "./index-eemvahkc.js";
+import {
+  assertPositiveSafeInteger
+} from "./index-0s4xebbg.js";
+
+// src/internal/deadline.ts
+async function withDeadline(value, timeoutMs) {
+  if (!(value instanceof Promise))
+    return { settled: true, value };
+  let timer;
+  const expiry = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ settled: false }), timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      value.then((settledValue) => ({
+        settled: true,
+        value: settledValue
+      })),
+      expiry
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+async function withSignalDeadline(timeoutMs, caller, makeReason, body) {
+  assertPositiveSafeInteger("Deadline timeoutMs", timeoutMs, RangeError);
+  if (timeoutMs > MAX_TIMER_MS)
+    throw new RangeError("Deadline timeoutMs exceeds the timer range");
+  caller?.throwIfAborted();
+  const deadline = new AbortController;
+  const timer = setTimeout(() => deadline.abort(makeReason()), timeoutMs);
+  const signal = caller ? AbortSignal.any([caller, deadline.signal]) : deadline.signal;
+  try {
+    return await body(signal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export { withDeadline, withSignalDeadline };

package/dist/{index-5csmzesf.js → index-azx12jgv.js}

@@ -87,8 +87,9 @@ var ProcessInstanceObservationSchema = z.discriminatedUnion("state", [
   z.object({ state: z.literal("observed"), instance: ProcessInstanceSchema2 }),
   z.object({ state: z.literal("unavailable"), cause: z.unknown() })
 ]);
+var MAX_PID = 2 ** 31 - 1;
 async function observeProcessInstance2(pid) {
-  z.number().int().positive().max(2147483647).parse(pid);
+  z.number().int().positive().max(MAX_PID).parse(pid);
   return observeProcessInstanceAt(pid, "/proc");
 }
 function linuxProcessStart(stat, pid) {
@@ -158,7 +159,7 @@ var ProcessOwnerEvidenceSchema = z.object({
   cause: z.unknown().optional()
 });
 async function probeProcessOwner2(pid, recorded) {
-  z.number().int().positive().max(2147483647).parse(pid);
+  z.number().int().positive().max(MAX_PID).parse(pid);
   if (recorded != null)
     ProcessInstanceSchema2.parse(recorded);
   return probeProcessOwnerWith(pid, recorded, {
@@ -203,7 +204,7 @@ async function probeProcessOwnerWith(pid, recorded, probes = { read: readProcess
   if (observation.state === "unavailable")
     return unavailable(observation.cause);
   const observed = observation.instance;
-  if (!observed || observed.bootId !== current.bootId || observed.namespace !== current.namespace)
+  if (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" };

package/dist/{index-mbnnw3f2.js → index-b0kddvzw.js}

@@ -1,23 +1,33 @@
 // src/internal/abort-race.ts
-function raceAbort(operation, signal) {
+function raceAbort(operation, signal, disposeLate) {
+  const dispose = (value) => {
+    try {
+      disposeLate?.(value);
+    } catch {}
+  };
   if (signal.aborted) {
-    operation.catch(() => {
+    operation.then(dispose, () => {
       return;
     });
     return Promise.reject(signal.reason);
   }
   return new Promise((resolve, reject) => {
+    let released = false;
     const abort = () => {
-      signal.removeEventListener("abort", abort);
+      released = true;
       reject(signal.reason);
     };
     signal.addEventListener("abort", abort, { once: true });
     operation.then((value) => {
       signal.removeEventListener("abort", abort);
-      resolve(value);
+      if (released)
+        dispose(value);
+      else
+        resolve(value);
     }, (error) => {
       signal.removeEventListener("abort", abort);
-      reject(error);
+      if (!released)
+        reject(error);
     });
   });
 }

package/dist/{index-n5yqxd3d.js → index-b0w7rbpt.js}

@@ -46,6 +46,22 @@ var AgentControlRequestSchema2 = z.discriminatedUnion("operation", [
     metadata: z.unknown().optional()
   })
 ]);
+var AgentControlErrorCodeSchema2 = z.enum([
+  "ATTACH_CANCELLED",
+  "ATTACH_IN_PROGRESS",
+  "ATTACHMENT_CAPACITY",
+  "CONNECTION_CLOSED",
+  "CONTROL_REQUEST_FAILED",
+  "EVENT_OVERFLOW",
+  "FORBIDDEN",
+  "LEASE_CONFLICT",
+  "LEASE_REQUIRED",
+  "NOT_ATTACHED",
+  "REQUEST_CANCELLED",
+  "REQUEST_CAPACITY",
+  "REQUEST_REJECTED",
+  "RESYNC_EXHAUSTED"
+]);
 var AgentControlResponseIdentitySchema = z.object({
   schemaVersion: z.literal(1),
   requestId: z.string().min(1)
@@ -58,7 +74,7 @@ var AgentControlResponseSchema2 = z.discriminatedUnion("outcome", [
   }).strict(),
   AgentControlResponseIdentitySchema.extend({
     outcome: z.literal("error"),
-    error: z.object({ code: z.string().min(1), message: z.string().min(1) }).strict()
+    error: z.object({ code: AgentControlErrorCodeSchema2, message: z.string().min(1) }).strict()
   }).strict()
 ]);
 var AgentControlDeliverySchema2 = z.discriminatedUnion("type", [
@@ -72,6 +88,11 @@ var AgentControlDeliverySchema2 = z.discriminatedUnion("type", [
     type: z.literal("resync-required"),
     conversationId: z.string().min(1),
     reason: z.literal("overflow")
+  }).strict(),
+  z.object({
+    schemaVersion: z.literal(1),
+    type: z.literal("access-denied"),
+    conversationId: z.string().min(1)
   }).strict()
 ]);
 var AgentMultiSessionCursorSchema2 = z.object({
@@ -195,4 +216,4 @@ function reduceAgentControlEvent2(view, rawEvent) {
   };
 }
 
-export { AgentControlRequestSchema2, AgentControlResponseSchema2, AgentControlDeliverySchema2, AgentMultiSessionCursorSchema2, advanceAgentMultiSessionCursor2, createAgentControlView2, reduceAgentControlSnapshot2, reduceAgentControlEvent2 };
+export { AgentControlRequestSchema2, AgentControlErrorCodeSchema2, AgentControlResponseSchema2, AgentControlDeliverySchema2, AgentMultiSessionCursorSchema2, advanceAgentMultiSessionCursor2, createAgentControlView2, reduceAgentControlSnapshot2, reduceAgentControlEvent2 };

package/dist/index-b56nnscm.js

@@ -0,0 +1,132 @@
+// src/internal/atomic-publication.ts
+import { closeSync, fsyncSync, linkSync, openSync, renameSync, unlinkSync } from "node:fs";
+import { link, open, rename, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// src/internal/close-after.ts
+async function closeAfter(handle, run) {
+  let result;
+  try {
+    result = await run();
+  } catch (error) {
+    await handle.close().catch(() => {
+      return;
+    });
+    throw error;
+  }
+  await handle.close();
+  return result;
+}
+function closeAfterSync(close, run) {
+  let result;
+  try {
+    result = run();
+  } catch (error) {
+    try {
+      close();
+    } catch {}
+    throw error;
+  }
+  close();
+  return result;
+}
+
+// src/internal/atomic-publication.ts
+class AtomicFilePublicationError2 extends Error {
+  phase;
+  published = true;
+  constructor(phase, cause) {
+    super(`File published but ${phase} failed`, { cause });
+    this.phase = phase;
+    this.name = "AtomicFilePublicationError";
+  }
+}
+var native = { rename, link, unlink, open };
+var nativeSync = {
+  rename: renameSync,
+  link: linkSync,
+  unlink: unlinkSync,
+  open(path, flags) {
+    const descriptor = openSync(path, flags);
+    return { sync: () => fsyncSync(descriptor), close: () => closeSync(descriptor) };
+  }
+};
+function assertDirectoryDurability() {
+  if (process.platform === "win32")
+    throw new Error("Directory durability is unsupported on Windows");
+}
+async function syncDirectory(path, io = native) {
+  assertDirectoryDurability();
+  const directory = await io.open(path, "r");
+  await closeAfter(directory, () => directory.sync());
+}
+async function publishAtomicFile(staged, target, { replace, durability }, io = native) {
+  const directorySync = durability === "directory";
+  if (directorySync)
+    assertDirectoryDurability();
+  const directory = directorySync ? await io.open(dirname(target), "r") : undefined;
+  const publish = async () => {
+    if (replace)
+      await io.rename(staged, target);
+    else {
+      await io.link(staged, target);
+      try {
+        await io.unlink(staged);
+      } catch (error) {
+        throw new AtomicFilePublicationError2("cleanup", error);
+      }
+    }
+    try {
+      await directory?.sync();
+    } catch (error) {
+      throw new AtomicFilePublicationError2("directory-sync", error);
+    }
+  };
+  if (directory === undefined)
+    return publish();
+  await closeAfter({
+    close: async () => {
+      try {
+        await directory.close();
+      } catch (error) {
+        throw new AtomicFilePublicationError2("directory-close", error);
+      }
+    }
+  }, publish);
+}
+function publishAtomicFileSync(staged, target, { replace, durability }, io = nativeSync) {
+  const directorySync = durability === "directory";
+  if (directorySync)
+    assertDirectoryDurability();
+  const directory = directorySync ? io.open(dirname(target), "r") : undefined;
+  const publish = () => {
+    if (replace)
+      io.rename(staged, target);
+    else {
+      io.link(staged, target);
+      try {
+        io.unlink(staged);
+      } catch (error) {
+        throw new AtomicFilePublicationError2("cleanup", error);
+      }
+    }
+    try {
+      directory?.sync();
+    } catch (error) {
+      throw new AtomicFilePublicationError2("directory-sync", error);
+    }
+  };
+  if (directory === undefined) {
+    publish();
+    return;
+  }
+  closeAfterSync(() => {
+    try {
+      directory.close();
+    } catch (error) {
+      throw new AtomicFilePublicationError2("directory-close", error);
+    }
+  }, publish);
+}
+
+export { closeAfter, closeAfterSync, AtomicFilePublicationError2, assertDirectoryDurability, syncDirectory, publishAtomicFile, publishAtomicFileSync };

package/dist/{index-0ndk4555.js → index-c0hffcmj.js}

@@ -5,7 +5,7 @@ import {
   AgentRecoverableDescriptorSchema2,
   AgentRecoverablePageSchema2,
   canonicalAgentJson2
-} from "./index-r5hsgkz5.js";
+} from "./index-0gs4ymfj.js";
 import {
   AgentMessageSchema2,
   AgentRunSchema2
@@ -18,7 +18,7 @@ import {
   AgentHistoryMutationSchema2,
   appendEventIn,
   createAgentRuntimeStore2
-} from "./index-ssmd41kh.js";
+} from "./index-d2h99n7d.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/{index-pptyv13k.js → index-c17xcx4k.js}

@@ -1,9 +1,12 @@
 import {
   raceAbort
-} from "./index-mbnnw3f2.js";
+} from "./index-b0kddvzw.js";
 import {
   isJsonData
-} from "./index-fm1c1a08.js";
+} from "./index-m6w6jtda.js";
+import {
+  MAX_TIMER_MS
+} from "./index-eemvahkc.js";
 
 // src/durability/contract.ts
 import { z } from "zod";
@@ -296,8 +299,8 @@ async function reconcile(context, name, handlers, timeoutMs, outerSignal) {
 }
 async function executeEffect(context, name, handlers, options) {
   const timeoutMs = options?.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
-    throw new TypeError(`reconcileTimeoutMs must be a positive finite number at most 2147483647, got ${timeoutMs}`);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_MS) {
+    throw new TypeError(`reconcileTimeoutMs must be a positive finite number at most ${MAX_TIMER_MS}, got ${timeoutMs}`);
   }
   const key = effectKey(context.conversationId, context.runId, name);
   const recorded = (await context.readLedger()).effects.get(key);
@@ -326,7 +329,7 @@ async function executeEffect(context, name, handlers, options) {
 var systemClock = {
   now: () => Date.now(),
   schedule(callback, delayMs) {
-    const timer = setTimeout(callback, Math.min(delayMs, 2147483647));
+    const timer = setTimeout(callback, Math.min(delayMs, MAX_TIMER_MS));
     timer.unref();
     return { cancel: () => clearTimeout(timer) };
   }
@@ -617,4 +620,37 @@ function createLocalStepDurability2(options) {
   };
 }
 
-export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2 };
+// src/tools/agent-tool-error.ts
+var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
+
+class AgentToolError2 extends Error {
+  output;
+  constructor(output, cause) {
+    let message = "Tool execution failed";
+    try {
+      message = JSON.stringify(output);
+    } catch {}
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "AgentToolError";
+    this.output = output;
+    Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
+  }
+}
+function isAgentToolError2(value) {
+  return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
+}
+
+// src/tools/durability-context.ts
+var contexts = new WeakMap;
+function createToolDurabilityContext(factory) {
+  const context = {};
+  contexts.set(context, factory);
+  return context;
+}
+function resolveToolDurability(context, callId, signal) {
+  if (typeof context !== "object" || context === null)
+    return;
+  return contexts.get(context)?.(callId, signal);
+}
+
+export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2, AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };

package/dist/index-cazts87s.js

@@ -0,0 +1,105 @@
+import {
+  stagingPath
+} from "./index-j4zh647a.js";
+import {
+  closeAfter,
+  closeAfterSync,
+  publishAtomicFile,
+  publishAtomicFileSync
+} from "./index-b56nnscm.js";
+
+// src/internal/atomic-file.ts
+import { closeSync, fchmodSync, fsyncSync, openSync, unlinkSync, writeSync } from "node:fs";
+import { open, unlink } from "node:fs/promises";
+var DEFAULT_MODE = 384;
+function bytesOf(data) {
+  return typeof data === "string" ? new TextEncoder().encode(data) : data;
+}
+async function writeAllBytes(file, bytes) {
+  for (let offset = 0;offset < bytes.byteLength; ) {
+    const { bytesWritten } = await file.write(bytes, offset, bytes.byteLength - offset);
+    if (bytesWritten === 0)
+      throw new Error("zero-byte atomic-file write");
+    offset += bytesWritten;
+  }
+}
+async function writeFileAtomic2(target, data, options = {}) {
+  return writeAtomicFileData(target, data, options);
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function writeAtomicFileStaged(target, stage, options, io = { open, unlink, publish: publishAtomicFile }) {
+  const mode = options.mode ?? DEFAULT_MODE;
+  const staged = stagingPath(target);
+  const file = await io.open(staged, "wx", mode);
+  try {
+    const value = await closeAfter(file, async () => {
+      const filled = await stage.fill(file);
+      await file.chmod(mode);
+      if (options.durability !== "none")
+        await file.sync();
+      return filled;
+    });
+    await io.publish(staged, target, {
+      replace: options.replace ?? true,
+      durability: options.durability ?? "file"
+    });
+    return value;
+  } catch (error) {
+    await io.unlink(staged).catch((cleanup) => {
+      if (!isMissing(cleanup))
+        stage.onCleanupError?.(cleanup);
+    });
+    throw error;
+  }
+}
+async function writeAtomicFileData(target, data, options, io) {
+  await writeAtomicFileStaged(target, { fill: (file) => writeAllBytes(file, bytesOf(data)) }, options, io);
+}
+var nativeSync = {
+  open(path, flags, mode) {
+    const descriptor = openSync(path, flags, mode);
+    return {
+      write: (bytes, offset, length) => writeSync(descriptor, bytes, offset, length),
+      chmod: (bits) => fchmodSync(descriptor, bits),
+      sync: () => fsyncSync(descriptor),
+      close: () => closeSync(descriptor)
+    };
+  },
+  unlink: unlinkSync,
+  publish: publishAtomicFileSync
+};
+function writeAtomicFileDataSync(target, data, options, io = nativeSync) {
+  const mode = options.mode ?? DEFAULT_MODE;
+  const bytes = bytesOf(data);
+  const staged = stagingPath(target);
+  const file = io.open(staged, "wx", mode);
+  try {
+    closeAfterSync(() => file.close(), () => {
+      for (let offset = 0;offset < bytes.byteLength; ) {
+        const written = file.write(bytes, offset, bytes.byteLength - offset);
+        if (written === 0)
+          throw new Error("zero-byte atomic-file write");
+        offset += written;
+      }
+      file.chmod(mode);
+      if (options.durability !== "none")
+        file.sync();
+    });
+    io.publish(staged, target, {
+      replace: options.replace ?? true,
+      durability: options.durability ?? "file"
+    });
+  } catch (error) {
+    try {
+      io.unlink(staged);
+    } catch {}
+    throw error;
+  }
+}
+function writeFileAtomicSync2(target, data, options = {}) {
+  writeAtomicFileDataSync(target, data, options);
+}
+
+export { writeAllBytes, writeFileAtomic2, writeAtomicFileStaged, writeAtomicFileData, writeFileAtomicSync2 };

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

@@ -1,6 +1,6 @@
 import {
   AppError2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   contractMethodFields
 } from "./index-1bx1xv1k.js";
@@ -68,7 +68,10 @@ function contractOnlyService(contract) {
 }
 function stubHandler(label) {
   return () => {
-    throw new AppError2("NOT_IMPLEMENTED", `[stitchkit] ${label} is declared by its contract and has no handler`, 501);
+    throw new AppError2("NOT_IMPLEMENTED", {
+      message: `[stitchkit] ${label} is declared by its contract and has no handler`,
+      status: 501
+    });
   };
 }
 function bindContract(contract, handlers, options) {