stitchkit 0.93.0 → 0.94.1

package/dist/index-cxqhvq21.js

@@ -1,413 +0,0 @@
-import {
-  mergeMeta,
-  resolveRouteParamsSchema
-} from "./index-0a349c33.js";
-import {
-  AppError
-} from "./index-2vtcmrj9.js";
-import {
-  isUnsafeKey
-} from "./index-kzfs85xp.js";
-import {
-  callRuntimeHandler,
-  isRecord,
-  transportResult,
-  typedEntries
-} from "./index-77fekveh.js";
-
-// src/server/implement.ts
-function isStreamingImplementation(value) {
-  return typeof value === "object" && value !== null && "kind" in value && value.kind === "stitchkit.multipart.stream";
-}
-function defineMultipartStream(endpoint, config) {
-  return buildMultipartStream(endpoint, config.files, config.handler);
-}
-function buildMultipartStream(endpoint, files, handler) {
-  const receivers = {};
-  for (const [key, receiver] of typedEntries(files)) {
-    receivers[String(key)] = receiver;
-  }
-  const declared = Object.keys(endpoint.multipart.files);
-  const configured = Object.keys(receivers);
-  if (declared.length !== configured.length || declared.some((field) => !Object.hasOwn(receivers, field))) {
-    throw new Error("Streaming multipart receivers must exactly match declared file fields");
-  }
-  return {
-    kind: "stitchkit.multipart.stream",
-    receivers,
-    execute(ctx, streamedFiles) {
-      return callRuntimeHandler(handler, { ...ctx, files: streamedFiles });
-    }
-  };
-}
-function createMultipartStream() {
-  return (endpoint, config) => buildMultipartStream(endpoint, config.files, config.handler);
-}
-function isStreamingEndpoint(endpoint) {
-  return endpoint.multipart?.delivery === "stream";
-}
-function contractOnlyService(contract) {
-  const handlers = {};
-  for (const [key, endpoint] of Object.entries(contract.endpoints)) {
-    if (isStreamingEndpoint(endpoint)) {
-      const receivers = {};
-      for (const field of Object.keys(endpoint.multipart.files)) {
-        receivers[field] = () => {
-          throw new Error("[stitchkit] contract-only service: handlers are not callable");
-        };
-      }
-      const streaming = {
-        kind: "stitchkit.multipart.stream",
-        receivers,
-        execute: () => {
-          throw new Error("[stitchkit] contract-only service: handlers are not callable");
-        }
-      };
-      handlers[key] = streaming;
-      continue;
-    }
-    handlers[key] = () => {
-      throw new Error("[stitchkit] contract-only service: handlers are not callable");
-    };
-  }
-  return bindContract(contract, handlers);
-}
-var HTTP_ONLY = Object.freeze(["HTTP"]);
-function stubHandler(label) {
-  return () => {
-    throw new AppError("NOT_IMPLEMENTED", `[stitchkit] ${label} is declared by its contract and has no handler`, 501);
-  };
-}
-function bindContract(contract, handlers, options) {
-  const methods = {};
-  const groupScope = contract.meta.scope ?? "public";
-  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
-    const label = `${contract.meta.prefix}.${String(key)}`;
-    let typedHandler = handlers[String(key)];
-    const isStreaming = endpoint.multipart?.delivery === "stream";
-    if (!isStreaming && typeof typedHandler !== "function") {
-      if (options?.onMissingHandler !== "stub") {
-        throw new Error(`[stitchkit] implement: missing handler for "${label}"`);
-      }
-      console.warn(`[stitchkit] implement: "${label}" has no handler and is mounted as a 501 stub`);
-      typedHandler = stubHandler(label);
-    }
-    if (isStreaming && !isStreamingImplementation(typedHandler)) {
-      throw new Error(`[stitchkit] implement: streaming multipart endpoint "${contract.meta.prefix}.${String(key)}" must use defineMultipartStream()`);
-    }
-    const streamingHandler = isStreamingImplementation(typedHandler) ? typedHandler : undefined;
-    const regularHandler = typeof typedHandler === "function" ? typedHandler : undefined;
-    methods[String(key)] = {
-      method: endpoint.method,
-      path: endpoint.path,
-      desc: endpoint.desc,
-      serviceName: contract.meta.prefix,
-      key: String(key),
-      toolName: "toolName" in endpoint ? endpoint.toolName : undefined,
-      expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta || "stream" in endpoint && endpoint.stream ? HTTP_ONLY : endpoint.expose,
-      scope: endpoint.scope ?? groupScope,
-      paramsSchema: resolveRouteParamsSchema(endpoint.path, endpoint.params),
-      inputSchema: endpoint.input,
-      outputSchema: endpoint.output,
-      stream: "stream" in endpoint ? endpoint.stream : undefined,
-      multipart: endpoint.multipart,
-      multipartReceivers: streamingHandler?.receivers,
-      maxJsonBodyBytes: endpoint.maxJsonBodyBytes,
-      idempotent: endpoint.idempotent,
-      ui: "ui" in endpoint ? endpoint.ui : undefined,
-      annotations: "annotations" in endpoint ? endpoint.annotations : undefined,
-      mcp: "mcp" in endpoint ? endpoint.mcp : undefined,
-      meta: mergeMeta(contract.meta.meta, endpoint.meta),
-      rawResponse: endpoint.rawResponse,
-      rawBody: endpoint.rawBody,
-      safelistedBody: endpoint.safelistedBody,
-      responseMeta: endpoint.responseMeta,
-      contentType: "contentType" in endpoint ? endpoint.contentType : undefined,
-      handler: streamingHandler ? (ctx) => streamingHandler.execute(ctx, ctx.files ?? {}) : (ctx) => {
-        if (!regularHandler) {
-          throw new Error(`[stitchkit] implement: missing handler for "${contract.meta.prefix}.${String(key)}"`);
-        }
-        return callRuntimeHandler(regularHandler, ctx);
-      }
-    };
-  }
-  return {
-    name: contract.meta.prefix,
-    prefix: contract.meta.prefix,
-    scope: groupScope,
-    methods
-  };
-}
-function implement(contract, handlers, options) {
-  return bindContract(contract, handlers, options);
-}
-function createImplement() {
-  return (contract, handlers, options) => implement(contract, handlers, options);
-}
-function createScopedImplement() {
-  const implementScoped = (contract, handlers, options) => bindContract(contract, handlers, options);
-  const stream = (scope, endpoint, config) => {
-    if (endpoint.scope !== undefined && endpoint.scope !== scope) {
-      throw new Error(`[stitchkit] createScopedImplement.stream: endpoint declares scope "${endpoint.scope}" but "${String(scope)}" was given`);
-    }
-    return buildMultipartStream(endpoint, config.files, config.handler);
-  };
-  const declare = (_contract) => (handlers) => handlers;
-  return Object.assign(implementScoped, { stream, declare });
-}
-function createScopedImplementRegistry() {
-  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
-}
-function isImplementationContract(value) {
-  return isRecord(value) && isRecord(value.meta) && typeof value.meta.prefix === "string" && isRecord(value.endpoints);
-}
-function bindRegistry(contracts, handlers, options) {
-  const contractKeys = Object.keys(contracts);
-  const handlerKeys = Object.keys(handlers);
-  const missing = contractKeys.filter((key) => !Object.hasOwn(handlers, key));
-  const extra = handlerKeys.filter((key) => !Object.hasOwn(contracts, key));
-  if (missing.length > 0 || extra.length > 0) {
-    if (options?.onMissingHandler !== "stub") {
-      throw new Error(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"})`);
-    }
-    console.warn(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"}) — missing contracts are mounted as 501 stubs and extra handlers are ignored`);
-  }
-  const prefixes = new Map;
-  const services = [];
-  const byKey = {};
-  for (const [key, candidate] of Object.entries(contracts)) {
-    if (!isImplementationContract(candidate)) {
-      throw new TypeError(`[stitchkit] implementRegistry: registry entry "${key}" must be one contract; composed arrays and namespaces are not supported`);
-    }
-    const contract = candidate;
-    const groupScope = contract.meta.scope ?? "public";
-    const identity = `${groupScope}\x00${contract.meta.prefix}`;
-    const previousKey = prefixes.get(identity);
-    if (previousKey !== undefined) {
-      throw new Error(`[stitchkit] implementRegistry: duplicate contract prefix "${contract.meta.prefix}" in scope "${groupScope}" at "${previousKey}" and "${key}"`);
-    }
-    prefixes.set(identity, key);
-    const entryHandlers = handlers[key] === undefined && options?.onMissingHandler === "stub" ? {} : handlers[key];
-    if (!isRecord(entryHandlers)) {
-      throw new TypeError(`[stitchkit] implementRegistry: handlers for "${key}" must be an object`);
-    }
-    const endpointKeys = Object.keys(contract.endpoints);
-    const handlerEntryKeys = Object.keys(entryHandlers);
-    const missingEndpoints = endpointKeys.filter((endpointKey) => !Object.hasOwn(entryHandlers, endpointKey));
-    const extraEndpoints = handlerEntryKeys.filter((endpointKey) => !Object.hasOwn(contract.endpoints, endpointKey));
-    if (missingEndpoints.length > 0 || extraEndpoints.length > 0) {
-      const detail = `handlers for "${key}" mismatch (missing: ${missingEndpoints.join(", ") || "none"}; extra: ${extraEndpoints.join(", ") || "none"})`;
-      if (options?.onMissingHandler !== "stub") {
-        throw new Error(`[stitchkit] implementRegistry: ${detail}`);
-      }
-      console.warn(`[stitchkit] implementRegistry: ${detail} — missing endpoints are mounted as 501 stubs and extra handlers are ignored`);
-    }
-    const service = bindContract(contract, entryHandlers, options);
-    services.push(service);
-    byKey[key] = service;
-  }
-  Object.defineProperty(services, "byKey", { value: byKey, enumerable: false });
-  return transportResult(services);
-}
-function implementRegistry(contracts, handlers, options) {
-  return transportResult(bindRegistry(contracts, handlers, options));
-}
-function createImplementRegistry() {
-  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
-}
-
-// src/server/middleware/cors.ts
-var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
-var DEFAULT_CORS_EXPOSE_HEADERS = "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 corsHeaders(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_HEADERS
-  };
-  const expose = Array.isArray(config.exposeHeaders) ? config.exposeHeaders.join(", ") : config.exposeHeaders ?? DEFAULT_CORS_EXPOSE_HEADERS;
-  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 corsPreflightResponse(config, req) {
-  return new Response(null, {
-    status: 204,
-    headers: corsHeaders(config, req.headers.get("origin"))
-  });
-}
-
-// src/internal/media-type.ts
-function mediaTypeEssence(contentType) {
-  return (contentType ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
-}
-
-// 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/server/context-contribution.ts
-var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
-  "params",
-  "input",
-  "files",
-  "rawBody",
-  "source",
-  "req",
-  "url",
-  "headers",
-  "traceId",
-  "spanId",
-  "ipAddress",
-  "userAgent",
-  "signal",
-  "mcp",
-  "reportProgress"
-]);
-function contributionError(scope, reason) {
-  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
-}
-function descriptorsEqual(left, right) {
-  if (!left || !right)
-    return left === right;
-  if (left.enumerable !== right.enumerable || left.configurable !== right.configurable || left.writable !== right.writable) {
-    return false;
-  }
-  if ("value" in left || "value" in right) {
-    return "value" in left && "value" in right && Object.is(left.value, right.value);
-  }
-  return left.get === right.get && left.set === right.set;
-}
-function contextContributionDelta(original, shadow, scope) {
-  if (Object.getPrototypeOf(shadow) !== Object.getPrototypeOf(original)) {
-    throw contributionError(scope, "context prototype changes are not supported");
-  }
-  const originalKeys = Reflect.ownKeys(original);
-  const shadowKeys = Reflect.ownKeys(shadow);
-  const shadowKeySet = new Set(shadowKeys);
-  for (const key of originalKeys) {
-    if (!shadowKeySet.has(key)) {
-      const printable = typeof key === "string" ? JSON.stringify(key) : "a symbol key";
-      throw contributionError(scope, `context key ${printable} may not be deleted`);
-    }
-  }
-  const contribution = Object.create(null);
-  for (const key of shadowKeys) {
-    const originalDescriptor = Object.getOwnPropertyDescriptor(original, key);
-    const shadowDescriptor = Object.getOwnPropertyDescriptor(shadow, key);
-    if (!shadowDescriptor || descriptorsEqual(originalDescriptor, shadowDescriptor))
-      continue;
-    Object.defineProperty(contribution, key, shadowDescriptor);
-  }
-  return contribution;
-}
-function prepareContextContribution(value, scope) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw contributionError(scope, "expected a plain record");
-  }
-  let prototype;
-  let descriptors;
-  let keys;
-  try {
-    prototype = Object.getPrototypeOf(value);
-    descriptors = Object.getOwnPropertyDescriptors(value);
-    keys = Reflect.ownKeys(value);
-  } catch {
-    throw contributionError(scope, "record inspection failed");
-  }
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw contributionError(scope, "expected Object.prototype or null prototype");
-  }
-  const prepared = Object.create(null);
-  for (const key of keys) {
-    if (typeof key !== "string") {
-      throw contributionError(scope, "symbol keys are not supported");
-    }
-    if (isUnsafeKey(key)) {
-      throw contributionError(scope, `unsafe key ${JSON.stringify(key)}`);
-    }
-    if (RUNTIME_CONTEXT_RESERVED_KEYS.has(key)) {
-      throw contributionError(scope, `reserved key ${JSON.stringify(key)}`);
-    }
-    const descriptor = descriptors[key];
-    if (!descriptor?.enumerable || !("value" in descriptor)) {
-      throw contributionError(scope, `key ${JSON.stringify(key)} must be enumerable data`);
-    }
-    prepared[key] = descriptor.value;
-  }
-  return prepared;
-}
-function mergeContextContribution(ctx, value, scope) {
-  Object.assign(ctx, prepareContextContribution(value, scope));
-}
-
-export { mediaTypeEssence, defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry, DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, isOriginAllowed, corsHeaders, corsPreflightResponse, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, RUNTIME_CONTEXT_RESERVED_KEYS, contextContributionDelta, prepareContextContribution, mergeContextContribution };

package/dist/index-e0znv5gn.js

@@ -1,176 +0,0 @@
-import {
-  AppError
-} from "./index-2vtcmrj9.js";
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/internal/errors.ts
-import { z } from "zod";
-function issuePath(path) {
-  return path.length > 0 ? path.map(String).join(".") : "(root)";
-}
-var MAX_UNION_DEPTH = 3;
-var MAX_DESCRIBED_BRANCHES = 5;
-function unionBranches(issue) {
-  const errors = Reflect.get(issue, "errors");
-  if (!Array.isArray(errors) || errors.length === 0)
-    return;
-  if (!errors.every((branch) => Array.isArray(branch)))
-    return;
-  return errors;
-}
-function deepestBranchReason(issues, prefix, budget) {
-  let deepest;
-  for (const issue of issues) {
-    const path = [...prefix, ...issue.path];
-    const nested = budget > 0 ? unionBranches(issue) : undefined;
-    const candidates = nested ? nested.map((branch) => deepestBranchReason(branch, path, budget - 1)).filter((reason) => reason !== undefined) : [{ path, message: issue.message }];
-    for (const candidate of candidates) {
-      if (!deepest || candidate.path.length > deepest.path.length)
-        deepest = candidate;
-    }
-  }
-  return deepest;
-}
-function unionSummary(branches, prefix) {
-  const reasons = branches.map((issues, index) => ({
-    branch: index + 1,
-    reason: deepestBranchReason(issues, prefix, MAX_UNION_DEPTH)
-  }));
-  const ranked = [...reasons].sort((a, b) => (b.reason?.path.length ?? -1) - (a.reason?.path.length ?? -1));
-  const described = ranked.slice(0, MAX_DESCRIBED_BRANCHES).map(({ branch, reason }) => {
-    if (!reason)
-      return `branch ${branch} reported no reason`;
-    return `branch ${branch} at ${issuePath(reason.path)}: ${reason.message}`;
-  });
-  const rest = branches.length - described.length;
-  const suffix = rest > 0 ? `; ...and ${rest} more branches` : "";
-  return `No union branch matched — ${described.join("; ")}${suffix}`;
-}
-function collectIssues(issues, prefix, branch, depth, into) {
-  for (const issue of issues) {
-    const path = [...prefix, ...issue.path];
-    const branches = unionBranches(issue);
-    into.push({
-      path: issuePath(path),
-      code: issue.code,
-      message: branches ? unionSummary(branches, path) : issue.message,
-      ...branch !== undefined && { branch }
-    });
-    if (!branches || depth >= MAX_UNION_DEPTH)
-      continue;
-    branches.forEach((branchIssues, index) => {
-      collectIssues(branchIssues, path, index + 1, depth + 1, into);
-    });
-  }
-}
-function zodIssues(error) {
-  const issues = [];
-  collectIssues(error.issues, [], undefined, 0, issues);
-  return issues;
-}
-var MAX_FORMATTED_ISSUES = 5;
-function formatZodError(error) {
-  const seen = new Set;
-  const all = zodIssues(error).filter((issue) => {
-    if (seen.has(issue.path))
-      return false;
-    seen.add(issue.path);
-    return true;
-  });
-  const shown = all.slice(0, MAX_FORMATTED_ISSUES);
-  const lines = shown.map((issue) => {
-    const where = issue.branch === undefined ? issue.path : `${issue.path} (branch ${issue.branch})`;
-    return `${where}: ${issue.message}`;
-  });
-  const suffix = all.length > shown.length ? `
-...and ${all.length - shown.length} more issues` : "";
-  return lines.join(`
-`) + suffix;
-}
-var MAX_DETAIL_ISSUES = 20;
-function errorCode(err) {
-  if (AppError.is(err))
-    return err.code;
-  if (err instanceof z.ZodError)
-    return "VALIDATION_ERROR";
-  return;
-}
-function recordedErrorMessage(code, envelopeMessage, thrown) {
-  if ((code === "INTERNAL_SERVER_ERROR" || code === "REALTIME_CONTRACT_VIOLATION") && thrown !== undefined) {
-    if (thrown instanceof Error)
-      return thrown.message;
-    if (typeof thrown === "string")
-      return thrown;
-  }
-  return envelopeMessage;
-}
-function normalizeError(err) {
-  if (AppError.is(err)) {
-    if (err.code === "REALTIME_CONTRACT_VIOLATION") {
-      return new AppError("REALTIME_CONTRACT_VIOLATION", "Realtime contract violation", 500);
-    }
-    return err;
-  }
-  if (err instanceof z.ZodError) {
-    return new AppError("VALIDATION_ERROR", formatZodError(err), 400, {
-      issues: zodIssues(err).slice(0, MAX_DETAIL_ISSUES)
-    });
-  }
-  console.error("[stitchkit] unhandled error:", err);
-  return new AppError("INTERNAL_SERVER_ERROR", "Internal server error", 500);
-}
-function strippedPaths(before, after, prefix) {
-  if (Array.isArray(before)) {
-    if (!Array.isArray(after))
-      return [];
-    return before.flatMap((item, i) => strippedPaths(item, after[i], `${prefix}[${i}]`));
-  }
-  if (!isRecord(before) || !isRecord(after))
-    return [];
-  const paths = [];
-  for (const [key, value] of Object.entries(before)) {
-    const path = prefix ? `${prefix}.${key}` : key;
-    if (!(key in after)) {
-      paths.push(path);
-      continue;
-    }
-    paths.push(...strippedPaths(value, after[key], path));
-  }
-  return paths;
-}
-function validateHandlerOutput(schema, data, onStripped) {
-  const parsed = schema.safeParse(data);
-  if (parsed.success) {
-    if (onStripped) {
-      const paths = strippedPaths(data, parsed.data, "");
-      if (paths.length > 0)
-        onStripped(paths);
-    }
-    return { ok: true, data: parsed.data };
-  }
-  return {
-    ok: false,
-    message: `Handler output does not match the contract: ${formatZodError(parsed.error)}`
-  };
-}
-function validateDeclaredOutput(schema, data, onStripped) {
-  if (!schema) {
-    if (data === undefined || data === null)
-      return { ok: true, data };
-    return {
-      ok: false,
-      message: "Handler returned data but the contract declares no output"
-    };
-  }
-  if (data === undefined) {
-    return {
-      ok: false,
-      message: "Handler returned undefined but the contract declares an output"
-    };
-  }
-  return validateHandlerOutput(schema, data, onStripped);
-}
-
-export { zodIssues, formatZodError, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput };