stitchkit 0.100.2 → 0.100.3

package/dist/{index-k30h66yd.js → index-ck71tbcf.js}

@@ -1,17 +1,17 @@
 import {
   resolveRouteParamsSchema
-} from "./index-4gcnakhx.js";
+} from "./index-m38ej7e5.js";
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/contract/tool-view.ts
 import { z } from "zod";
 var DECLARED_TOOL_VIEW = Symbol.for("stitchkit.toolView");
-function withToolView(endpoint, view) {
+function withToolView2(endpoint, view) {
   const declared = { ...view, [DECLARED_TOOL_VIEW]: true };
   return { ...endpoint, tool: { ...endpoint.tool, view: declared } };
 }
@@ -254,9 +254,9 @@ function assertResponseMetaEndpoint(prefix, key, ep) {
 }
 
 // src/contract/define.ts
-var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
-var TOOL_TRANSPORTS = ["MCP", "AGENT", "CLI"];
-function defineContract(meta, endpoints) {
+var ALL_TRANSPORTS2 = ["HTTP", "MCP", "AGENT", "CLI"];
+var TOOL_TRANSPORTS2 = ["MCP", "AGENT", "CLI"];
+function defineContract2(meta, endpoints) {
   const materializedEndpoints = {};
   for (const [key, endpoint] of Object.entries(endpoints)) {
     const params = resolveRouteParamsSchema(endpoint.path, endpoint.params);
@@ -293,7 +293,7 @@ function defineContract(meta, endpoints) {
     }
     const transports = new Set(ep.expose ? ep.expose.filter((t) => t !== "HTTP") : ["MCP", "AGENT"]);
     if (transports.size === 0) {
-      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" sets tool options but is not exposed on any tool transport (${TOOL_TRANSPORTS.join(" / ")}) — a contract factory with toolExposure 'explicit' makes an omitted expose HTTP-only`);
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" sets tool options but is not exposed on any tool transport (${TOOL_TRANSPORTS2.join(" / ")}) — a contract factory with toolExposure 'explicit' makes an omitted expose HTTP-only`);
     }
     if (tool.view !== undefined)
       assertToolView(meta.prefix, key, ep);
@@ -314,4 +314,4 @@ function defineContract(meta, endpoints) {
   return { meta, endpoints: materializedEndpoints };
 }
 
-export { withToolView, ALL_TRANSPORTS, TOOL_TRANSPORTS, defineContract };
+export { withToolView2, ALL_TRANSPORTS2, TOOL_TRANSPORTS2, defineContract2 };

package/dist/{index-eqqvgdb3.js → index-ct75c3at.js}

@@ -22,8 +22,8 @@ function jsonSchemaFields(jsonSchema) {
         continue;
       for (const field of jsonSchemaFields(member)) {
         const existing = byName.get(field.name);
-        const required2 = existing ? conjunctive ? existing.required || field.required : existing.required && field.required : field.required;
-        byName.set(field.name, existing ? { ...field, required: required2 } : field);
+        const required = existing ? conjunctive ? existing.required || field.required : existing.required && field.required : field.required;
+        byName.set(field.name, existing ? { ...field, required } : field);
       }
     }
     return [...byName.values()];

package/dist/{index-gw8bmyaj.js → index-djjhhgjk.js}

@@ -1,38 +1,38 @@
+import {
+  forbidden2,
+  conflict2
+} from "./index-n53mswt3.js";
+import {
+  probeAgentProcessSandbox2,
+  missingSandboxRestrictions2,
+  codingRefusal,
+  codingPathRefusal,
+  refuseMissingCodingPath
+} from "./index-ahvsksw5.js";
 import {
   NumericFileHandle,
-  assertContainedFileCurrent,
-  assertContainedParentCurrent,
-  containedEntryMetadata,
   descriptorPath,
   listContainedDirectory,
   missingContainedDirectories,
-  openContainedFile,
   openContainedParent,
+  openContainedFile,
+  assertContainedFileCurrent,
+  assertContainedParentCurrent,
+  containedEntryMetadata,
   openContainedParentFile,
   readContainedUtf8Handle,
   scanContainedFiles
-} from "./index-fhwqwxe0.js";
+} from "./index-ej331hah.js";
 import {
   loadDarwinBinding
-} from "./index-zjjyynm3.js";
-import {
-  codingPathRefusal,
-  codingRefusal,
-  missingSandboxRestrictions,
-  probeAgentProcessSandbox,
-  refuseMissingCodingPath
-} from "./index-qmy6zq75.js";
-import {
-  defineRuntimeTool
-} from "./index-d8m8zpd8.js";
+} from "./index-d4pa2bgs.js";
 import {
-  conflict,
-  forbidden
-} from "./index-2vtcmrj9.js";
+  defineRuntimeTool2
+} from "./index-jzczzcsb.js";
 
 // src/agent-runtime/coding-tool-contract.ts
 import { z } from "zod";
-var AgentCodingToolLimitsSchema = z.object({
+var AgentCodingToolLimitsSchema2 = z.object({
   maxPathBytes: z.int().positive(),
   maxReadBytes: z.int().positive(),
   maxWriteBytes: z.int().positive(),
@@ -47,7 +47,7 @@ var AgentCodingToolLimitsSchema = z.object({
   shellTimeoutMs: z.int().positive(),
   shellTerminationGraceMs: z.int().positive()
 }).strict();
-var AgentCodingToolAuthorizationSchema = z.discriminatedUnion("operation", [
+var AgentCodingToolAuthorizationSchema2 = z.discriminatedUnion("operation", [
   z.object({ operation: z.literal("read"), path: z.string().min(1) }).strict(),
   z.object({
     operation: z.literal("write"),
@@ -95,7 +95,7 @@ var AgentCodingToolAuthorizationSchema = z.discriminatedUnion("operation", [
     cwd: z.string().min(1)
   }).strict()
 ]);
-var AgentCodingToolPathAuthorizationSchema = z.object({ path: z.string().min(1) }).strict();
+var AgentCodingToolPathAuthorizationSchema2 = z.object({ path: z.string().min(1) }).strict();
 var CodingDeniedEntrySchema = z.object({
   path: z.string().min(1),
   kind: z.enum(["file", "directory", "symlink", "other"])
@@ -170,7 +170,7 @@ var DEFAULT_LIMITS = {
   shellTerminationGraceMs: 250
 };
 function resolveCodingToolLimits(input) {
-  return AgentCodingToolLimitsSchema.parse({ ...DEFAULT_LIMITS, ...input });
+  return AgentCodingToolLimitsSchema2.parse({ ...DEFAULT_LIMITS, ...input });
 }
 
 // src/agent-runtime/coding-tools.ts
@@ -238,14 +238,14 @@ async function existingCodingPath(root, requested, maxPathBytes) {
   return { absolute: resolved, relative: path.relative(root, resolved) || "." };
 }
 async function authorizeCodingTool(config, request) {
-  const parsed = AgentCodingToolAuthorizationSchema.parse(request);
+  const parsed = AgentCodingToolAuthorizationSchema2.parse(request);
   if (!await config.authorize(parsed))
-    forbidden("Coding tool permission denied");
+    forbidden2("Coding tool permission denied");
 }
 async function isCodingPathAuthorized(config, path2) {
   if (!config.authorizePath)
     return true;
-  const parsed = AgentCodingToolPathAuthorizationSchema.parse({ path: path2 });
+  const parsed = AgentCodingToolPathAuthorizationSchema2.parse({ path: path2 });
   return await config.authorizePath(parsed);
 }
 async function authorizeCodingPath(config, path2) {
@@ -427,7 +427,7 @@ async function digestFile(handle, size) {
   return hash.digest("hex");
 }
 function createFileCodingTools(config, limits) {
-  const read = defineRuntimeTool({
+  const read = defineRuntimeTool2({
     name: "read_file",
     description: "Read a bounded UTF-8 slice from a host-authorized workspace file.",
     identity: { serviceName: "coding", action: "read-file", method: "POST" },
@@ -491,7 +491,7 @@ function createFileCodingTools(config, limits) {
       };
     }
   });
-  const write = defineRuntimeTool({
+  const write = defineRuntimeTool2({
     name: "write_file",
     description: "Write bounded UTF-8 content to a host-authorized workspace file.",
     identity: { serviceName: "coding", action: "write-file", method: "POST" },
@@ -630,7 +630,7 @@ function compileWorkspaceGlob(pattern) {
 }
 function createListingCodingTools(config, limits) {
   const excluded = new Set(config.search?.excludeDirectories ?? DEFAULT_EXCLUDED_DIRECTORIES);
-  const list = defineRuntimeTool({
+  const list = defineRuntimeTool2({
     name: "list_directory",
     description: "List the direct entries of one workspace directory.",
     identity: { serviceName: "coding", action: "list-directory", method: "POST" },
@@ -672,7 +672,7 @@ function createListingCodingTools(config, limits) {
       };
     }
   });
-  const glob = defineRuntimeTool({
+  const glob = defineRuntimeTool2({
     name: "glob",
     description: "List workspace files matching a `**`/`*`/`?` pattern.",
     identity: { serviceName: "coding", action: "glob", method: "POST" },
@@ -894,7 +894,7 @@ async function editFile(config, limits, input) {
       const source = read.text;
       const baseSha256 = sha256(source);
       if (input.expectedSha256 !== undefined && baseSha256 !== input.expectedSha256) {
-        conflict("The file changed since it was read", {
+        conflict2("The file changed since it was read", {
           message: "The file changed since it was read",
           path: relative,
           expectedSha256: input.expectedSha256,
@@ -956,7 +956,7 @@ async function editFile(config, limits, input) {
   }
 }
 function createSearchAndPatchCodingTools(config, limits) {
-  const search = defineRuntimeTool({
+  const search = defineRuntimeTool2({
     name: "search_files",
     description: "Search bounded relative paths or UTF-8 file content under the workspace root.",
     identity: { serviceName: "coding", action: "search", method: "POST" },
@@ -965,7 +965,7 @@ function createSearchAndPatchCodingTools(config, limits) {
     transports: ["AGENT"],
     handler: ({ input }) => searchFiles(config, limits, input)
   });
-  const edit = defineRuntimeTool({
+  const edit = defineRuntimeTool2({
     name: "edit_file",
     description: "Replace an exact snippet in one workspace file.",
     identity: { serviceName: "coding", action: "edit-file", method: "POST" },
@@ -1165,7 +1165,7 @@ async function runCodingShell(input) {
 function createShellCodingTool(config, limits) {
   const executables = config.executables ?? {};
   const executableNames = Object.keys(executables).sort();
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     name: "run_command",
     description: "Run a finite host-declared executable with bounded arguments, time and output.",
     identity: { serviceName: "coding", action: "shell", method: "POST" },
@@ -1199,13 +1199,13 @@ function createShellCodingTool(config, limits) {
       let executableArgs = input.args;
       let environment = config.environment ?? {};
       if (config.sandbox) {
-        const grade = await probeAgentProcessSandbox(config.sandbox.adapter);
+        const grade = await probeAgentProcessSandbox2(config.sandbox.adapter);
         if (grade.grade === "unavailable") {
           codingRefusal("SANDBOX_UNAVAILABLE", "The configured process sandbox is unavailable", {
             details: { reason: grade.reason }
           });
         }
-        const missing = missingSandboxRestrictions(grade, config.sandbox.required);
+        const missing = missingSandboxRestrictions2(grade, config.sandbox.required);
         if (missing.length > 0) {
           codingRefusal("SANDBOX_INSUFFICIENT", "The process sandbox lacks required restrictions", {
             details: { missing, grade: grade.grade }
@@ -1223,7 +1223,7 @@ function createShellCodingTool(config, limits) {
           executableArgs = [...prepared.args];
           environment = prepared.environment ?? environment;
         } catch (error) {
-          const refreshed = await probeAgentProcessSandbox(config.sandbox.adapter, {
+          const refreshed = await probeAgentProcessSandbox2(config.sandbox.adapter, {
             refresh: true
           });
           codingRefusal("SANDBOX_UNAVAILABLE", "The process sandbox failed while preparing a command", {
@@ -1277,7 +1277,7 @@ var AGENT_CODING_TOOL_NAMES = {
   searchFiles: "search_files",
   writeFile: "write_file"
 };
-function createAgentCodingTools(config) {
+function createAgentCodingTools2(config) {
   if (!path5.isAbsolute(config.root))
     throw new Error("Coding tool root must be absolute");
   for (const executable of Object.values(config.executables ?? {})) {
@@ -1289,7 +1289,7 @@ function createAgentCodingTools(config) {
   const artifactTools = [];
   if (config.artifacts) {
     const artifacts = config.artifacts;
-    artifactTools.push(defineRuntimeTool({
+    artifactTools.push(defineRuntimeTool2({
       name: AGENT_CODING_TOOL_NAMES.readOutput,
       description: "Read a bounded byte slice from one opaque coding output artifact.",
       identity: { serviceName: "coding", action: "read-artifact", method: "POST" },
@@ -1338,7 +1338,7 @@ function createAgentCodingTools(config) {
     }));
     if (artifacts.search) {
       const search = artifacts.search;
-      artifactTools.push(defineRuntimeTool({
+      artifactTools.push(defineRuntimeTool2({
         name: AGENT_CODING_TOOL_NAMES.searchOutput,
         description: "Search a durable spilled output without loading it into context.",
         identity: { serviceName: "coding", action: "search-artifact", method: "POST" },
@@ -1386,4 +1386,4 @@ function createAgentCodingTools(config) {
   ];
 }
 
-export { AgentCodingToolLimitsSchema, AgentCodingToolAuthorizationSchema, AgentCodingToolPathAuthorizationSchema, createAgentCodingTools };
+export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, createAgentCodingTools2 };

package/dist/{index-8qt2m66q.js → index-dvwj1f43.js}

@@ -1,34 +1,34 @@
 import {
-  getRequestContext,
-  runWithRequestContext
-} from "./index-zfrhfn82.js";
+  AppError2,
+  STITCH_ERROR_STATUS2,
+  isRetryableStatus2,
+  isStitchErrorCode2
+} from "./index-n53mswt3.js";
 import {
-  coerceJsonArgs
-} from "./index-1zbbzgfh.js";
+  normalizeError2,
+  validateDeclaredOutput
+} from "./index-b2bz0kdm.js";
 import {
-  applyToolViewDefaults,
-  objectShapeKeys,
-  projectToolView
-} from "./index-0r0fbk7z.js";
+  coerceJsonArgs2
+} from "./index-9pw0a51a.js";
 import {
-  normalizeError,
-  validateDeclaredOutput
-} from "./index-znfs20ss.js";
+  applyToolViewDefaults,
+  projectToolView,
+  objectShapeKeys
+} from "./index-7z9ym7t8.js";
 import {
-  formatZodError
-} from "./index-p5r7qpdd.js";
+  runWithRequestContext2,
+  getRequestContext2
+} from "./index-r1z0rd9c.js";
 import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isRetryableStatus,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
+  formatZodError2
+} from "./index-1eeqpadm.js";
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/tools/execute-args.ts
 function parseToolCallArguments(method, callArgs, {
@@ -47,8 +47,8 @@ function parseToolCallArguments(method, callArgs, {
       inputArgs[key] = value;
   }
   if (coerceJson) {
-    paramArgs = coerceJsonArgs(paramArgs, method.paramsSchema);
-    inputArgs = coerceJsonArgs(inputArgs, method.inputSchema);
+    paramArgs = coerceJsonArgs2(paramArgs, method.paramsSchema);
+    inputArgs = coerceJsonArgs2(inputArgs, method.inputSchema);
   }
   if (toolSurface)
     inputArgs = applyToolViewDefaults(inputArgs, method.toolView?.defaults);
@@ -61,7 +61,7 @@ function parseToolCallArguments(method, callArgs, {
       return { ok: false, message: "Invalid params", thrown: err };
     }
     if (!result.success) {
-      return { ok: false, message: `Invalid params: ${formatZodError(result.error)}` };
+      return { ok: false, message: `Invalid params: ${formatZodError2(result.error)}` };
     }
     params = result.data;
   }
@@ -74,7 +74,7 @@ function parseToolCallArguments(method, callArgs, {
       return { ok: false, message: "Invalid input", thrown: err };
     }
     if (!result.success) {
-      return { ok: false, message: `Invalid input: ${formatZodError(result.error)}` };
+      return { ok: false, message: `Invalid input: ${formatZodError2(result.error)}` };
     }
     input = result.data;
   }
@@ -84,13 +84,13 @@ function parseToolCallArguments(method, callArgs, {
 // src/tools/execute-result.ts
 var normalizedToolErrors = new WeakMap;
 function toolResultFromError(err) {
-  const appErr = normalizeError(err);
+  const appErr = normalizeError2(err);
   const result = {
     ok: false,
     code: appErr.code,
     details: appErr.details ?? { message: appErr.message },
     ...appErr.hint && { hint: appErr.hint },
-    retryable: appErr.retryable ?? isRetryableStatus(appErr.status)
+    retryable: appErr.retryable ?? isRetryableStatus2(appErr.status)
   };
   normalizedToolErrors.set(result, { normalized: appErr, cause: err });
   return result;
@@ -101,15 +101,15 @@ function toolErrorFromResult(result) {
     return retained.normalized;
   const details = isRecord(result.details) ? result.details : undefined;
   const message = typeof details?.message === "string" ? details.message : result.code;
-  const status = isStitchErrorCode(result.code) ? STITCH_ERROR_STATUS[result.code] : 500;
-  return new AppError(result.code, message, status, details, result.hint, undefined, result.retryable);
+  const status = isStitchErrorCode2(result.code) ? STITCH_ERROR_STATUS2[result.code] : 500;
+  return new AppError2(result.code, message, status, details, result.hint, undefined, result.retryable);
 }
 function toolCauseFromResult(result) {
   return normalizedToolErrors.get(result)?.cause;
 }
 
 // src/tools/execute.ts
-class ToolExecutionControlError extends Error {
+class ToolExecutionControlError2 extends Error {
   reason;
   constructor(reason) {
     super(`Agent tool execution stopped: ${reason}`);
@@ -123,8 +123,8 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function isToolExecutionControlError(value) {
-  return value instanceof ToolExecutionControlError;
+function isToolExecutionControlError2(value) {
+  return value instanceof ToolExecutionControlError2;
 }
 var noProgress = async () => {
   return;
@@ -134,10 +134,10 @@ async function executeToolMethod(method, call, options = {}) {
   return inToolCallContext({ source: context.source, toolName, method }, () => runToolMethod(method, call, options));
 }
 function inToolCallContext(call, body) {
-  const parent = getRequestContext();
+  const parent = getRequestContext2();
   if (!parent)
     return body();
-  return runWithRequestContext({
+  return runWithRequestContext2({
     ...parent,
     trace: parent.trace,
     dimensions: parent.dimensions ? { ...parent.dimensions } : undefined,
@@ -205,7 +205,7 @@ async function resolveToolExtension(extension, keys, rawArgs, context) {
     return { thrown: err };
   }
   if (!parsed.success)
-    return { invalid: formatZodError(parsed.error) };
+    return { invalid: formatZodError2(parsed.error) };
   try {
     const resolved = await extension.resolve({ ...rawArgs, ...parsed.data });
     return {
@@ -279,9 +279,9 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
     return { kind: "args" };
   };
   const finishThrown = async (err) => {
-    const before2 = await runBefore();
-    if (before2?.kind === "failure")
-      return before2.result;
+    const before = await runBefore();
+    if (before?.kind === "failure")
+      return before.result;
     await observed("onToolError", () => hooks?.onToolError?.({ toolName, error: err, context: hookContext, endpoint: method }));
     return finish(toolResultFromError(err), err);
   };
@@ -294,9 +294,9 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
     if ("thrown" in resolved)
       return finishThrown(resolved.thrown);
     if ("invalid" in resolved) {
-      const before2 = await runBefore();
-      if (before2?.kind === "failure")
-        return before2.result;
+      const before = await runBefore();
+      if (before?.kind === "failure")
+        return before.result;
       return finish({
         ok: false,
         code: "VALIDATION_ERROR",
@@ -334,10 +334,10 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
       toolSurface
     }));
   } catch (err) {
-    if (isToolExecutionControlError(err))
+    if (isToolExecutionControlError2(err))
       throw err;
     return finishThrown(err);
   }
 }
 
-export { parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, ToolExecutionControlError, isToolExecutionControlError, executeToolMethod };
+export { parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, ToolExecutionControlError2, isToolExecutionControlError2, executeToolMethod };

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

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

package/dist/{index-9t3dffv2.js → index-ewbaywk5.js}

@@ -1,12 +1,12 @@
+import {
+  projectToolSurface
+} from "./index-7z9ym7t8.js";
 import {
   contractToolMountable
-} from "./index-bm5rx7n6.js";
+} from "./index-n9tyz8z3.js";
 import {
   runtimeToolMountable
-} from "./index-d8m8zpd8.js";
-import {
-  projectToolSurface
-} from "./index-0r0fbk7z.js";
+} from "./index-jzczzcsb.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/{index-7p1f0vp2.js → index-fyphpknh.js}

@@ -1,20 +1,20 @@
 import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
+  defineContract2
+} from "./index-ck71tbcf.js";
 import {
-  defineContract
-} from "./index-k30h66yd.js";
+  AppError2,
+  STITCH_ERROR_STATUS2,
+  isStitchErrorCode2
+} from "./index-n53mswt3.js";
 import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
+  bytesToBase64Url,
+  base64UrlToBytes
+} from "./index-dwfv9a85.js";
 import {
-  mapObjectTypeBoundary,
+  typedEntries,
   transportResult,
-  typedEntries
-} from "./index-hffjpmq9.js";
+  mapObjectTypeBoundary
+} from "./index-9jfdm5tg.js";
 // src/contract/errors-factory.ts
 import { z } from "zod";
 function isErrorDetailsSchema(value) {
@@ -31,7 +31,7 @@ function validateDefinition(code, definition) {
     throw new Error(`[stitchkit] Error "${code}" message must be a non-empty string`);
   }
 }
-function defineErrors(source, mapping) {
+function defineErrors2(source, mapping) {
   const definitions = mapObjectTypeBoundary(source, (code, definition) => {
     const name = String(code);
     validateDefinition(name, definition);
@@ -46,10 +46,10 @@ function defineErrors(source, mapping) {
         if ("details" in options) {
           throw new Error(`[stitchkit] Error "${name}" does not declare details`);
         }
-        return new AppError(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
+        return new AppError2(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
       }
       const details = definition.details.parse(options.details);
-      return new AppError(name, message, definition.status, details, options.hint, undefined, definition.retryable);
+      return new AppError2(name, message, definition.status, details, options.hint, undefined, definition.retryable);
     };
   });
   Object.freeze(errors);
@@ -57,13 +57,13 @@ function defineErrors(source, mapping) {
   Object.freeze(codes);
   const known = new Set(Object.keys(definitions));
   for (const [code, target] of Object.entries(mapping?.map ?? {})) {
-    if (!isStitchErrorCode(code)) {
+    if (!isStitchErrorCode2(code)) {
       throw new Error(`[stitchkit] Error vocabulary contains unknown framework code "${code}"`);
     }
     if (typeof target !== "string" || !known.has(target)) {
       throw new Error(`[stitchkit] Error vocabulary maps "${code}" to undeclared code "${String(target)}"`);
     }
-    const status = STITCH_ERROR_STATUS[code];
+    const status = STITCH_ERROR_STATUS2[code];
     if (definitions[target]?.status !== status) {
       throw new Error(`[stitchkit] Error vocabulary maps "${code}" (${status}) to "${target}", declared with status ${String(definitions[target]?.status)}`);
     }
@@ -81,14 +81,14 @@ function defineErrors(source, mapping) {
     }
   }
   if (mapping?.exhaustive === true) {
-    for (const code of Object.keys(STITCH_ERROR_STATUS)) {
+    for (const code of Object.keys(STITCH_ERROR_STATUS2)) {
       if (!Object.hasOwn(mapping.map, code)) {
         throw new Error(`[stitchkit] Exhaustive error vocabulary is missing "${code}"`);
       }
     }
   }
   const codeMap = {};
-  for (const [stitchCode, status] of typedEntries(STITCH_ERROR_STATUS)) {
+  for (const [stitchCode, status] of typedEntries(STITCH_ERROR_STATUS2)) {
     const code = mapping?.map?.[stitchCode] ?? mapping?.fallback?.[status];
     if (code === undefined)
       continue;
@@ -108,9 +108,9 @@ function defineErrors(source, mapping) {
   });
 }
 // src/contract/factory.ts
-function createContractFactory(config) {
+function createContractFactory2(config) {
   const scoped = (meta, endpoints) => {
-    const validated = defineContract({ prefix: meta.prefix }, endpoints);
+    const validated = defineContract2({ prefix: meta.prefix }, endpoints);
     return {
       endpoints: validated.endpoints,
       meta: { ...meta, prefix: meta.prefix, scope: meta.scope }
@@ -126,7 +126,7 @@ function createContractFactory(config) {
 }
 // src/contract/pagination.ts
 import { z as z2 } from "zod";
-function paginatedSchema(itemSchema) {
+function paginatedSchema2(itemSchema) {
   return z2.object({
     items: z2.array(itemSchema),
     nextCursor: z2.string().nullable()
@@ -138,10 +138,10 @@ function toBase64Url(str) {
 function fromBase64Url(value) {
   return new TextDecoder().decode(base64UrlToBytes(value));
 }
-function encodeCursor(value) {
+function encodeCursor2(value) {
   return toBase64Url(JSON.stringify(value));
 }
-function decodeCursor(cursor, schema) {
+function decodeCursor2(cursor, schema) {
   if (!cursor)
     return null;
   try {
@@ -151,4 +151,4 @@ function decodeCursor(cursor, schema) {
     return null;
   }
 }
-export { defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor };
+export { defineErrors2, createContractFactory2, paginatedSchema2, encodeCursor2, decodeCursor2 };

package/dist/{index-83bdg97s.js → index-g149e9pk.js}

@@ -1,6 +1,6 @@
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/internal/error-message.ts
 function messageOf(value) {

package/dist/{index-ngfhvfpd.js → index-g6a3na27.js}

@@ -1,7 +1,7 @@
 // src/internal/backoff.ts
 import { z } from "zod";
 var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var BackoffPolicySchema = z.object({
+var BackoffPolicySchema2 = z.object({
   minDelayMs: PositiveSafeIntegerSchema,
   maxDelayMs: PositiveSafeIntegerSchema,
   jitter: z.number().min(0).max(1)
@@ -13,8 +13,8 @@ function backoffDelay(policy, attempt, random = Math.random) {
   const spread = exponential * policy.jitter * random();
   return Math.max(1, Math.round(exponential - spread));
 }
-function createBackoff(policy, random = Math.random) {
-  const parsed = BackoffPolicySchema.parse(policy);
+function createBackoff2(policy, random = Math.random) {
+  const parsed = BackoffPolicySchema2.parse(policy);
   let attempt = 0;
   return {
     next() {
@@ -27,4 +27,4 @@ function createBackoff(policy, random = Math.random) {
   };
 }
 
-export { BackoffPolicySchema, backoffDelay, createBackoff };
+export { BackoffPolicySchema2, backoffDelay, createBackoff2 };