@temporary-name/server 1.9.3-alpha.121f1a14eceb7f2aa23c6993c2adce0ccca377db → 1.9.3-alpha.1a5ff4923d25c9d83e80d717687ebc859f5312f2

package/dist/index.mjs

@@ -1,136 +1,13 @@
+import { mergePrefix, mergeTags, ContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, prefixRoute, initialSchemas, isContractProcedure, getContractRouter } from '@temporary-name/contract';
+export { ValidationError, eventIterator, validateORPCError } from '@temporary-name/contract';
 import { onError, resolveMaybeOptionalOptions } from '@temporary-name/shared';
 export { AsyncIteratorClass, EventPublisher, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, safe, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
-import { isContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, enhanceRoute, mergeTags, ContractProcedure, getContractRouter } from '@temporary-name/contract';
-export { ValidationError, eventIterator, type, validateORPCError } from '@temporary-name/contract';
-import { c as createProcedureClient, i as isLazy, g as getLazyMeta, l as lazy$1, u as unlazy } from './shared/server.BZtKt8i8.mjs';
-export { L as LAZY_SYMBOL, a as createORPCErrorConstructorMap, m as mergeCurrentContext, b as middlewareOutputFn } from './shared/server.BZtKt8i8.mjs';
-import * as core from 'zod/v4/core';
-import { $ZodError, util, _overwrite, _regex, _includes, _startsWith, _endsWith, _minLength, _maxLength, _length, _lowercase, _uppercase, _trim, _normalize, _toLowerCase, _toUpperCase, _gt, _gte, _lt, _lte, _multipleOf } from 'zod/v4/core';
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { SchemaClass, gatingContext } from '@temporary-name/zod';
+import { P as Procedure, c as createProcedureClient, e as enhanceRouter, a as addMiddleware, s as setHiddenRouterContract, l as lazyInternal, g as getLazyMeta, u as unlazy, i as isProcedure, b as isLazy, d as getRouter } from './shared/server.CHV9AQHl.mjs';
+export { L as LAZY_SYMBOL, p as createAccessibleLazyRouter, f as createORPCErrorConstructorMap, o as getHiddenRouterContract, k as isStartWithMiddlewares, h as lazy, m as mergeCurrentContext, n as mergeMiddlewares, j as middlewareOutputFn, r as resolveContractProcedures, t as traverseContractProcedures, q as unlazyRouter } from './shared/server.CHV9AQHl.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
 
-function isStartWithMiddlewares(middlewares, compare) {
-  if (compare.length > middlewares.length) {
-    return false;
-  }
-  for (let i = 0; i < middlewares.length; i++) {
-    if (compare[i] === void 0) {
-      return true;
-    }
-    if (middlewares[i] !== compare[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function mergeMiddlewares(first, second, options) {
-  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
-    return second;
-  }
-  return [...first, ...second];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
-}
-
-function decorateMiddleware(middleware) {
-  const decorated = ((...args) => middleware(...args));
-  decorated.mapInput = (mapInput) => {
-    const mapped = decorateMiddleware(
-      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
-    );
-    return mapped;
-  };
-  decorated.concat = (concatMiddleware, mapInput) => {
-    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
-    const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const merged = middleware(
-        {
-          ...options,
-          next: (...[nextOptions1]) => mapped(
-            {
-              ...options,
-              context: { ...options.context, ...nextOptions1?.context },
-              next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
-            },
-            input,
-            output,
-            ...rest
-          )
-        },
-        input,
-        output,
-        ...rest
-      );
-      return merged;
-    });
-    return concatted;
-  };
-  return decorated;
-}
-
-class Procedure {
-  /**
-   * This property holds the defined options.
-   */
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-}
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
-}
-
 class DecoratedProcedure extends Procedure {
-  /**
-   * Adds type-safe custom errors.
-   * The provided errors are spared-merged with any existing errors.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
-   */
-  errors(errors) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-  }
-  /**
-   * Sets or updates the metadata.
-   * The provided metadata is spared-merged with any existing metadata.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
-   */
-  meta(meta) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      meta: mergeMeta(this["~orpc"].meta, meta)
-    });
-  }
-  /**
-   * Sets or updates the route definition.
-   * The provided route is spared-merged with any existing route.
-   * This option is typically relevant when integrating with OpenAPI.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
-   * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
-   */
-  route(route) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
-    });
-  }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
-    });
-  }
   /**
    * Make this procedure callable (works like a function while still being a procedure).
    *
@@ -149,1717 +26,11 @@ class DecoratedProcedure extends Procedure {
   }
 }
 
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
-function setHiddenRouterContract(router, contract) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getHiddenRouterContract(router) {
-  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
-}
-
-function getRouter(router, path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    return lazy$1(async () => {
-      const unwrapped = await unlazy(lazied);
-      const next = getRouter(unwrapped.default, rest);
-      return unlazy(next);
-    }, getLazyMeta(lazied));
-  }
-  return current;
-}
-function createAccessibleLazyRouter(lazied) {
-  const recursive = new Proxy(lazied, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouter(lazied, [key]);
-      return createAccessibleLazyRouter(next);
-    }
-  });
-  return recursive;
-}
-function enhanceRouter(router, options) {
-  if (isLazy(router)) {
-    const laziedMeta = getLazyMeta(router);
-    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
-    const enhanced2 = lazy$1(
-      async () => {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = enhanceRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      },
-      {
-        ...laziedMeta,
-        prefix: enhancedPrefix
-      }
-    );
-    const accessible = createAccessibleLazyRouter(enhanced2);
-    return accessible;
-  }
-  if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
-      dedupeLeading: options.dedupeLeadingMiddlewares
-    });
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const enhanced2 = new Procedure({
-      ...router["~orpc"],
-      route: enhanceRoute(router["~orpc"].route, options),
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      middlewares: newMiddlewares,
-      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
-      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
-    });
-    return enhanced2;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = enhanceRouter(router[key], options);
-  }
-  return enhanced;
-}
-function traverseContractProcedures(options, callback, lazyOptions = []) {
-  let currentRouter = options.router;
-  const hiddenContract = getHiddenRouterContract(options.router);
-  if (hiddenContract !== void 0) {
-    currentRouter = hiddenContract;
-  }
-  if (isLazy(currentRouter)) {
-    lazyOptions.push({
-      router: currentRouter,
-      path: options.path
-    });
-  } else if (isContractProcedure(currentRouter)) {
-    callback({
-      contract: currentRouter,
-      path: options.path
-    });
-  } else {
-    for (const key in currentRouter) {
-      traverseContractProcedures(
-        {
-          router: currentRouter[key],
-          path: [...options.path, key]
-        },
-        callback,
-        lazyOptions
-      );
-    }
-  }
-  return lazyOptions;
-}
-async function resolveContractProcedures(options, callback) {
-  const pending = [options];
-  for (const options2 of pending) {
-    const lazyOptions = traverseContractProcedures(options2, callback);
-    for (const options3 of lazyOptions) {
-      const { default: router } = await unlazy(options3.router);
-      pending.push({
-        router,
-        path: options3.path
-      });
-    }
-  }
-}
-async function unlazyRouter(router) {
-  if (isProcedure(router)) {
-    return router;
-  }
-  const unlazied = {};
-  for (const key in router) {
-    const item = router[key];
-    const { default: unlaziedRouter } = await unlazy(item);
-    unlazied[key] = await unlazyRouter(unlaziedRouter);
-  }
-  return unlazied;
-}
-
-const ZodISODateTime = /* @__PURE__ */ core.$constructor(
-  "ZodISODateTime",
-  (inst, def) => {
-    const coreInit = core.$ZodISODateTime.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function datetime(params) {
-  return core._isoDateTime(ZodISODateTime, params);
-}
-const ZodISODate = /* @__PURE__ */ core.$constructor(
-  "ZodISODate",
-  (inst, def) => {
-    const coreInit = core.$ZodISODate.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function date$1(params) {
-  return core._isoDate(ZodISODate, params);
-}
-const ZodISOTime = /* @__PURE__ */ core.$constructor(
-  "ZodISOTime",
-  (inst, def) => {
-    const coreInit = core.$ZodISOTime.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function time(params) {
-  return core._isoTime(ZodISOTime, params);
-}
-const ZodISODuration = /* @__PURE__ */ core.$constructor(
-  "ZodISODuration",
-  (inst, def) => {
-    const coreInit = core.$ZodISODuration.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function duration(params) {
-  return core._isoDuration(ZodISODuration, params);
-}
-
-const initializer = (inst, issues) => {
-  $ZodError.init(inst, issues);
-  inst.name = "ZodError";
-  Object.defineProperties(inst, {
-    format: {
-      value: (mapper) => core.formatError(inst, mapper)
-      // enumerable: false,
-    },
-    flatten: {
-      value: (mapper) => core.flattenError(inst, mapper)
-      // enumerable: false,
-    },
-    addIssue: {
-      value: (issue) => {
-        inst.issues.push(issue);
-        inst.message = JSON.stringify(inst.issues, core.util.jsonStringifyReplacer, 2);
-      }
-      // enumerable: false,
-    },
-    addIssues: {
-      value: (issues2) => {
-        inst.issues.push(...issues2);
-        inst.message = JSON.stringify(inst.issues, core.util.jsonStringifyReplacer, 2);
-      }
-      // enumerable: false,
-    },
-    isEmpty: {
-      get() {
-        return inst.issues.length === 0;
-      }
-      // enumerable: false,
-    }
-  });
-};
-core.$constructor("ZodError", initializer);
-const ZodRealError = core.$constructor("ZodError", initializer, {
-  Parent: Error
-});
-
-const parse = /* @__PURE__ */ core._parse(ZodRealError);
-const parseAsync = /* @__PURE__ */ core._parseAsync(ZodRealError);
-const safeParse = /* @__PURE__ */ core._safeParse(ZodRealError);
-const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodRealError);
-const encode = /* @__PURE__ */ core._encode(ZodRealError);
-const decode = /* @__PURE__ */ core._decode(ZodRealError);
-const encodeAsync = /* @__PURE__ */ core._encodeAsync(ZodRealError);
-const decodeAsync = /* @__PURE__ */ core._decodeAsync(ZodRealError);
-const safeEncode = /* @__PURE__ */ core._safeEncode(ZodRealError);
-const safeDecode = /* @__PURE__ */ core._safeDecode(ZodRealError);
-const safeEncodeAsync = /* @__PURE__ */ core._safeEncodeAsync(ZodRealError);
-const safeDecodeAsync = /* @__PURE__ */ core._safeDecodeAsync(ZodRealError);
-
-const gatingContext = new AsyncLocalStorage();
-function isGateIssueRaw(issue) {
-  return issue.code === "invalid_type" && issue.expected === "never" && issue.inst instanceof ZodGate;
-}
-function isGateIssue(issue) {
-  return issue.code === "invalid_type" && issue.expected === "never" && issue.path?.length === 0;
-}
-const ZodGate = /* @__PURE__ */ core.$constructor("ZodGate", (inst, def) => {
-  const coreInit = core.$ZodOptional.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const gateEnabled = gatingContext.getStore()?.(def.gateName);
-    if (gateEnabled) {
-      return def.innerType._zod.run(payload, ctx);
-    } else if (payload.value !== void 0) {
-      payload.issues.push({
-        expected: "never",
-        code: "invalid_type",
-        input: payload.value,
-        inst
-      });
-    }
-    return payload;
-  };
-});
-function gate(innerType, gateName) {
-  return new ZodGate({
-    type: "optional",
-    innerType,
-    gateName
-  });
-}
-
-function handleGating(payload) {
-  for (let i = 0; i < payload.issues.length; i++) {
-    const issue = payload.issues[i];
-    if (issue?.code === "invalid_union") {
-      const newErrors = issue.errors.filter((innerIssues) => !innerIssues.some(isGateIssue));
-      issue.errors.splice(0, Infinity, ...newErrors);
-    }
-  }
-  return payload;
-}
-const ZodUnion = /* @__PURE__ */ core.$constructor(
-  "ZodUnion",
-  (inst, def) => {
-    const coreInit = core.$ZodUnion.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.options = def.options;
-    const origParse = inst._zod.parse;
-    inst._zod.parse = (payload, ctx) => {
-      const res = origParse(payload, ctx);
-      if (res instanceof Promise) {
-        return res.then((r) => handleGating(r));
-      } else {
-        return handleGating(res);
-      }
-    };
-  }
-);
-function union(options, params) {
-  return new ZodUnion({
-    type: "union",
-    options,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodDiscriminatedUnion = /* @__PURE__ */ core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
-  ZodUnion.init(inst, def);
-  const coreInit = core.$ZodDiscriminatedUnion.init;
-  coreInit(inst, def);
-});
-function discriminatedUnion(discriminator, options, params) {
-  return new ZodDiscriminatedUnion({
-    type: "union",
-    options,
-    discriminator,
-    ...util.normalizeParams(params)
-  });
-}
-
-function handlePropertyResult(result, final, key, input) {
-  if (result.issues.length) {
-    final.issues.push(...util.prefixIssues(key, result.issues));
-  }
-  if (result.value === void 0) {
-    if (key in input) {
-      final.value[key] = void 0;
-    }
-  } else {
-    final.value[key] = result.value;
-  }
-}
-const ZodObject = /* @__PURE__ */ core.$constructor(
-  "ZodObject",
-  (inst, def) => {
-    const coreInit = core.$ZodObjectJIT.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    util.defineLazy(inst, "shape", () => {
-      return def.shape;
-    });
-    inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
-    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
-    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
-    inst.extend = (incoming) => {
-      return util.extend(inst, incoming);
-    };
-    inst.safeExtend = (incoming) => {
-      return util.safeExtend(inst, incoming);
-    };
-    inst.merge = (other) => util.merge(inst, other);
-    inst.pick = (mask) => util.pick(inst, mask);
-    inst.omit = (mask) => util.omit(inst, mask);
-    inst.partial = (...args) => util.partial(ZodOptional, inst, args[0]);
-    inst.required = (...args) => util.required(ZodNonOptional, inst, args[0]);
-    function handleGating(input, payload, ctx) {
-      const _catchall = def.catchall?._zod;
-      const t = _catchall?.def.type;
-      let newIssues = null;
-      const proms = [];
-      const newUnrecognizedKeys = [];
-      for (let i = 0; i < payload.issues.length; i++) {
-        const issue = payload.issues[i];
-        if (!isGateIssueRaw(issue)) {
-          continue;
-        }
-        newIssues ??= [...payload.issues];
-        newIssues[i] = null;
-        const key = issue.path[0];
-        if (!_catchall) {
-          delete payload.value[key];
-        } else if (t === "never") {
-          newUnrecognizedKeys.push(key);
-        } else {
-          const r = _catchall.run({ value: input[key], issues: [] }, ctx);
-          if (r instanceof Promise) {
-            proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
-          } else {
-            handlePropertyResult(r, payload, key, input);
-          }
-        }
-      }
-      if (newIssues) {
-        payload.issues = newIssues.filter(Boolean);
-      }
-      if (newUnrecognizedKeys.length > 0) {
-        const missingKeyIssue = payload.issues.find(
-          (issue) => issue.code === "unrecognized_keys" && !issue.path
-        );
-        if (missingKeyIssue) {
-          missingKeyIssue.keys.push(...newUnrecognizedKeys);
-        } else {
-          payload.issues.push({
-            code: "unrecognized_keys",
-            keys: newUnrecognizedKeys,
-            input,
-            inst
-          });
-        }
-      }
-      if (proms.length > 0) {
-        return Promise.all(proms).then(() => payload);
-      } else {
-        return payload;
-      }
-    }
-    const origParse = inst._zod.parse;
-    inst._zod.parse = (payload, ctx) => {
-      const input = payload.value;
-      const res = origParse(payload, ctx);
-      if (res instanceof Promise) {
-        return res.then((r) => handleGating(input, r, ctx));
-      } else {
-        return handleGating(input, res, ctx);
-      }
-    };
-  }
-);
-function object(shape, params) {
-  const def = {
-    type: "object",
-    shape: shape ?? {},
-    ...util.normalizeParams(params)
-  };
-  return new ZodObject(def);
-}
-function strictObject(shape, params) {
-  return new ZodObject({
-    type: "object",
-    shape,
-    catchall: never(),
-    ...util.normalizeParams(params)
-  });
-}
-function looseObject(shape, params) {
-  return new ZodObject({
-    type: "object",
-    shape,
-    catchall: unknown(),
-    ...util.normalizeParams(params)
-  });
-}
-
-const KrustyType = /* @__PURE__ */ core.$constructor(
-  "KrustyType",
-  (inst, def) => {
-    const coreInit = core.$ZodType.init;
-    coreInit(inst, def);
-    inst.def = def;
-    inst.type = def.type;
-    Object.defineProperty(inst, "_def", { value: def });
-    inst.check = (...checks2) => {
-      return inst.clone(
-        util.mergeDefs(def, {
-          checks: [
-            ...def.checks ?? [],
-            ...checks2.map(
-              (ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
-            )
-          ]
-        })
-      );
-    };
-    inst.clone = (def2, params) => core.clone(inst, def2, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta) => {
-      reg.add(inst, meta);
-      return inst;
-    });
-    inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
-    inst.spa = inst.safeParseAsync;
-    inst.encode = (data, params) => encode(inst, data, params);
-    inst.decode = (data, params) => decode(inst, data, params);
-    inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
-    inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
-    inst.safeEncode = (data, params) => safeEncode(inst, data, params);
-    inst.safeDecode = (data, params) => safeDecode(inst, data, params);
-    inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
-    inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
-    inst.refine = (check2, params) => inst.check(refine(check2, params));
-    inst.superRefine = (refinement) => inst.check(superRefine(refinement));
-    inst.overwrite = (fn) => inst.check(_overwrite(fn));
-    inst.gate = (gateName) => gate(inst, gateName);
-    inst.optional = () => optional(inst);
-    inst.nullable = () => nullable(inst);
-    inst.nullish = () => optional(nullable(inst));
-    inst.nonoptional = (params) => nonoptional(inst, params);
-    inst.array = () => array(inst);
-    inst.or = (arg) => union([inst, arg]);
-    inst.and = (arg) => intersection(inst, arg);
-    inst.transform = (tx) => pipe(inst, transform(tx));
-    inst.default = (def2) => _default(inst, def2);
-    inst.prefault = (def2) => prefault(inst, def2);
-    inst.catch = (params) => _catch(inst, params);
-    inst.pipe = (target) => pipe(inst, target);
-    inst.readonly = () => readonly(inst);
-    inst.describe = (description) => {
-      const cl = inst.clone();
-      core.globalRegistry.add(cl, { description });
-      return cl;
-    };
-    Object.defineProperty(inst, "description", {
-      get() {
-        return core.globalRegistry.get(inst)?.description;
-      },
-      configurable: true
-    });
-    inst.meta = (...args) => {
-      if (args.length === 0) {
-        return core.globalRegistry.get(inst);
-      }
-      const cl = inst.clone();
-      core.globalRegistry.add(cl, args[0]);
-      return cl;
-    };
-    return inst;
-  }
-);
-const _ZodString = /* @__PURE__ */ core.$constructor(
-  "_ZodString",
-  (inst, def) => {
-    const coreInit = core.$ZodString.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    const bag = inst._zod.bag;
-    inst.format = bag.format ?? null;
-    inst.minLength = bag.minimum ?? null;
-    inst.maxLength = bag.maximum ?? null;
-    inst.regex = (...args) => inst.check(_regex(...args));
-    inst.includes = (...args) => inst.check(_includes(...args));
-    inst.startsWith = (...args) => inst.check(_startsWith(...args));
-    inst.endsWith = (...args) => inst.check(_endsWith(...args));
-    inst.min = (...args) => inst.check(_minLength(...args));
-    inst.max = (...args) => inst.check(_maxLength(...args));
-    inst.length = (...args) => inst.check(_length(...args));
-    inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
-    inst.lowercase = (params) => inst.check(_lowercase(params));
-    inst.uppercase = (params) => inst.check(_uppercase(params));
-    inst.trim = () => inst.check(_trim());
-    inst.normalize = (...args) => inst.check(_normalize(...args));
-    inst.toLowerCase = () => inst.check(_toLowerCase());
-    inst.toUpperCase = () => inst.check(_toUpperCase());
-  }
-);
-const ZodString = /* @__PURE__ */ core.$constructor(
-  "ZodString",
-  (inst, def) => {
-    const coreInit = core.$ZodString.init;
-    coreInit(inst, def);
-    _ZodString.init(inst, def);
-    inst.email = (params) => inst.check(core._email(ZodEmail, params));
-    inst.url = (params) => inst.check(core._url(ZodURL, params));
-    inst.jwt = (params) => inst.check(core._jwt(ZodJWT, params));
-    inst.emoji = (params) => inst.check(core._emoji(ZodEmoji, params));
-    inst.guid = (params) => inst.check(core._guid(ZodGUID, params));
-    inst.uuid = (params) => inst.check(core._uuid(ZodUUID, params));
-    inst.uuidv4 = (params) => inst.check(core._uuidv4(ZodUUID, params));
-    inst.uuidv6 = (params) => inst.check(core._uuidv6(ZodUUID, params));
-    inst.uuidv7 = (params) => inst.check(core._uuidv7(ZodUUID, params));
-    inst.nanoid = (params) => inst.check(core._nanoid(ZodNanoID, params));
-    inst.guid = (params) => inst.check(core._guid(ZodGUID, params));
-    inst.cuid = (params) => inst.check(core._cuid(ZodCUID, params));
-    inst.cuid2 = (params) => inst.check(core._cuid2(ZodCUID2, params));
-    inst.ulid = (params) => inst.check(core._ulid(ZodULID, params));
-    inst.base64 = (params) => inst.check(core._base64(ZodBase64, params));
-    inst.base64url = (params) => inst.check(core._base64url(ZodBase64URL, params));
-    inst.xid = (params) => inst.check(core._xid(ZodXID, params));
-    inst.ksuid = (params) => inst.check(core._ksuid(ZodKSUID, params));
-    inst.ipv4 = (params) => inst.check(core._ipv4(ZodIPv4, params));
-    inst.ipv6 = (params) => inst.check(core._ipv6(ZodIPv6, params));
-    inst.cidrv4 = (params) => inst.check(core._cidrv4(ZodCIDRv4, params));
-    inst.cidrv6 = (params) => inst.check(core._cidrv6(ZodCIDRv6, params));
-    inst.e164 = (params) => inst.check(core._e164(ZodE164, params));
-    inst.datetime = (params) => inst.check(datetime(params));
-    inst.date = (params) => inst.check(date$1(params));
-    inst.time = (params) => inst.check(time(params));
-    inst.duration = (params) => inst.check(duration(params));
-  }
-);
-function string(params) {
-  return core._string(ZodString, params);
-}
-const ZodStringFormat = /* @__PURE__ */ core.$constructor(
-  "ZodStringFormat",
-  (inst, def) => {
-    const coreInit = core.$ZodStringFormat.init;
-    coreInit(inst, def);
-    _ZodString.init(inst, def);
-  }
-);
-const ZodEmail = /* @__PURE__ */ core.$constructor(
-  "ZodEmail",
-  (inst, def) => {
-    const coreInit = core.$ZodEmail.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function email(params) {
-  return core._email(ZodEmail, params);
-}
-const ZodGUID = /* @__PURE__ */ core.$constructor("ZodGUID", (inst, def) => {
-  const coreInit = core.$ZodGUID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function guid(params) {
-  return core._guid(ZodGUID, params);
-}
-const ZodUUID = /* @__PURE__ */ core.$constructor("ZodUUID", (inst, def) => {
-  const coreInit = core.$ZodUUID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function uuid(params) {
-  return core._uuid(ZodUUID, params);
-}
-function uuidv4(params) {
-  return core._uuidv4(ZodUUID, params);
-}
-function uuidv6(params) {
-  return core._uuidv6(ZodUUID, params);
-}
-function uuidv7(params) {
-  return core._uuidv7(ZodUUID, params);
-}
-const ZodURL = /* @__PURE__ */ core.$constructor("ZodURL", (inst, def) => {
-  const coreInit = core.$ZodURL.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function url(params) {
-  return core._url(ZodURL, params);
-}
-function httpUrl(params) {
-  return core._url(ZodURL, {
-    protocol: /^https?$/,
-    hostname: core.regexes.domain,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodEmoji = /* @__PURE__ */ core.$constructor(
-  "ZodEmoji",
-  (inst, def) => {
-    const coreInit = core.$ZodEmoji.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function emoji(params) {
-  return core._emoji(ZodEmoji, params);
-}
-const ZodNanoID = /* @__PURE__ */ core.$constructor(
-  "ZodNanoID",
-  (inst, def) => {
-    const coreInit = core.$ZodNanoID.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function nanoid(params) {
-  return core._nanoid(ZodNanoID, params);
-}
-const ZodCUID = /* @__PURE__ */ core.$constructor("ZodCUID", (inst, def) => {
-  const coreInit = core.$ZodCUID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function cuid(params) {
-  return core._cuid(ZodCUID, params);
-}
-const ZodCUID2 = /* @__PURE__ */ core.$constructor(
-  "ZodCUID2",
-  (inst, def) => {
-    const coreInit = core.$ZodCUID2.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function cuid2(params) {
-  return core._cuid2(ZodCUID2, params);
-}
-const ZodULID = /* @__PURE__ */ core.$constructor("ZodULID", (inst, def) => {
-  const coreInit = core.$ZodULID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function ulid(params) {
-  return core._ulid(ZodULID, params);
-}
-const ZodXID = /* @__PURE__ */ core.$constructor("ZodXID", (inst, def) => {
-  const coreInit = core.$ZodXID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function xid(params) {
-  return core._xid(ZodXID, params);
-}
-const ZodKSUID = /* @__PURE__ */ core.$constructor(
-  "ZodKSUID",
-  (inst, def) => {
-    const coreInit = core.$ZodKSUID.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function ksuid(params) {
-  return core._ksuid(ZodKSUID, params);
-}
-const ZodIPv4 = /* @__PURE__ */ core.$constructor("ZodIPv4", (inst, def) => {
-  const coreInit = core.$ZodIPv4.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function ipv4(params) {
-  return core._ipv4(ZodIPv4, params);
-}
-const ZodIPv6 = /* @__PURE__ */ core.$constructor("ZodIPv6", (inst, def) => {
-  const coreInit = core.$ZodIPv6.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function ipv6(params) {
-  return core._ipv6(ZodIPv6, params);
-}
-const ZodCIDRv4 = /* @__PURE__ */ core.$constructor(
-  "ZodCIDRv4",
-  (inst, def) => {
-    const coreInit = core.$ZodCIDRv4.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function cidrv4(params) {
-  return core._cidrv4(ZodCIDRv4, params);
-}
-const ZodCIDRv6 = /* @__PURE__ */ core.$constructor(
-  "ZodCIDRv6",
-  (inst, def) => {
-    const coreInit = core.$ZodCIDRv6.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function cidrv6(params) {
-  return core._cidrv6(ZodCIDRv6, params);
-}
-const ZodBase64 = /* @__PURE__ */ core.$constructor(
-  "ZodBase64",
-  (inst, def) => {
-    const coreInit = core.$ZodBase64.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function base64(params) {
-  return core._base64(ZodBase64, params);
-}
-const ZodBase64URL = /* @__PURE__ */ core.$constructor(
-  "ZodBase64URL",
-  (inst, def) => {
-    const coreInit = core.$ZodBase64URL.init;
-    coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
-  }
-);
-function base64url(params) {
-  return core._base64url(ZodBase64URL, params);
-}
-const ZodE164 = /* @__PURE__ */ core.$constructor("ZodE164", (inst, def) => {
-  const coreInit = core.$ZodE164.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function e164(params) {
-  return core._e164(ZodE164, params);
-}
-const ZodJWT = /* @__PURE__ */ core.$constructor("ZodJWT", (inst, def) => {
-  const coreInit = core.$ZodJWT.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function jwt(params) {
-  return core._jwt(ZodJWT, params);
-}
-const ZodCustomStringFormat = /* @__PURE__ */ core.$constructor("ZodCustomStringFormat", (inst, def) => {
-  const coreInit = core.$ZodCustomStringFormat.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
-function stringFormat(format, fnOrRegex, _params = {}) {
-  return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
-}
-function hostname(_params) {
-  return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params);
-}
-function hex(_params) {
-  return core._stringFormat(ZodCustomStringFormat, "hex", core.regexes.hex, _params);
-}
-function hash(alg, params) {
-  const enc = params?.enc ?? "hex";
-  const format = `${alg}_${enc}`;
-  const regex = core.regexes[format];
-  if (!regex) throw new Error(`Unrecognized hash format: ${format}`);
-  return core._stringFormat(ZodCustomStringFormat, format, regex, params);
-}
-const ZodNumber = /* @__PURE__ */ core.$constructor(
-  "ZodNumber",
-  (inst, def) => {
-    const coreInit = core.$ZodNumber.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.gt = (value, params) => inst.check(_gt(value, params));
-    inst.gte = (value, params) => inst.check(_gte(value, params));
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.lt = (value, params) => inst.check(_lt(value, params));
-    inst.lte = (value, params) => inst.check(_lte(value, params));
-    inst.max = (value, params) => inst.check(_lte(value, params));
-    inst.int = (params) => inst.check(int(params));
-    inst.safe = (params) => inst.check(int(params));
-    inst.positive = (params) => inst.check(_gt(0, params));
-    inst.nonnegative = (params) => inst.check(_gte(0, params));
-    inst.negative = (params) => inst.check(_lt(0, params));
-    inst.nonpositive = (params) => inst.check(_lte(0, params));
-    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
-    inst.step = (value, params) => inst.check(_multipleOf(value, params));
-    inst.finite = () => inst;
-    const bag = inst._zod.bag;
-    inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
-    inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
-    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
-    inst.isFinite = true;
-    inst.format = bag.format ?? null;
-  }
-);
-function number(params) {
-  return core._number(ZodNumber, params);
-}
-const ZodNumberFormat = /* @__PURE__ */ core.$constructor(
-  "ZodNumberFormat",
-  (inst, def) => {
-    const coreInit = core.$ZodNumberFormat.init;
-    coreInit(inst, def);
-    ZodNumber.init(inst, def);
-  }
-);
-function int(params) {
-  return core._int(ZodNumberFormat, params);
-}
-function float32(params) {
-  return core._float32(ZodNumberFormat, params);
-}
-function float64(params) {
-  return core._float64(ZodNumberFormat, params);
-}
-function int32(params) {
-  return core._int32(ZodNumberFormat, params);
-}
-function uint32(params) {
-  return core._uint32(ZodNumberFormat, params);
-}
-const ZodBoolean = /* @__PURE__ */ core.$constructor(
-  "ZodBoolean",
-  (inst, def) => {
-    const coreInit = core.$ZodBoolean.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function boolean(params) {
-  return core._boolean(ZodBoolean, params);
-}
-const ZodBigInt = /* @__PURE__ */ core.$constructor(
-  "ZodBigInt",
-  (inst, def) => {
-    const coreInit = core.$ZodBigInt.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.gte = (value, params) => inst.check(_gte(value, params));
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.gt = (value, params) => inst.check(_gt(value, params));
-    inst.gte = (value, params) => inst.check(_gte(value, params));
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.lt = (value, params) => inst.check(_lt(value, params));
-    inst.lte = (value, params) => inst.check(_lte(value, params));
-    inst.max = (value, params) => inst.check(_lte(value, params));
-    inst.positive = (params) => inst.check(_gt(BigInt(0), params));
-    inst.negative = (params) => inst.check(_lt(BigInt(0), params));
-    inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
-    inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
-    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
-    const bag = inst._zod.bag;
-    inst.minValue = bag.minimum ?? null;
-    inst.maxValue = bag.maximum ?? null;
-    inst.format = bag.format ?? null;
-  }
-);
-function bigint(params) {
-  return core._bigint(ZodBigInt, params);
-}
-const ZodBigIntFormat = /* @__PURE__ */ core.$constructor(
-  "ZodBigIntFormat",
-  (inst, def) => {
-    const coreInit = core.$ZodBigIntFormat.init;
-    coreInit(inst, def);
-    ZodBigInt.init(inst, def);
-  }
-);
-function int64(params) {
-  return core._int64(ZodBigIntFormat, params);
-}
-function uint64(params) {
-  return core._uint64(ZodBigIntFormat, params);
-}
-const ZodSymbol = /* @__PURE__ */ core.$constructor(
-  "ZodSymbol",
-  (inst, def) => {
-    const coreInit = core.$ZodSymbol.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function symbol(params) {
-  return core._symbol(ZodSymbol, params);
-}
-const ZodUndefined = /* @__PURE__ */ core.$constructor(
-  "ZodUndefined",
-  (inst, def) => {
-    const coreInit = core.$ZodUndefined.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function _undefined(params) {
-  return core._undefined(ZodUndefined, params);
-}
-const ZodNull = /* @__PURE__ */ core.$constructor("ZodNull", (inst, def) => {
-  const coreInit = core.$ZodNull.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
-function _null(params) {
-  return core._null(ZodNull, params);
-}
-const ZodAny = /* @__PURE__ */ core.$constructor("ZodAny", (inst, def) => {
-  const coreInit = core.$ZodAny.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
-function any() {
-  return core._any(ZodAny);
-}
-const ZodUnknown = /* @__PURE__ */ core.$constructor(
-  "ZodUnknown",
-  (inst, def) => {
-    const coreInit = core.$ZodUnknown.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function unknown() {
-  return core._unknown(ZodUnknown);
-}
-const ZodNever = /* @__PURE__ */ core.$constructor(
-  "ZodNever",
-  (inst, def) => {
-    const coreInit = core.$ZodNever.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function never(params) {
-  return core._never(ZodNever, params);
-}
-const ZodVoid = /* @__PURE__ */ core.$constructor("ZodVoid", (inst, def) => {
-  const coreInit = core.$ZodVoid.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
-function _void(params) {
-  return core._void(ZodVoid, params);
-}
-const ZodDate = /* @__PURE__ */ core.$constructor("ZodDate", (inst, def) => {
-  const coreInit = core.$ZodDate.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.min = (value, params) => inst.check(_gte(value, params));
-  inst.max = (value, params) => inst.check(_lte(value, params));
-  const c = inst._zod.bag;
-  inst.minDate = c.minimum ? new Date(c.minimum) : null;
-  inst.maxDate = c.maximum ? new Date(c.maximum) : null;
-});
-function date(params) {
-  return core._date(ZodDate, params);
-}
-const ZodArray = /* @__PURE__ */ core.$constructor(
-  "ZodArray",
-  (inst, def) => {
-    const coreInit = core.$ZodArray.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.element = def.element;
-    inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
-    inst.nonempty = (params) => inst.check(_minLength(1, params));
-    inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
-    inst.length = (len, params) => inst.check(_length(len, params));
-    inst.unwrap = () => inst.element;
-  }
-);
-function array(element, params) {
-  return core._array(ZodArray, element, params);
-}
-function keyof(schema) {
-  const shape = schema._zod.def.shape;
-  return _enum(Object.keys(shape));
-}
-const ZodIntersection = /* @__PURE__ */ core.$constructor(
-  "ZodIntersection",
-  (inst, def) => {
-    const coreInit = core.$ZodIntersection.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function intersection(left, right) {
-  return new ZodIntersection({
-    type: "intersection",
-    left,
-    right
-  });
-}
-const ZodTuple = /* @__PURE__ */ core.$constructor(
-  "ZodTuple",
-  (inst, def) => {
-    const coreInit = core.$ZodTuple.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.rest = (rest) => inst.clone({
-      ...inst._zod.def,
-      rest
-    });
-  }
-);
-function tuple(items, _paramsOrRest, _params) {
-  const hasRest = _paramsOrRest instanceof core.$ZodType;
-  const params = hasRest ? _params : _paramsOrRest;
-  const rest = hasRest ? _paramsOrRest : null;
-  return new ZodTuple({
-    type: "tuple",
-    items,
-    rest,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodRecord = /* @__PURE__ */ core.$constructor(
-  "ZodRecord",
-  (inst, def) => {
-    const coreInit = core.$ZodRecord.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.keyType = def.keyType;
-    inst.valueType = def.valueType;
-  }
-);
-function record(keyType, valueType, params) {
-  return new ZodRecord({
-    type: "record",
-    keyType,
-    valueType,
-    ...util.normalizeParams(params)
-  });
-}
-function partialRecord(keyType, valueType, params) {
-  const k = core.clone(keyType);
-  k._zod.values = void 0;
-  return new ZodRecord({
-    type: "record",
-    keyType: k,
-    valueType,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodMap = /* @__PURE__ */ core.$constructor("ZodMap", (inst, def) => {
-  const coreInit = core.$ZodMap.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.keyType = def.keyType;
-  inst.valueType = def.valueType;
-});
-function map(keyType, valueType, params) {
-  return new ZodMap({
-    type: "map",
-    keyType,
-    valueType,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodSet = /* @__PURE__ */ core.$constructor("ZodSet", (inst, def) => {
-  const coreInit = core.$ZodSet.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.min = (...args) => inst.check(core._minSize(...args));
-  inst.nonempty = (params) => inst.check(core._minSize(1, params));
-  inst.max = (...args) => inst.check(core._maxSize(...args));
-  inst.size = (...args) => inst.check(core._size(...args));
-});
-function set(valueType, params) {
-  return new ZodSet({
-    type: "set",
-    valueType,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodEnum = /* @__PURE__ */ core.$constructor("ZodEnum", (inst, def) => {
-  const coreInit = core.$ZodEnum.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.enum = def.entries;
-  inst.options = Object.values(def.entries);
-  const keys = new Set(Object.keys(def.entries));
-  inst.extract = (values, params) => {
-    const newEntries = {};
-    for (const value of values) {
-      if (keys.has(value)) {
-        newEntries[value] = def.entries[value];
-      } else throw new Error(`Key ${value} not found in enum`);
-    }
-    return new ZodEnum({
-      ...def,
-      checks: [],
-      ...util.normalizeParams(params),
-      entries: newEntries
-    });
-  };
-  inst.exclude = (values, params) => {
-    const newEntries = { ...def.entries };
-    for (const value of values) {
-      if (keys.has(value)) {
-        delete newEntries[value];
-      } else throw new Error(`Key ${value} not found in enum`);
-    }
-    return new ZodEnum({
-      ...def,
-      checks: [],
-      ...util.normalizeParams(params),
-      entries: newEntries
-    });
-  };
-});
-function _enum(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
-  return new ZodEnum({
-    type: "enum",
-    entries,
-    ...util.normalizeParams(params)
-  });
-}
-function nativeEnum(entries, params) {
-  return new ZodEnum({
-    type: "enum",
-    entries,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodLiteral = /* @__PURE__ */ core.$constructor(
-  "ZodLiteral",
-  (inst, def) => {
-    const coreInit = core.$ZodLiteral.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.values = new Set(def.values);
-    Object.defineProperty(inst, "value", {
-      get() {
-        if (def.values.length > 1) {
-          throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
-        }
-        return def.values[0];
-      }
-    });
-  }
-);
-function literal(value, params) {
-  return new ZodLiteral({
-    type: "literal",
-    values: Array.isArray(value) ? value : [value],
-    ...util.normalizeParams(params)
-  });
-}
-const ZodFile = /* @__PURE__ */ core.$constructor("ZodFile", (inst, def) => {
-  const coreInit = core.$ZodFile.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.min = (size, params) => inst.check(core._minSize(size, params));
-  inst.max = (size, params) => inst.check(core._maxSize(size, params));
-  inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
-});
-function file(params) {
-  return core._file(ZodFile, params);
-}
-const ZodTransform = /* @__PURE__ */ core.$constructor(
-  "ZodTransform",
-  (inst, def) => {
-    const coreInit = core.$ZodTransform.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst._zod.parse = (payload, _ctx) => {
-      if (_ctx.direction === "backward") {
-        throw new core.$ZodEncodeError(inst.constructor.name);
-      }
-      payload.addIssue = (issue) => {
-        if (typeof issue === "string") {
-          payload.issues.push(util.issue(issue, payload.value, def));
-        } else {
-          const _issue = issue;
-          if (_issue.fatal) _issue.continue = false;
-          _issue.code ??= "custom";
-          _issue.input ??= payload.value;
-          _issue.inst ??= inst;
-          payload.issues.push(util.issue(_issue));
-        }
-      };
-      const output = def.transform(payload.value, payload);
-      if (output instanceof Promise) {
-        return output.then((output2) => {
-          payload.value = output2;
-          return payload;
-        });
-      }
-      payload.value = output;
-      return payload;
-    };
-  }
-);
-function transform(fn) {
-  return new ZodTransform({
-    type: "transform",
-    transform: fn
-  });
-}
-const ZodOptional = /* @__PURE__ */ core.$constructor(
-  "ZodOptional",
-  (inst, def) => {
-    const coreInit = core.$ZodOptional.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function optional(innerType) {
-  return new ZodOptional({
-    type: "optional",
-    innerType
-  });
-}
-const ZodNullable = /* @__PURE__ */ core.$constructor(
-  "ZodNullable",
-  (inst, def) => {
-    const coreInit = core.$ZodNullable.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function nullable(innerType) {
-  return new ZodNullable({
-    type: "nullable",
-    innerType
-  });
-}
-function nullish(innerType) {
-  return optional(nullable(innerType));
-}
-const ZodDefault = /* @__PURE__ */ core.$constructor(
-  "ZodDefault",
-  (inst, def) => {
-    const coreInit = core.$ZodDefault.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-    inst.removeDefault = inst.unwrap;
-  }
-);
-function _default(innerType, defaultValue) {
-  return new ZodDefault({
-    type: "default",
-    innerType,
-    get defaultValue() {
-      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
-    }
-  });
-}
-const ZodPrefault = /* @__PURE__ */ core.$constructor(
-  "ZodPrefault",
-  (inst, def) => {
-    const coreInit = core.$ZodPrefault.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function prefault(innerType, defaultValue) {
-  return new ZodPrefault({
-    type: "prefault",
-    innerType,
-    get defaultValue() {
-      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
-    }
-  });
-}
-const ZodNonOptional = /* @__PURE__ */ core.$constructor(
-  "ZodNonOptional",
-  (inst, def) => {
-    const coreInit = core.$ZodNonOptional.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function nonoptional(innerType, params) {
-  return new ZodNonOptional({
-    type: "nonoptional",
-    innerType,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodSuccess = /* @__PURE__ */ core.$constructor(
-  "ZodSuccess",
-  (inst, def) => {
-    const coreInit = core.$ZodSuccess.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function success(innerType) {
-  return new ZodSuccess({
-    type: "success",
-    innerType
-  });
-}
-const ZodCatch = /* @__PURE__ */ core.$constructor(
-  "ZodCatch",
-  (inst, def) => {
-    const coreInit = core.$ZodCatch.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-    inst.removeCatch = inst.unwrap;
-  }
-);
-function _catch(innerType, catchValue) {
-  return new ZodCatch({
-    type: "catch",
-    innerType,
-    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
-  });
-}
-const ZodNaN = /* @__PURE__ */ core.$constructor("ZodNaN", (inst, def) => {
-  const coreInit = core.$ZodNaN.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
-function nan(params) {
-  return core._nan(ZodNaN, params);
-}
-const ZodPipe = /* @__PURE__ */ core.$constructor("ZodPipe", (inst, def) => {
-  const coreInit = core.$ZodPipe.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.in = def.in;
-  inst.out = def.out;
-});
-function pipe(in_, out) {
-  return new ZodPipe({
-    type: "pipe",
-    in: in_,
-    out
-    // ...util.normalizeParams(params),
-  });
-}
-const ZodCodec = /* @__PURE__ */ core.$constructor(
-  "ZodCodec",
-  (inst, def) => {
-    ZodPipe.init(inst, def);
-    const coreInit = core.$ZodCodec.init;
-    coreInit(inst, def);
-  }
-);
-function codec(in_, out, params) {
-  return new ZodCodec({
-    type: "pipe",
-    in: in_,
-    out,
-    transform: params.decode,
-    reverseTransform: params.encode
-  });
-}
-const ZodReadonly = /* @__PURE__ */ core.$constructor(
-  "ZodReadonly",
-  (inst, def) => {
-    const coreInit = core.$ZodReadonly.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function readonly(innerType) {
-  return new ZodReadonly({
-    type: "readonly",
-    innerType
-  });
-}
-const ZodTemplateLiteral = /* @__PURE__ */ core.$constructor(
-  "ZodTemplateLiteral",
-  (inst, def) => {
-    const coreInit = core.$ZodTemplateLiteral.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function templateLiteral(parts, params) {
-  return new ZodTemplateLiteral({
-    type: "template_literal",
-    parts,
-    ...util.normalizeParams(params)
-  });
-}
-const ZodLazy = /* @__PURE__ */ core.$constructor("ZodLazy", (inst, def) => {
-  const coreInit = core.$ZodLazy.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.unwrap = () => inst._zod.def.getter();
-});
-function lazy(getter) {
-  return new ZodLazy({
-    type: "lazy",
-    getter
-  });
-}
-const ZodPromise = /* @__PURE__ */ core.$constructor(
-  "ZodPromise",
-  (inst, def) => {
-    const coreInit = core.$ZodPromise.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-    inst.unwrap = () => inst._zod.def.innerType;
-  }
-);
-function promise(innerType) {
-  return new ZodPromise({
-    type: "promise",
-    innerType
-  });
-}
-const ZodFunction = /* @__PURE__ */ core.$constructor(
-  "ZodFunction",
-  (inst, def) => {
-    const coreInit = core.$ZodFunction.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function _function(params) {
-  return new ZodFunction({
-    type: "function",
-    input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
-    output: params?.output ?? unknown()
-  });
-}
-const ZodCustom = /* @__PURE__ */ core.$constructor(
-  "ZodCustom",
-  (inst, def) => {
-    const coreInit = core.$ZodCustom.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
-function check(fn) {
-  const ch = new core.$ZodCheck({
-    check: "custom"
-    // ...util.normalizeParams(params),
-  });
-  ch._zod.check = fn;
-  return ch;
-}
-function custom(fn, _params) {
-  return core._custom(ZodCustom, fn ?? (() => true), _params);
-}
-function refine(fn, _params = {}) {
-  return core._refine(ZodCustom, fn, _params);
-}
-function superRefine(fn) {
-  return core._superRefine(fn);
-}
-function _instanceof(cls, params = {
-  error: `Input not instance of ${cls.name}`
-}) {
-  const inst = new ZodCustom({
-    type: "custom",
-    check: "custom",
-    fn: (data) => data instanceof cls,
-    abort: true,
-    ...util.normalizeParams(params)
-  });
-  inst._zod.bag.Class = cls;
-  return inst;
-}
-const stringbool = (...args) => core._stringbool(
-  {
-    Codec: ZodCodec,
-    Boolean: ZodBoolean,
-    String: ZodString
-  },
-  ...args
-);
-function json(params) {
-  const jsonSchema = lazy(() => {
-    return union([
-      string(params),
-      number(),
-      boolean(),
-      _null(),
-      array(jsonSchema),
-      record(string(), jsonSchema)
-    ]);
-  });
-  return jsonSchema;
-}
-function preprocess(fn, schema) {
-  return pipe(transform(fn), schema);
-}
-
-const fullSchema_ = {
-  __proto__: null,
-  KrustyType: KrustyType,
-  ZodAny: ZodAny,
-  ZodArray: ZodArray,
-  ZodBase64: ZodBase64,
-  ZodBase64URL: ZodBase64URL,
-  ZodBigInt: ZodBigInt,
-  ZodBigIntFormat: ZodBigIntFormat,
-  ZodBoolean: ZodBoolean,
-  ZodCIDRv4: ZodCIDRv4,
-  ZodCIDRv6: ZodCIDRv6,
-  ZodCUID: ZodCUID,
-  ZodCUID2: ZodCUID2,
-  ZodCatch: ZodCatch,
-  ZodCodec: ZodCodec,
-  ZodCustom: ZodCustom,
-  ZodCustomStringFormat: ZodCustomStringFormat,
-  ZodDate: ZodDate,
-  ZodDefault: ZodDefault,
-  ZodDiscriminatedUnion: ZodDiscriminatedUnion,
-  ZodE164: ZodE164,
-  ZodEmail: ZodEmail,
-  ZodEmoji: ZodEmoji,
-  ZodEnum: ZodEnum,
-  ZodFile: ZodFile,
-  ZodFunction: ZodFunction,
-  ZodGUID: ZodGUID,
-  ZodGate: ZodGate,
-  ZodIPv4: ZodIPv4,
-  ZodIPv6: ZodIPv6,
-  ZodIntersection: ZodIntersection,
-  ZodJWT: ZodJWT,
-  ZodKSUID: ZodKSUID,
-  ZodLazy: ZodLazy,
-  ZodLiteral: ZodLiteral,
-  ZodMap: ZodMap,
-  ZodNaN: ZodNaN,
-  ZodNanoID: ZodNanoID,
-  ZodNever: ZodNever,
-  ZodNonOptional: ZodNonOptional,
-  ZodNull: ZodNull,
-  ZodNullable: ZodNullable,
-  ZodNumber: ZodNumber,
-  ZodNumberFormat: ZodNumberFormat,
-  ZodObject: ZodObject,
-  ZodOptional: ZodOptional,
-  ZodPipe: ZodPipe,
-  ZodPrefault: ZodPrefault,
-  ZodPromise: ZodPromise,
-  ZodReadonly: ZodReadonly,
-  ZodRecord: ZodRecord,
-  ZodSet: ZodSet,
-  ZodString: ZodString,
-  ZodStringFormat: ZodStringFormat,
-  ZodSuccess: ZodSuccess,
-  ZodSymbol: ZodSymbol,
-  ZodTemplateLiteral: ZodTemplateLiteral,
-  ZodTransform: ZodTransform,
-  ZodTuple: ZodTuple,
-  ZodULID: ZodULID,
-  ZodURL: ZodURL,
-  ZodUUID: ZodUUID,
-  ZodUndefined: ZodUndefined,
-  ZodUnion: ZodUnion,
-  ZodUnknown: ZodUnknown,
-  ZodVoid: ZodVoid,
-  ZodXID: ZodXID,
-  _ZodString: _ZodString,
-  _default: _default,
-  _function: _function,
-  any: any,
-  array: array,
-  base64: base64,
-  base64url: base64url,
-  bigint: bigint,
-  boolean: boolean,
-  catch: _catch,
-  check: check,
-  cidrv4: cidrv4,
-  cidrv6: cidrv6,
-  codec: codec,
-  cuid: cuid,
-  cuid2: cuid2,
-  custom: custom,
-  date: date,
-  discriminatedUnion: discriminatedUnion,
-  e164: e164,
-  email: email,
-  emoji: emoji,
-  enum: _enum,
-  file: file,
-  float32: float32,
-  float64: float64,
-  function: _function,
-  gate: gate,
-  gatingContext: gatingContext,
-  guid: guid,
-  hash: hash,
-  hex: hex,
-  hostname: hostname,
-  httpUrl: httpUrl,
-  instanceof: _instanceof,
-  int: int,
-  int32: int32,
-  int64: int64,
-  intersection: intersection,
-  ipv4: ipv4,
-  ipv6: ipv6,
-  isGateIssue: isGateIssue,
-  isGateIssueRaw: isGateIssueRaw,
-  json: json,
-  jwt: jwt,
-  keyof: keyof,
-  ksuid: ksuid,
-  lazy: lazy,
-  literal: literal,
-  looseObject: looseObject,
-  map: map,
-  nan: nan,
-  nanoid: nanoid,
-  nativeEnum: nativeEnum,
-  never: never,
-  nonoptional: nonoptional,
-  null: _null,
-  nullable: nullable,
-  nullish: nullish,
-  number: number,
-  object: object,
-  optional: optional,
-  partialRecord: partialRecord,
-  pipe: pipe,
-  prefault: prefault,
-  preprocess: preprocess,
-  promise: promise,
-  readonly: readonly,
-  record: record,
-  refine: refine,
-  set: set,
-  strictObject: strictObject,
-  string: string,
-  stringFormat: stringFormat,
-  stringbool: stringbool,
-  success: success,
-  superRefine: superRefine,
-  symbol: symbol,
-  templateLiteral: templateLiteral,
-  transform: transform,
-  tuple: tuple,
-  uint32: uint32,
-  uint64: uint64,
-  ulid: ulid,
-  undefined: _undefined,
-  union: union,
-  unknown: unknown,
-  url: url,
-  uuid: uuid,
-  uuidv4: uuidv4,
-  uuidv6: uuidv6,
-  uuidv7: uuidv7,
-  void: _void,
-  xid: xid
-};
-
 class ProcedureBuilder extends ContractProcedure {
+  z;
   constructor(def) {
     super(def);
+    this.z = new SchemaClass();
   }
   /**
    * Adds type-safe custom errors to the contract.
@@ -1894,20 +65,39 @@ class ProcedureBuilder extends ContractProcedure {
    * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
    */
   route(route) {
+    const { prefix } = this["~orpc"];
     return new ProcedureBuilder({
       ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
+      route: mergeRoute(this["~orpc"].route, prefix ? prefixRoute(route, prefix) : route)
     });
   }
-  /**
-   * Defines the input validation schema.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Input Validation Docs}
-   */
-  input(schema) {
+  path(schema) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      schemas: {
+        ...this["~orpc"].schemas,
+        pathSchema: schema
+      },
+      inputValidationIndex: this["~orpc"].middlewares.length
+    });
+  }
+  query(schema) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      schemas: {
+        ...this["~orpc"].schemas,
+        querySchema: schema
+      },
+      inputValidationIndex: this["~orpc"].middlewares.length
+    });
+  }
+  body(schema) {
     return new ProcedureBuilder({
       ...this["~orpc"],
-      inputSchema: schema,
+      schemas: {
+        ...this["~orpc"].schemas,
+        bodySchema: schema
+      },
       inputValidationIndex: this["~orpc"].middlewares.length
     });
   }
@@ -1919,7 +109,10 @@ class ProcedureBuilder extends ContractProcedure {
   output(schema) {
     return new ProcedureBuilder({
       ...this["~orpc"],
-      outputSchema: schema,
+      schemas: {
+        ...this["~orpc"].schemas,
+        outputSchema: schema
+      },
       outputValidationIndex: this["~orpc"].middlewares.length
     });
   }
@@ -1991,34 +184,43 @@ class BuilderWithMiddlewares extends ProcedureBuilder {
   router(router) {
     return enhanceRouter(router, this["~orpc"]);
   }
-  /**
-   * Create a lazy router
-   * And applies all of the previously defined options to the specified router.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
-   */
-  lazyRoute(loader) {
-    return enhanceRouter(lazy$1(loader), this["~orpc"]);
-  }
 }
 
-const fullSchema = fullSchema_;
-const miniSchema = {
-  array: fullSchema.array,
-  boolean: fullSchema.boolean,
-  date: fullSchema.date,
-  number: fullSchema.number,
-  int: fullSchema.int,
-  string: fullSchema.string,
-  literal: fullSchema.literal,
-  enum: fullSchema.enum,
-  union: fullSchema.union,
-  discriminatedUnion: fullSchema.discriminatedUnion,
-  null: fullSchema.null,
-  record: fullSchema.record,
-  file: fullSchema.file,
-  object: fullSchema.object
-};
+function decorateMiddleware(middleware) {
+  const decorated = ((...args) => middleware(...args));
+  decorated.mapInput = (mapInput) => {
+    const mapped = decorateMiddleware(
+      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
+    );
+    return mapped;
+  };
+  decorated.concat = (concatMiddleware, mapInput) => {
+    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+    const concatted = decorateMiddleware((options, input, output, ...rest) => {
+      const merged = middleware(
+        {
+          ...options,
+          next: (...[nextOptions1]) => mapped(
+            {
+              ...options,
+              context: { ...options.context, ...nextOptions1?.context },
+              next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
+            },
+            input,
+            output,
+            ...rest
+          )
+        },
+        input,
+        output,
+        ...rest
+      );
+      return merged;
+    });
+    return concatted;
+  };
+  return decorated;
+}
 
 class Builder extends BuilderWithMiddlewares {
   /**
@@ -2039,7 +241,7 @@ class Builder extends BuilderWithMiddlewares {
   }
 }
 function createApiBuilder(opts = {}) {
-  const base = new Builder({
+  return new Builder({
     route: {},
     meta: opts.meta ?? {},
     errorMap: {},
@@ -2050,11 +252,11 @@ function createApiBuilder(opts = {}) {
         console.dir(error, { depth: null });
       })
     ],
+    schemas: initialSchemas,
     // NB: this is a relic from orpc -- I'm not convinced there's a need for this (or if there is, that it's
     // the best solution). For now I've removed the interface to configure it externally.
     dedupeLeadingMiddlewares: true
   });
-  return Object.assign(base, miniSchema, { z: fullSchema });
 }
 const os = createApiBuilder();
 
@@ -2092,17 +294,6 @@ function implementerInternal(contract, middlewares) {
           });
           return setHiddenRouterContract(adapted, contract);
         };
-      } else if (key === "lazyRoute") {
-        method = (loader) => {
-          const adapted = enhanceRouter(lazy$1(loader), {
-            middlewares,
-            errorMap: {},
-            prefix: void 0,
-            tags: void 0,
-            dedupeLeadingMiddlewares: true
-          });
-          return setHiddenRouterContract(adapted, contract);
-        };
       }
       const next = getContractRouter(target, [key]);
       if (!next) {
@@ -2144,7 +335,7 @@ function implement(contract) {
 }
 
 function createAssertedLazyProcedure(lazied) {
-  const lazyProcedure = lazy$1(async () => {
+  const lazyProcedure = lazyInternal(async () => {
     const { default: maybeProcedure } = await unlazy(lazied);
     if (!isProcedure(maybeProcedure)) {
       throw new Error(`
@@ -2195,4 +386,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, BuilderWithMiddlewares, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createAccessibleLazyRouter, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getHiddenRouterContract, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, isStartWithMiddlewares, lazy$1 as lazy, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazy, unlazyRouter };
+export { Builder, BuilderWithMiddlewares, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, lazyInternal, os, setHiddenRouterContract, unlazy };