@temporary-name/server 1.9.3-alpha.021f5c8fe9793dff332b025dce560e804c45a7b1

package/dist/index.mjs

@@ -0,0 +1,2199 @@
+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, prefixRoute, 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';
+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).
+   *
+   * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+   */
+  callable(...rest) {
+    const client = createProcedureClient(this, ...rest);
+    return new Proxy(client, {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
+    });
+  }
+}
+
+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 {
+  constructor(def) {
+    super(def);
+  }
+  /**
+   * Adds type-safe custom errors to the contract.
+   * The provided errors are spared-merged with any existing errors in the contract.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+   */
+  errors(errors) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+    });
+  }
+  /**
+   * Sets or updates the metadata for the contract.
+   * The provided metadata is spared-merged with any existing metadata in the contract.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
+   */
+  meta(meta) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      meta: mergeMeta(this["~orpc"].meta, meta)
+    });
+  }
+  /**
+   * Sets or updates the route definition for the contract.
+   * The provided route is spared-merged with any existing route in the contract.
+   * 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) {
+    const { prefix } = this["~orpc"];
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      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) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      inputSchema: schema,
+      inputValidationIndex: this["~orpc"].middlewares.length
+    });
+  }
+  /**
+   * Defines the output validation schema.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
+   */
+  output(schema) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      outputSchema: schema,
+      outputValidationIndex: this["~orpc"].middlewares.length
+    });
+  }
+  /**
+   * Uses a middleware to modify the context or improve the pipeline.
+   *
+   * @info Supports both normal middleware and inline middleware implementations.
+   * @note The current context must be satisfy middleware dependent-context
+   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+   */
+  use(middleware) {
+    return new this.constructor({
+      ...this["~orpc"],
+      middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
+    });
+  }
+  useGating(gates, isGateEnabled) {
+    return this.use(({ next, context }) => {
+      return gatingContext.run(
+        (gate) => isGateEnabled(gate, context),
+        () => next({ context: { isGateEnabled } })
+      );
+    });
+  }
+  /**
+   * Defines the handler of the procedure.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+   */
+  handler(handler) {
+    return new DecoratedProcedure({
+      ...this["~orpc"],
+      handler
+    });
+  }
+}
+class BuilderWithMiddlewares extends ProcedureBuilder {
+  /**
+   * Prefixes all procedures in the router.
+   * The provided prefix is post-appended to any existing router prefix.
+   *
+   * @note This option does not affect procedures that do not define a path in their route definition.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+   */
+  prefix(prefix) {
+    return new this.constructor({
+      ...this["~orpc"],
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
+    });
+  }
+  /**
+   * Adds tags to all procedures in the router.
+   * This helpful when you want to group procedures together in the OpenAPI specification.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+   */
+  tag(...tags) {
+    return new this.constructor({
+      ...this["~orpc"],
+      tags: mergeTags(this["~orpc"].tags, tags)
+    });
+  }
+  /**
+   * Applies all of the previously defined options to the specified router.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+   */
+  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
+};
+
+class Builder extends BuilderWithMiddlewares {
+  /**
+   * Set or override the initial context.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
+   */
+  $context() {
+    return this;
+  }
+  /**
+   * Creates a middleware.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+   */
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
+  }
+}
+function createApiBuilder(opts = {}) {
+  const base = new Builder({
+    route: {},
+    meta: opts.meta ?? {},
+    errorMap: {},
+    inputValidationIndex: 0,
+    outputValidationIndex: 0,
+    middlewares: [
+      onError((error, _options) => {
+        console.dir(error, { depth: null });
+      })
+    ],
+    // 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();
+
+function implementerInternal(contract, middlewares) {
+  if (isContractProcedure(contract)) {
+    const impl2 = new Builder({
+      ...contract["~orpc"],
+      middlewares,
+      inputValidationIndex: middlewares.length,
+      outputValidationIndex: middlewares.length,
+      dedupeLeadingMiddlewares: true
+    });
+    return impl2;
+  }
+  const impl = new Proxy(contract, {
+    get: (target, key) => {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      let method;
+      if (key === "middleware") {
+        method = (mid) => decorateMiddleware(mid);
+      } else if (key === "use") {
+        method = (mid) => {
+          return implementerInternal(contract, addMiddleware(middlewares, mid));
+        };
+      } else if (key === "router") {
+        method = (router) => {
+          const adapted = enhanceRouter(router, {
+            middlewares,
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0,
+            dedupeLeadingMiddlewares: true
+          });
+          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) {
+        return method ?? next;
+      }
+      const nextImpl = implementerInternal(next, middlewares);
+      if (method) {
+        return new Proxy(method, {
+          get(_, key2) {
+            return Reflect.get(nextImpl, key2);
+          }
+        });
+      }
+      return nextImpl;
+    }
+  });
+  return impl;
+}
+function implement(contract) {
+  const implInternal = implementerInternal(contract, []);
+  const impl = new Proxy(implInternal, {
+    get: (target, key) => {
+      let method;
+      if (key === "$context") {
+        method = () => impl;
+      }
+      const next = Reflect.get(target, key);
+      if (!method || !next || typeof next !== "function" && typeof next !== "object") {
+        return method || next;
+      }
+      return new Proxy(method, {
+        get(_, key2) {
+          return Reflect.get(next, key2);
+        }
+      });
+    }
+  });
+  return impl;
+}
+
+function createAssertedLazyProcedure(lazied) {
+  const lazyProcedure = lazy$1(async () => {
+    const { default: maybeProcedure } = await unlazy(lazied);
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  }, getLazyMeta(lazied));
+  return lazyProcedure;
+}
+function createContractedProcedure(procedure, contract) {
+  return new Procedure({
+    ...procedure["~orpc"],
+    errorMap: contract["~orpc"].errorMap,
+    route: contract["~orpc"].route,
+    meta: contract["~orpc"].meta
+  });
+}
+function call(procedure, input, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  return createProcedureClient(procedure, options)(input, options);
+}
+
+function createRouterClient(router, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, options);
+    return caller;
+  }
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
+  const recursive = new Proxy(procedureCaller, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(router, [key]);
+      if (!next) {
+        return Reflect.get(target, key);
+      }
+      return createRouterClient(next, {
+        ...rest[0],
+        path: [...rest[0]?.path ?? [], key]
+      });
+    }
+  });
+  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 };