@temporary-name/server 1.9.3-alpha.6ef4729e23affbe6454d37025d1dfc4d998b0649 → 1.9.3-alpha.70ac9623e5fa2a8af7954e34ef97cee968e5cad9

package/dist/index.mjs

@@ -1,137 +1,82 @@
-import { isContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, enhanceRoute, mergeTags, getContractRouter } from '@temporary-name/contract';
-export { ValidationError, eventIterator, type, 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 { g as gatingContext } from './shared/server.D6K9uoPI.mjs';
-import { c as createProcedureClient, i as isLazy, g as getLazyMeta, l as lazy, u as unlazy } from './shared/server.BEQrAa3A.mjs';
-export { L as LAZY_SYMBOL, a as createORPCErrorConstructorMap, m as mergeCurrentContext, b as middlewareOutputFn } from './shared/server.BEQrAa3A.mjs';
+import { assertNever, splitFirst, onError, isObject, toArray, guard, resolveMaybeOptionalOptions, isTypescriptObject, isPropertyKey } from '@temporary-name/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+import { SchemaClass, object, core, gatingContext } from '@temporary-name/zod';
+export { z as baseZ };
+import { U as UnauthorizedError, P as Procedure, m as mergePrefix, a as mergeTags, b as enhanceRouter, C as Contract, p as parseEndpointDefinition, c as mergeRoute, d as prefixRoute, f as addMiddleware, l as lazyInternal, h as getLazyMeta, u as unlazy, j as isProcedure } from './shared/server.X8F6e8eV.mjs';
+export { A as APIError, B as BadRequestError, F as ForbiddenError, I as InternalServerError, L as LAZY_SYMBOL, N as NotFoundError, V as ValidationError, x as createAccessibleLazyRouter, e as encodeError, D as endpointRegex, g as getDynamicParams, w as getRouter, i as isAPIErrorStatus, E as isDevelopment, o as isLazy, q as isStartWithMiddlewares, n as lazy, k as makeErrors, v as mergeMiddlewares, r as resolveContractProcedures, s as standardizeHTTPPath, t as toAPIError, y as traverseContractProcedures, z as unlazyRouter } from './shared/server.X8F6e8eV.mjs';
+import { g as getCookie } from './shared/server.C1RJffw4.mjs';
+import { c as createProcedureClient } from './shared/server.CmNVzZVe.mjs';
+export { m as mergeCurrentContext, a as middlewareOutputFn } from './shared/server.CmNVzZVe.mjs';
+import { J as JsonSchemaXNativeType } from './shared/server.BM9lK_Yv.mjs';
+export { b as JSON_SCHEMA_INPUT_REGISTRY, c as JSON_SCHEMA_OUTPUT_REGISTRY, a as JSON_SCHEMA_REGISTRY, Z as ZodToJsonSchemaConverter, e as eventIterator, g as getEventIteratorSchemaDetails } from './shared/server.BM9lK_Yv.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
-import 'node:async_hooks';
-import 'zod';
+import 'cookie';
+import '@temporary-name/server/openapi';
 import 'zod/v4/core';
 
-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;
-}
-
-function isStartWithMiddlewares(middlewares, compare) {
-  if (compare.length > middlewares.length) {
-    return false;
+function validateTokenPrefix(prefix, token) {
+  if (prefix && !token.startsWith(prefix)) {
+    throw new UnauthorizedError({ message: `Invalid auth token. It must start with "${prefix}"` });
   }
-  for (let i = 0; i < middlewares.length; i++) {
-    if (compare[i] === void 0) {
-      return true;
+}
+function validateTokenAuth(config, token, options) {
+  const { tokenPrefix, validate } = config;
+  validateTokenPrefix(tokenPrefix, token);
+  return validate(token, options);
+}
+function runAuth(config, options) {
+  switch (config.type) {
+    case "header": {
+      const authHeader = options.request.headers.get(config.name);
+      return authHeader ? validateTokenAuth(config, authHeader, options) : void 0;
+    }
+    case "query": {
+      const { name, tokenPrefix, validate } = config;
+      const query = options.request.url.searchParams;
+      const token = query.get(name);
+      if (!token) return void 0;
+      validateTokenPrefix(tokenPrefix, token);
+      return validate(token, options);
+    }
+    case "cookie": {
+      const cookie = getCookie(options.request.headers, config.name);
+      return cookie ? validateTokenAuth(config, cookie, options) : void 0;
+    }
+    case "bearer": {
+      const authHeader = options.request.headers.get("Authorization");
+      if (!authHeader) return void 0;
+      const [authType, bearer] = splitFirst(authHeader, " ");
+      return authType === "Bearer" ? validateTokenAuth(config, bearer, options) : void 0;
+    }
+    case "basic": {
+      const authHeader = options.request.headers.get("Authorization");
+      if (!authHeader) return void 0;
+      const [authType, encoded] = splitFirst(authHeader, " ");
+      if (authType !== "Basic") return void 0;
+      const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+      const [username, password] = splitFirst(decoded, ":");
+      validateTokenPrefix(config.tokenPrefix, password);
+      return config.validate(username, password, options);
     }
-    if (middlewares[i] !== compare[i]) {
+    case "none": {
       return false;
     }
+    default: {
+      assertNever(config);
+    }
   }
-  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 authDescription(config) {
+  const { type } = config;
+  return type === "basic" ? "a Basic Authentication header" : type === "bearer" ? "a Bearer Authentication header" : type === "header" ? `a header named "${config.name}"` : type === "query" ? `a query parameter named "${config.name}"` : type === "cookie" ? `a cookie named "${config.name}"` : type === "none" ? "no authentication" : assertNever(type);
 }
 
-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"];
+function mergeMeta(meta1, meta2) {
+  return { ...meta1, ...meta2 };
 }
 
 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).
    *
@@ -150,244 +95,76 @@ 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(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(
-      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 initialSchemas = {
+  pathSchema: z.strictObject({}),
+  querySchema: z.strictObject({}),
+  bodySchema: z.strictObject({}),
+  outputSchema: z.unknown()
+};
 
-class Builder {
-  /**
-   * This property holds the defined options.
-   */
-  "~orpc";
+class ProcedureBuilder extends Contract {
+  z;
   constructor(def) {
-    this["~orpc"] = def;
+    super(def);
+    this.z = new SchemaClass();
   }
   /**
-   * 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);
-  }
-  /**
-   * 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 Builder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-  }
-  /**
-   * 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 Builder({
-      ...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 } })
-      );
-    });
-  }
-  /**
-   * Sets or updates the metadata.
-   * The provided metadata is spared-merged with any existing metadata.
+   * 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 Builder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
+  endpoint(stringsOrEndpoint, ...values) {
+    const { method, path, pathSchema } = parseEndpointDefinition(stringsOrEndpoint, values);
+    const { prefix } = this["~orpc"];
+    const route = { method, path };
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      route: mergeRoute(this["~orpc"].route, prefix ? prefixRoute(route, prefix) : route),
+      schemas: {
+        ...this["~orpc"].schemas,
+        pathSchema
+      }
+    });
+  }
   /**
-   * Sets or updates the route definition.
-   * The provided route is spared-merged with any existing route.
+   * 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) {
-    return new Builder({
+  endpointOpts(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) {
-    return new Builder({
+  query(schema) {
+    return new ProcedureBuilder({
       ...this["~orpc"],
-      inputSchema: schema,
+      schemas: {
+        ...this["~orpc"].schemas,
+        querySchema: schema instanceof core.$ZodType ? schema : object(schema)
+      },
+      inputValidationIndex: this["~orpc"].middlewares.length
+    });
+  }
+  body(schema) {
+    return new ProcedureBuilder({
+      ...this["~orpc"],
+      schemas: {
+        ...this["~orpc"].schemas,
+        bodySchema: schema instanceof core.$ZodType ? schema : object(schema)
+      },
       inputValidationIndex: this["~orpc"].middlewares.length
     });
   }
@@ -397,23 +174,79 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
    */
   output(schema) {
-    return new Builder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
-      outputSchema: schema,
+      schemas: {
+        ...this["~orpc"].schemas,
+        outputSchema: schema instanceof core.$ZodType ? schema : object(schema)
+      },
       outputValidationIndex: this["~orpc"].middlewares.length
     });
   }
+  use(middleware) {
+    return new this.constructor({
+      ...this["~orpc"],
+      middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
+    });
+  }
+  useErrors(errorMap) {
+    return new this.constructor({
+      ...this["~orpc"],
+      errorMap
+    });
+  }
+  // The default of false for ValidatedAuthContext is used when you pass in the type 'none'. We use false
+  // because we can't use null or undefined (see ValidatedAuthContext) but we still want it to be falsy.
+  useAuth(config) {
+    const middleware = baseApi.$context().middleware(async (options) => {
+      const { next, context } = options;
+      if (context.auth) return next();
+      const auth = await runAuth(config, options);
+      if (auth === void 0) {
+        const { authConfigs } = options.procedure["~orpc"];
+        if (context.auth !== false && config === authConfigs.at(-1)) {
+          let authDescriptions = authConfigs.map(authDescription).join(", ");
+          if (authConfigs.length > 1) {
+            authDescriptions = `one of: ${authDescriptions}`;
+          }
+          throw new UnauthorizedError({
+            message: `Authentication required. You must provide ${authDescriptions}`
+          });
+        }
+        return next();
+      }
+      return next({ context: { auth } });
+    });
+    return new this.constructor({
+      ...this["~orpc"],
+      authConfigs: [...this["~orpc"].authConfigs, config],
+      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) {
+    if (this["~orpc"].schemas.outputSchema === initialSchemas.outputSchema) {
+      throw new Error("You must call .output() before calling .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.
@@ -423,7 +256,7 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
    */
   prefix(prefix) {
-    return new Builder({
+    return new this.constructor({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
@@ -435,7 +268,7 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
    */
   tag(...tags) {
-    return new Builder({
+    return new this.constructor({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
@@ -448,123 +281,383 @@ class Builder {
   router(router) {
     return enhanceRouter(router, this["~orpc"]);
   }
+}
+
+function decorateMiddleware(middleware) {
+  const decorated = ((...args) => middleware(...args));
+  decorated.mapInput = (mapInput) => {
+    const mapped = decorateMiddleware(
+      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
+    );
+    return mapped;
+  };
+  return decorated;
+}
+
+class Builder extends BuilderWithMiddlewares {
   /**
-   * Create a lazy router
-   * And applies all of the previously defined options to the specified router.
+   * Set or override the initial context.
    *
-   * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+   * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
    */
-  lazyRoute(loader) {
-    return enhanceRouter(lazy(loader), this["~orpc"]);
+  $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 base;
-}
-const os = createApiBuilder();
+const baseApi = new Builder({
+  route: {},
+  meta: {},
+  errorMap: {},
+  inputValidationIndex: 0,
+  outputValidationIndex: 0,
+  middlewares: [
+    onError((error, _options) => {
+      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,
+  authConfigs: []
+});
 
-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(loader), {
-            middlewares,
-            errorMap: {},
-            prefix: void 0,
-            tags: void 0,
-            dedupeLeadingMiddlewares: true
-          });
-          return setHiddenRouterContract(adapted, contract);
-        };
+const FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;
+class experimental_JsonSchemaCoercer {
+  coerce(schema, value, options = {}) {
+    const [, coerced] = this.#coerce(schema, value, options);
+    return coerced;
+  }
+  #coerce(schema, originalValue, options) {
+    if (typeof schema === "boolean") {
+      return [schema, originalValue];
+    }
+    if (Array.isArray(schema.type)) {
+      return this.#coerce(
+        {
+          anyOf: schema.type.map((type) => ({ ...schema, type }))
+        },
+        originalValue,
+        options
+      );
+    }
+    let coerced = originalValue;
+    let satisfied = true;
+    if (typeof schema.$ref === "string") {
+      const refSchema = options?.components?.[schema.$ref];
+      if (refSchema !== void 0) {
+        const [subSatisfied, subCoerced] = this.#coerce(refSchema, coerced, options);
+        coerced = subCoerced;
+        satisfied = subSatisfied;
       }
-      const next = getContractRouter(target, [key]);
-      if (!next) {
-        return method ?? next;
+    }
+    const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;
+    if (enumValues !== void 0 && !enumValues.includes(coerced)) {
+      if (typeof coerced === "string") {
+        const numberValue = this.#stringToNumber(coerced);
+        if (enumValues.includes(numberValue)) {
+          coerced = numberValue;
+        } else {
+          const booleanValue = this.#stringToBoolean(coerced);
+          if (enumValues.includes(booleanValue)) {
+            coerced = booleanValue;
+          } else {
+            satisfied = false;
+          }
+        }
+      } else {
+        satisfied = false;
       }
-      const nextImpl = implementerInternal(next, middlewares);
-      if (method) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(nextImpl, key2);
+    }
+    if (typeof schema.type === "string") {
+      switch (schema.type) {
+        case "null": {
+          if (coerced !== null) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "string": {
+          if (typeof coerced !== "string") {
+            satisfied = false;
           }
-        });
+          break;
+        }
+        case "number": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToNumber(coerced);
+          }
+          if (typeof coerced !== "number") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "integer": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToInteger(coerced);
+          }
+          if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case "boolean": {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToBoolean(coerced);
+          }
+          if (typeof coerced !== "boolean") {
+            satisfied = false;
+          }
+          break;
+        }
+        case "array": {
+          if (Array.isArray(coerced)) {
+            const prefixItemSchemas = "prefixItems" in schema ? toArray(schema.prefixItems) : Array.isArray(schema.items) ? schema.items : [];
+            const itemSchema = Array.isArray(schema.items) ? schema.additionalItems : schema.items;
+            let shouldUseCoercedItems = false;
+            const coercedItems = coerced.map((item, i) => {
+              const subSchema = prefixItemSchemas[i] ?? itemSchema;
+              if (subSchema === void 0) {
+                satisfied = false;
+                return item;
+              }
+              const [subSatisfied, subCoerced] = this.#coerce(subSchema, item, options);
+              if (!subSatisfied) {
+                satisfied = false;
+              }
+              if (subCoerced !== item) {
+                shouldUseCoercedItems = true;
+              }
+              return subCoerced;
+            });
+            if (coercedItems.length < prefixItemSchemas.length) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
+        case "object": {
+          if (Array.isArray(coerced)) {
+            coerced = { ...coerced };
+          }
+          if (isObject(coerced)) {
+            let shouldUseCoercedItems = false;
+            const coercedItems = {};
+            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(
+              ([key, value]) => [new RegExp(key), value]
+            );
+            for (const key in coerced) {
+              const value = coerced[key];
+              const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
+              if (value === void 0 && !schema.required?.includes(key)) {
+                coercedItems[key] = value;
+              } else if (subSchema === void 0) {
+                coercedItems[key] = value;
+                satisfied = false;
+              } else {
+                const [subSatisfied, subCoerced] = this.#coerce(subSchema, value, options);
+                coercedItems[key] = subCoerced;
+                if (!subSatisfied) {
+                  satisfied = false;
+                }
+                if (subCoerced !== value) {
+                  shouldUseCoercedItems = true;
+                }
+              }
+            }
+            if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {
+              satisfied = false;
+            }
+            if (shouldUseCoercedItems) {
+              coerced = coercedItems;
+            }
+          } else {
+            satisfied = false;
+          }
+          break;
+        }
       }
-      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;
+    if ("x-native-type" in schema && typeof schema["x-native-type"] === "string") {
+      switch (schema["x-native-type"]) {
+        case JsonSchemaXNativeType.Date: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToDate(coerced);
+          }
+          if (!(coerced instanceof Date)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.BigInt: {
+          switch (typeof coerced) {
+            case "string":
+              coerced = this.#stringToBigInt(coerced);
+              break;
+            case "number":
+              coerced = this.#numberToBigInt(coerced);
+              break;
+          }
+          if (typeof coerced !== "bigint") {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.RegExp: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToRegExp(coerced);
+          }
+          if (!(coerced instanceof RegExp)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Url: {
+          if (typeof coerced === "string") {
+            coerced = this.#stringToURL(coerced);
+          }
+          if (!(coerced instanceof URL)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Set: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToSet(coerced);
+          }
+          if (!(coerced instanceof Set)) {
+            satisfied = false;
+          }
+          break;
+        }
+        case JsonSchemaXNativeType.Map: {
+          if (Array.isArray(coerced)) {
+            coerced = this.#arrayToMap(coerced);
+          }
+          if (!(coerced instanceof Map)) {
+            satisfied = false;
+          }
+          break;
+        }
       }
-      const next = Reflect.get(target, key);
-      if (!method || !next || typeof next !== "function" && typeof next !== "object") {
-        return method || next;
+    }
+    if (schema.allOf) {
+      for (const subSchema of schema.allOf) {
+        const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+        coerced = subCoerced;
+        if (!subSatisfied) {
+          satisfied = false;
+        }
       }
-      return new Proxy(method, {
-        get(_, key2) {
-          return Reflect.get(next, key2);
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+      if (schema[key]) {
+        let bestOptions;
+        for (const subSchema of schema[key]) {
+          const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+          if (subSatisfied) {
+            if (!bestOptions || subCoerced === coerced) {
+              bestOptions = { coerced: subCoerced, satisfied: subSatisfied };
+            }
+            if (subCoerced === coerced) {
+              break;
+            }
+          }
         }
-      });
+        coerced = bestOptions ? bestOptions.coerced : coerced;
+        satisfied = bestOptions ? bestOptions.satisfied : false;
+      }
+    }
+    if (typeof schema.not !== "undefined") {
+      const [notSatisfied] = this.#coerce(schema.not, coerced, options);
+      if (notSatisfied) {
+        satisfied = false;
+      }
+    }
+    return [satisfied, coerced];
+  }
+  #stringToNumber(value) {
+    const num = Number.parseFloat(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToInteger(value) {
+    const num = Number.parseInt(value);
+    if (Number.isNaN(num) || num !== Number(value)) {
+      return value;
+    }
+    return num;
+  }
+  #stringToBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === "false" || lower === "off") {
+      return false;
+    }
+    if (lower === "true" || lower === "on") {
+      return true;
+    }
+    return value;
+  }
+  #stringToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #numberToBigInt(value) {
+    return guard(() => BigInt(value)) ?? value;
+  }
+  #stringToDate(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
+      return value;
+    }
+    return date;
+  }
+  #stringToRegExp(value) {
+    const match = value.match(/^\/(.*)\/([a-z]*)$/);
+    if (match) {
+      const [, pattern, flags] = match;
+      return guard(() => new RegExp(pattern, flags)) ?? value;
     }
-  });
-  return impl;
+    return value;
+  }
+  #stringToURL(value) {
+    return guard(() => new URL(value)) ?? value;
+  }
+  #arrayToSet(value) {
+    const set = new Set(value);
+    if (set.size !== value.length) {
+      return value;
+    }
+    return set;
+  }
+  #arrayToMap(value) {
+    if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
+      return value;
+    }
+    const result = new Map(value);
+    if (result.size !== value.length) {
+      return value;
+    }
+    return result;
+  }
 }
 
 function createAssertedLazyProcedure(lazied) {
-  const lazyProcedure = lazy(async () => {
+  const lazyProcedure = lazyInternal(async () => {
     const { default: maybeProcedure } = await unlazy(lazied);
     if (!isProcedure(maybeProcedure)) {
       throw new Error(`
@@ -577,42 +670,26 @@ function createAssertedLazyProcedure(lazied) {
   }, 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]
-      });
+function isSchemaIssue(issue) {
+  if (!isTypescriptObject(issue) || typeof issue.message !== "string") {
+    return false;
+  }
+  if (issue.path !== void 0) {
+    if (!Array.isArray(issue.path)) {
+      return false;
     }
-  });
-  return recursive;
+    if (!issue.path.every(
+      (segment) => isPropertyKey(segment) || isTypescriptObject(segment) && isPropertyKey(segment.key)
+    )) {
+      return false;
+    }
+  }
+  return true;
 }
 
-export { Builder, DecoratedProcedure, Procedure, addMiddleware, call, createAccessibleLazyRouter, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getHiddenRouterContract, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, isStartWithMiddlewares, lazy, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazy, unlazyRouter };
+export { Builder, BuilderWithMiddlewares, Contract, DecoratedProcedure, JsonSchemaXNativeType, Procedure, ProcedureBuilder, UnauthorizedError, addMiddleware, baseApi, call, createAssertedLazyProcedure, createProcedureClient, decorateMiddleware, enhanceRouter, experimental_JsonSchemaCoercer, getLazyMeta, initialSchemas, isProcedure, isSchemaIssue, lazyInternal, mergeMeta, parseEndpointDefinition, unlazy };