stitchkit 0.93.0 → 0.94.1

package/dist/google.js

@@ -1,175 +0,0 @@
-// src/google.ts
-import { OAuth2Client } from "google-auth-library";
-import { z } from "zod";
-var DEFAULT_TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
-var DEFAULT_TIMEOUT_MS = 1e4;
-var ERROR_MESSAGES = {
-  MISCONFIGURED: "Google OIDC is not configured correctly.",
-  INVALID_CREDENTIAL: "The Google credential is invalid.",
-  UPSTREAM_UNAVAILABLE: "Google identity verification is temporarily unavailable."
-};
-
-class GoogleOidcError extends Error {
-  code;
-  retryable;
-  constructor(code, options) {
-    super(ERROR_MESSAGES[code], options);
-    this.name = "GoogleOidcError";
-    this.code = code;
-    this.retryable = code === "UPSTREAM_UNAVAILABLE";
-  }
-}
-function recordOf(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : null;
-}
-function statusOf(error) {
-  const record = recordOf(error);
-  const response = recordOf(record?.response);
-  return typeof response?.status === "number" ? response.status : null;
-}
-function codeOf(error) {
-  const record = recordOf(error);
-  return typeof record?.code === "string" ? record.code : null;
-}
-function upstreamVerifierFailure(error) {
-  const status = statusOf(error);
-  if (status !== null && (status === 429 || status >= 500))
-    return true;
-  return ["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN"].includes(codeOf(error) ?? "");
-}
-function constantTimeEqual(left, right) {
-  const leftBytes = new TextEncoder().encode(left);
-  const rightBytes = new TextEncoder().encode(right);
-  if (leftBytes.length !== rightBytes.length)
-    return false;
-  let difference = 0;
-  for (let index = 0;index < leftBytes.length; index += 1) {
-    difference |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
-  }
-  return difference === 0;
-}
-function defaultTokenTransport(fetcher) {
-  return async (input) => {
-    let response;
-    try {
-      response = await fetcher(input.tokenEndpoint, {
-        method: "POST",
-        headers: { "content-type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          grant_type: "authorization_code",
-          code: input.code,
-          code_verifier: input.codeVerifier,
-          redirect_uri: input.redirectUri,
-          client_id: input.clientId,
-          client_secret: input.clientSecret
-        }),
-        signal: input.signal
-      });
-    } catch {
-      throw new GoogleOidcError("UPSTREAM_UNAVAILABLE");
-    }
-    if (!response.ok) {
-      throw new GoogleOidcError(response.status === 429 || response.status >= 500 ? "UPSTREAM_UNAVAILABLE" : "INVALID_CREDENTIAL");
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      throw new GoogleOidcError("UPSTREAM_UNAVAILABLE");
-    }
-    const idToken = recordOf(body)?.id_token;
-    if (typeof idToken !== "string" || !idToken) {
-      throw new GoogleOidcError("INVALID_CREDENTIAL");
-    }
-    return { idToken };
-  };
-}
-function defaultIdTokenVerifier(clientId, clientSecret) {
-  const client = new OAuth2Client(clientId, clientSecret);
-  return async ({ idToken, audience }) => {
-    const ticket = await client.verifyIdToken({ idToken, audience });
-    const payload = ticket.getPayload();
-    if (!payload)
-      throw new GoogleOidcError("INVALID_CREDENTIAL");
-    return {
-      sub: payload.sub,
-      email: payload.email,
-      emailVerified: payload.email_verified,
-      nonce: payload.nonce,
-      name: payload.name,
-      picture: payload.picture
-    };
-  };
-}
-function createGoogleOidcClient(config) {
-  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  if (!config.clientId || !config.clientSecret || config.allowedRedirectUris.length === 0 || config.allowedRedirectUris.some((uri) => !uri) || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new GoogleOidcError("MISCONFIGURED");
-  }
-  const allowedRedirectUris = new Set(config.allowedRedirectUris);
-  const transport = config.tokenTransport ?? defaultTokenTransport(config.fetch ?? globalThis.fetch);
-  const verify = config.idTokenVerifier ?? defaultIdTokenVerifier(config.clientId, config.clientSecret);
-  return {
-    async exchangeAuthorizationCode(input) {
-      if (!allowedRedirectUris.has(input.redirectUri)) {
-        throw new GoogleOidcError("INVALID_CREDENTIAL");
-      }
-      if (!input.code || !input.codeVerifier || !input.nonce) {
-        throw new GoogleOidcError("INVALID_CREDENTIAL");
-      }
-      const controller = new AbortController;
-      let timer;
-      const deadline = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          controller.abort();
-          reject(new GoogleOidcError("UPSTREAM_UNAVAILABLE"));
-        }, timeoutMs);
-      });
-      let exchanged;
-      try {
-        exchanged = await Promise.race([
-          transport({
-            code: input.code,
-            codeVerifier: input.codeVerifier,
-            redirectUri: input.redirectUri,
-            clientId: config.clientId,
-            clientSecret: config.clientSecret,
-            tokenEndpoint: DEFAULT_TOKEN_ENDPOINT,
-            signal: controller.signal
-          }),
-          deadline
-        ]);
-      } catch (cause) {
-        if (cause instanceof GoogleOidcError)
-          throw cause;
-        throw new GoogleOidcError("UPSTREAM_UNAVAILABLE");
-      } finally {
-        if (timer)
-          clearTimeout(timer);
-      }
-      if (!exchanged.idToken)
-        throw new GoogleOidcError("INVALID_CREDENTIAL");
-      let claims;
-      try {
-        claims = await verify({ idToken: exchanged.idToken, audience: config.clientId });
-      } catch (cause) {
-        if (cause instanceof GoogleOidcError)
-          throw cause;
-        throw new GoogleOidcError(upstreamVerifierFailure(cause) ? "UPSTREAM_UNAVAILABLE" : "INVALID_CREDENTIAL");
-      }
-      if (!claims.sub || !claims.email || claims.emailVerified !== true || !claims.nonce || !constantTimeEqual(claims.nonce, input.nonce) || !z.email().safeParse(claims.email).success) {
-        throw new GoogleOidcError("INVALID_CREDENTIAL");
-      }
-      return {
-        subject: claims.sub,
-        email: claims.email,
-        ...claims.name ? { name: claims.name } : {},
-        ...claims.picture ? { picture: claims.picture } : {}
-      };
-    }
-  };
-}
-export {
-  createGoogleOidcClient,
-  GoogleOidcError
-};

package/dist/index-0a349c33.js

@@ -1,470 +0,0 @@
-import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
-import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
-import {
-  isUnsafeKey
-} from "./index-kzfs85xp.js";
-import {
-  mapObjectTypeBoundary,
-  transportResult,
-  typedEntries
-} from "./index-77fekveh.js";
-
-// src/internal/route-pattern.ts
-import { z } from "zod";
-var PARAM_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function joinRoutePath(...parts) {
-  const joined = parts.filter((part) => Boolean(part)).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
-  return `/${joined}`;
-}
-function parseRoutePattern(path) {
-  const segments = path.split("/").filter(Boolean);
-  const parameters = [];
-  const names = new Set;
-  for (const [segmentIndex, segment] of segments.entries()) {
-    const marker = segment.at(0);
-    if (marker !== ":" && marker !== "*") {
-      if (segment.includes("*")) {
-        throw new Error(`Wildcard must occupy its own segment in path "${path}"`);
-      }
-      continue;
-    }
-    const name = segment.slice(1);
-    if (marker === "*" && name === "") {
-      throw new Error(`Trailing wildcard in path "${path}" must be named, for example "/*filePath"`);
-    }
-    if (!PARAM_IDENTIFIER.test(name) || isUnsafeKey(name)) {
-      const label = marker === "*" ? "wildcard" : "route parameter";
-      throw new Error(`Invalid ${label} name "${name}" in path "${path}"`);
-    }
-    if (names.has(name)) {
-      throw new Error(`Duplicate route parameter name "${name}" in path "${path}"`);
-    }
-    if (marker === "*" && segmentIndex !== segments.length - 1) {
-      throw new Error(`Wildcard "*${name}" must be the final segment in path "${path}"`);
-    }
-    names.add(name);
-    parameters.push({
-      name,
-      kind: marker === "*" ? "wildcard" : "segment",
-      segmentIndex
-    });
-  }
-  return parameters;
-}
-function resolveRouteParamsSchema(path, schema) {
-  const parameters = parseRoutePattern(path);
-  if (parameters.length === 0)
-    return schema;
-  if (!schema) {
-    const shape = {};
-    for (const parameter of parameters)
-      shape[parameter.name] = z.string();
-    return z.object(shape);
-  }
-  const jsonSchema = z.toJSONSchema(schema, { io: "input", unrepresentable: "any" });
-  const properties = jsonSchema.properties;
-  if (!properties) {
-    throw new Error(`Route params schema for path "${path}" must be an object schema with a property per path field`);
-  }
-  for (const parameter of parameters) {
-    if (!(parameter.name in properties)) {
-      const kind = parameter.kind === "wildcard" ? "wildcard" : "path";
-      throw new Error(`Route params schema for path "${path}" is missing ${kind} field "${parameter.name}"`);
-    }
-  }
-  const names = new Set(parameters.map((parameter) => parameter.name));
-  const required = Array.isArray(jsonSchema.required) ? jsonSchema.required : [];
-  for (const field of required) {
-    if (typeof field === "string" && !names.has(field)) {
-      throw new Error(`Route params schema for path "${path}" requires field "${field}" that the path does not carry`);
-    }
-  }
-  return schema;
-}
-function parseTrailingWildcard(path) {
-  const wildcard = parseRoutePattern(path).find((parameter) => parameter.kind === "wildcard");
-  return wildcard ? { name: wildcard.name, segmentIndex: wildcard.segmentIndex } : null;
-}
-
-// src/contract/define.ts
-var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
-function defineContract(meta, endpoints) {
-  const materializedEndpoints = {};
-  for (const [key, endpoint] of Object.entries(endpoints)) {
-    const params = resolveRouteParamsSchema(endpoint.path, endpoint.params);
-    materializedEndpoints[key] = params === endpoint.params ? endpoint : { ...endpoint, params };
-  }
-  const toolTransports = new Map;
-  for (const [key, ep] of Object.entries(materializedEndpoints)) {
-    if (ep.desc.trim() === "") {
-      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" has an empty desc`);
-    }
-    if (ep.maxJsonBodyBytes !== undefined && (!Number.isSafeInteger(ep.maxJsonBodyBytes) || ep.maxJsonBodyBytes <= 0)) {
-      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" maxJsonBodyBytes must be a positive safe integer, received ${ep.maxJsonBodyBytes}`);
-    }
-    if (ep.multipart)
-      assertMultipartEndpoint(meta.prefix, key, ep);
-    if (ep.rawResponse)
-      assertRawEndpoint(meta.prefix, key, ep);
-    if ("stream" in ep)
-      assertStreamingResponseEndpoint(meta.prefix, key, ep);
-    if (ep.method === "HEAD")
-      assertHeadEndpoint(meta.prefix, key, ep);
-    if (ep.rawBody)
-      assertRawBodyEndpoint(meta.prefix, key, ep);
-    if (ep.safelistedBody)
-      assertSafelistedBodyEndpoint(meta.prefix, key, ep);
-    if ("responseMeta" in ep)
-      assertResponseMetaEndpoint(meta.prefix, key, ep);
-    if (!("toolName" in ep) || !ep.toolName)
-      continue;
-    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 toolName "${ep.toolName}" but is not exposed on any tool transport (MCP / AGENT)`);
-    }
-    const existing = toolTransports.get(ep.toolName);
-    if (existing) {
-      for (const t of transports) {
-        if (existing.transports.has(t)) {
-          throw new Error(`Contract "${meta.prefix}": duplicate toolName "${ep.toolName}" on transport "${t}" (endpoints: "${existing.key}" and "${key}")`);
-        }
-        existing.transports.add(t);
-      }
-    } else {
-      toolTransports.set(ep.toolName, { key, transports });
-    }
-  }
-  return { meta, endpoints: materializedEndpoints };
-}
-function assertPositiveLimit(where, name, value) {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
-    throw new Error(`${where} ${name} must be a positive safe integer, received ${value}`);
-  }
-}
-function assertMultipartEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": multipart endpoint "${key}"`;
-  if (ep.method !== "POST" && ep.method !== "PUT" && ep.method !== "PATCH") {
-    throw new Error(`${where} must use POST, PUT or PATCH`);
-  }
-  const multipart = ep.multipart;
-  if (!multipart || typeof multipart !== "object") {
-    throw new Error(`${where} must declare a multipart descriptor`);
-  }
-  assertPositiveLimit(where, "maxRequestBytes", multipart.maxRequestBytes);
-  assertPositiveLimit(where, "maxFieldBytes", multipart.maxFieldBytes);
-  const entries = Object.entries(multipart.files);
-  if (entries.length === 0)
-    throw new Error(`${where} must declare at least one file field`);
-  for (const [field, policy] of entries) {
-    if (!field || isUnsafeKey(field))
-      throw new Error(`${where} has an invalid file field name`);
-    assertPositiveLimit(`${where} field "${field}"`, "maxBytes", policy.maxBytes);
-    assertPositiveLimit(`${where} field "${field}"`, "maxFiles", policy.maxFiles);
-    if (policy.multiple !== true && policy.maxFiles !== undefined) {
-      throw new Error(`${where} field "${field}" may set maxFiles only with multiple: true`);
-    }
-    if (policy.contentTypes) {
-      if (policy.contentTypes.length === 0) {
-        throw new Error(`${where} field "${field}" contentTypes cannot be empty`);
-      }
-      for (const contentType of policy.contentTypes) {
-        if (!/^[a-z0-9!#$&^_.+-]+\/(?:[a-z0-9!#$&^_.+-]+|\*)$/i.test(contentType)) {
-          throw new Error(`${where} field "${field}" has invalid content type policy "${contentType}"`);
-        }
-      }
-    }
-  }
-}
-function assertRawEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": raw endpoint "${key}"`;
-  if (ep.output)
-    throw new Error(`${where} cannot declare an output schema`);
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  if ("ui" in ep && ep.ui)
-    throw new Error(`${where} cannot set MCP ui metadata`);
-  if ("annotations" in ep && ep.annotations) {
-    throw new Error(`${where} cannot set MCP annotations`);
-  }
-  const nonHttp = (ep.expose ?? []).filter((t) => t !== "HTTP");
-  if (nonHttp.length > 0) {
-    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
-  }
-}
-function assertStreamingResponseEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": streaming endpoint "${key}"`;
-  if (!("stream" in ep) || !ep.stream || typeof ep.stream !== "object") {
-    throw new Error(`${where} must declare a stream descriptor`);
-  }
-  if (!ep.stream.item || typeof ep.stream.item.parse !== "function") {
-    throw new Error(`${where} must declare an item schema`);
-  }
-  const runtimeFormat = Reflect.get(ep.stream, "format");
-  const runtimeFinalLine = Reflect.get(ep.stream, "finalLine");
-  if (ep.stream.framing === "item" && runtimeFormat === "sse") {
-    throw new Error(`${where} item framing is supported only for ndjson`);
-  }
-  if (ep.stream.framing === "item" && ep.stream.completion !== "terminal") {
-    throw new Error(`${where} item framing requires terminal completion`);
-  }
-  if (ep.stream.completion === "terminal" && !ep.stream.terminal) {
-    throw new Error(`${where} terminal completion requires a terminal schema`);
-  }
-  if (runtimeFinalLine === "require-newline" && runtimeFormat === "sse") {
-    throw new Error(`${where} finalLine applies only to ndjson`);
-  }
-  assertPositiveLimit(where, "maxFrameBytes", ep.stream.maxFrameBytes);
-  assertPositiveLimit(where, "lifetimeMs", ep.stream.lifetimeMs);
-  assertPositiveLimit(where, "heartbeatMs", ep.stream.heartbeatMs);
-  if (ep.stream.idleTimeoutSeconds !== undefined && (!Number.isSafeInteger(ep.stream.idleTimeoutSeconds) || ep.stream.idleTimeoutSeconds < 0)) {
-    throw new Error(`${where} idleTimeoutSeconds must be a non-negative safe integer`);
-  }
-  if (ep.output)
-    throw new Error(`${where} cannot declare an output schema`);
-  if (ep.rawResponse)
-    throw new Error(`${where} cannot also be rawResponse`);
-  if (ep.multipart)
-    throw new Error(`${where} cannot be multipart`);
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  const nonHttp = (ep.expose ?? []).filter((transport) => transport !== "HTTP");
-  if (nonHttp.length > 0) {
-    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
-  }
-}
-function assertHeadEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": HEAD endpoint "${key}"`;
-  if (!ep.rawResponse)
-    throw new Error(`${where} must declare rawResponse: true`);
-  if (ep.input)
-    throw new Error(`${where} cannot declare an input schema`);
-  if (ep.multipart)
-    throw new Error(`${where} cannot be multipart`);
-  if (ep.rawBody)
-    throw new Error(`${where} cannot retain a raw body`);
-}
-function assertRawBodyEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": rawBody endpoint "${key}"`;
-  if (!ep.input)
-    throw new Error(`${where} must declare an input schema`);
-  if (ep.multipart)
-    throw new Error(`${where} cannot be multipart`);
-  if (ep.method !== "POST" && ep.method !== "PUT" && ep.method !== "PATCH") {
-    throw new Error(`${where} must use POST, PUT or PATCH`);
-  }
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  if ("ui" in ep && ep.ui)
-    throw new Error(`${where} cannot set MCP ui metadata`);
-  if ("annotations" in ep && ep.annotations) {
-    throw new Error(`${where} cannot set MCP annotations`);
-  }
-  const nonHttp = (ep.expose ?? []).filter((transport) => transport !== "HTTP");
-  if (nonHttp.length > 0) {
-    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
-  }
-}
-function assertSafelistedBodyEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": safelistedBody endpoint "${key}"`;
-  if (ep.method !== "POST")
-    throw new Error(`${where} must use POST`);
-  if (!ep.input)
-    throw new Error(`${where} must declare an input schema`);
-  if (ep.multipart)
-    throw new Error(`${where} cannot be multipart`);
-  if ("stream" in ep && ep.stream)
-    throw new Error(`${where} cannot be a streaming response`);
-}
-function assertResponseMetaEndpoint(prefix, key, ep) {
-  const where = `Contract "${prefix}": responseMeta endpoint "${key}"`;
-  if (!ep.responseMeta || typeof ep.responseMeta !== "object") {
-    throw new Error(`${where} must declare responseMeta as an object`);
-  }
-  const status = ep.responseMeta.status;
-  if (status !== undefined && (!Number.isSafeInteger(status) || status < 200 || status > 299)) {
-    throw new Error(`${where} status must be a successful 2xx integer, received ${status}`);
-  }
-  if (ep.output && (status === 204 || status === 205)) {
-    throw new Error(`${where} cannot combine output with bodyless status ${status}`);
-  }
-  if (ep.rawResponse)
-    throw new Error(`${where} cannot also be a rawResponse endpoint`);
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  if ("ui" in ep && ep.ui)
-    throw new Error(`${where} cannot set MCP ui metadata`);
-  if ("annotations" in ep && ep.annotations) {
-    throw new Error(`${where} cannot set MCP annotations`);
-  }
-  const nonHttp = (ep.expose ?? []).filter((transport) => transport !== "HTTP");
-  if (nonHttp.length > 0) {
-    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
-  }
-}
-function mergeMeta(contractMeta, endpointMeta) {
-  if (!contractMeta)
-    return endpointMeta;
-  if (!endpointMeta)
-    return { ...contractMeta };
-  return { ...contractMeta, ...endpointMeta };
-}
-// src/contract/errors-factory.ts
-import { z as z2 } from "zod";
-function isErrorDetailsSchema(value) {
-  return value instanceof z2.ZodObject || value instanceof z2.ZodOptional && value.unwrap() instanceof z2.ZodObject;
-}
-function validateDefinition(code, definition) {
-  if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
-    throw new Error(`[stitchkit] Error "${code}" must declare an integer HTTP status from 400 to 599`);
-  }
-  if (definition.details !== undefined && !isErrorDetailsSchema(definition.details)) {
-    throw new Error(`[stitchkit] Error "${code}" details must be a Zod object or optional Zod object`);
-  }
-  if (definition.message !== undefined && (typeof definition.message !== "string" || definition.message.trim() === "")) {
-    throw new Error(`[stitchkit] Error "${code}" message must be a non-empty string`);
-  }
-}
-function defineErrors(source, mapping) {
-  const definitions = mapObjectTypeBoundary(source, (code, definition) => {
-    const name = String(code);
-    validateDefinition(name, definition);
-    return Object.freeze({ ...definition });
-  });
-  Object.freeze(definitions);
-  const errors = mapObjectTypeBoundary(definitions, (code, definition) => {
-    const name = String(code);
-    return (options = {}) => {
-      const message = options.message ?? definition.message;
-      if (definition.details === undefined) {
-        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);
-      }
-      const details = definition.details.parse(options.details);
-      return new AppError(name, message, definition.status, details, options.hint, undefined, definition.retryable);
-    };
-  });
-  Object.freeze(errors);
-  const codes = mapObjectTypeBoundary(definitions, (code) => String(code));
-  Object.freeze(codes);
-  const known = new Set(Object.keys(definitions));
-  for (const [code, target] of Object.entries(mapping?.map ?? {})) {
-    if (!isStitchErrorCode(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];
-    if (definitions[target]?.status !== status) {
-      throw new Error(`[stitchkit] Error vocabulary maps "${code}" (${status}) to "${target}", declared with status ${String(definitions[target]?.status)}`);
-    }
-  }
-  for (const [statusText, target] of Object.entries(mapping?.fallback ?? {})) {
-    const status = Number(statusText);
-    if (!Number.isInteger(status) || status < 400 || status > 599) {
-      throw new Error(`[stitchkit] Error vocabulary fallback status "${statusText}" must be an integer from 400 to 599`);
-    }
-    if (typeof target !== "string" || !known.has(target)) {
-      throw new Error(`[stitchkit] Error vocabulary fallback ${status} names undeclared code "${String(target)}"`);
-    }
-    if (definitions[target]?.status !== status) {
-      throw new Error(`[stitchkit] Error vocabulary fallback ${status} must name a code with status ${status}`);
-    }
-  }
-  if (mapping?.exhaustive === true) {
-    for (const code of Object.keys(STITCH_ERROR_STATUS)) {
-      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)) {
-    const code = mapping?.map?.[stitchCode] ?? mapping?.fallback?.[status];
-    if (code === undefined)
-      continue;
-    if (!known.has(code)) {
-      throw new Error(`[stitchkit] Error vocabulary maps "${stitchCode}" to undeclared code "${code}"`);
-    }
-    codeMap[stitchCode] = code;
-  }
-  Object.freeze(codeMap);
-  const vocabularyCodeMap = transportResult(codeMap);
-  return Object.freeze({
-    errors,
-    codes,
-    definitions,
-    isCode: (code) => known.has(code),
-    codeMap: vocabularyCodeMap
-  });
-}
-// src/contract/factory.ts
-function createContractFactory(config) {
-  const scoped = (meta, endpoints) => {
-    const validated = defineContract({ prefix: meta.prefix }, endpoints);
-    return {
-      endpoints: validated.endpoints,
-      meta: { ...meta, prefix: meta.prefix, scope: meta.scope }
-    };
-  };
-  if (config?.toolExposure !== "explicit")
-    return { defineContract: scoped };
-  const explicit = (meta, endpoints) => {
-    const materialized = mapObjectTypeBoundary(endpoints, (_key, endpoint) => endpoint.expose ? endpoint : { ...endpoint, expose: ["HTTP"] });
-    return scoped(meta, materialized);
-  };
-  return { defineContract: explicit };
-}
-// src/contract/pagination.ts
-import { z as z3 } from "zod";
-function paginatedSchema(itemSchema) {
-  return z3.object({
-    items: z3.array(itemSchema),
-    nextCursor: z3.string().nullable()
-  });
-}
-function toBase64Url(str) {
-  return bytesToBase64Url(new TextEncoder().encode(str));
-}
-function fromBase64Url(value) {
-  return new TextDecoder().decode(base64UrlToBytes(value));
-}
-function encodeCursor(value) {
-  return toBase64Url(JSON.stringify(value));
-}
-function decodeCursor(cursor, schema) {
-  if (!cursor)
-    return null;
-  try {
-    const parsed = schema.safeParse(JSON.parse(fromBase64Url(cursor)));
-    return parsed.success ? parsed.data : null;
-  } catch {
-    return null;
-  }
-}
-// src/contract/stream.ts
-import { z as z4 } from "zod";
-var DEFAULT_CONTRACT_STREAM_FRAME_BYTES = 256 * 1024;
-var ContractStreamFrameSchema = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.literal("data"), data: z4.unknown() }).strict(),
-  z4.object({
-    type: z4.literal("error"),
-    error: z4.object({
-      code: z4.string(),
-      message: z4.string().optional(),
-      details: z4.unknown().optional(),
-      hint: z4.string().optional()
-    }).strict()
-  }).strict(),
-  z4.object({ type: z4.literal("end") }).strict()
-]);
-export { joinRoutePath, resolveRouteParamsSchema, parseTrailingWildcard, ALL_TRANSPORTS, defineContract, mergeMeta, defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };

package/dist/index-0j3vcp5m.js

@@ -1,28 +0,0 @@
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/internal/canonical-json.ts
-function compareCodepoints(left, right) {
-  if (left < right)
-    return -1;
-  if (left > right)
-    return 1;
-  return 0;
-}
-function canonicalValue(value) {
-  if (Array.isArray(value))
-    return value.map(canonicalValue);
-  if (!isRecord(value))
-    return value;
-  const result = {};
-  for (const key of Object.keys(value).sort(compareCodepoints)) {
-    result[key] = canonicalValue(value[key]);
-  }
-  return result;
-}
-function serializeCanonicalJson(value) {
-  return JSON.stringify(canonicalValue(value));
-}
-
-export { compareCodepoints, serializeCanonicalJson };