@temporary-name/server 1.9.3-alpha.592ae1e02e18c5274906b132313b083116248636 → 1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e

package/dist/shared/{server.BKSOrA6h.d.ts → server.B5czSQQh.d.ts}

@@ -1,5 +1,5 @@
-import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@temporary-name/contract';
-import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, HTTPPath, Promisable, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, Schemas, Meta, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, AnySchema, ErrorFromErrorMap } from '@temporary-name/contract';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
@@ -13,38 +13,11 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 
-declare const LAZY_SYMBOL: unique symbol;
-interface LazyMeta {
-    prefix?: HTTPPath;
-}
-interface Lazy<T> {
-    [LAZY_SYMBOL]: {
-        loader: () => Promise<{
-            default: T;
-        }>;
-        meta: LazyMeta;
-    };
-}
-type Lazyable<T> = T | Lazy<T>;
-/**
- * Creates a lazy-loaded item.
- *
- * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
- */
-declare function lazy<T>(loader: () => Promise<{
-    default: T;
-}>, meta?: LazyMeta): Lazy<T>;
-declare function isLazy(item: unknown): item is Lazy<any>;
-declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
-declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
-    default: T extends Lazy<infer U> ? U : T;
-}>;
-
 interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
     input: TInput;
     path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
     errors: TErrorConstructorMap;
@@ -52,7 +25,7 @@ interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErro
 interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
     (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
 }
-interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TSchemas, TErrorMap, TMeta> {
     __initialContext?: (type: TInitialContext) => unknown;
     middlewares: readonly AnyMiddleware[];
     inputValidationIndex: number;
@@ -64,14 +37,14 @@ interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends
  *
  * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
  */
-declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> {
     /**
      * This property holds the defined options.
      */
-    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>);
 }
-type AnyProcedure = Procedure<any, any, any, any, any, any>;
+type AnyProcedure = Procedure<any, any, Schemas, any, any>;
 declare function isProcedure(item: unknown): item is AnyProcedure;
 
 type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
@@ -92,7 +65,7 @@ interface MiddlewareOutputFn<TOutput> {
 interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TInContext;
     path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
     signal?: AbortSignal;
     lastEventId: string | undefined;
     next: MiddlewareNextFn<TOutput>;
@@ -112,41 +85,13 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 }
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    context: TInitialContext;
-    input: unknown;
-    errors: ORPCErrorConstructorMap<TErrorMap>;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-}
-type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
-    /**
-     * This is helpful for logging and analytics.
-     */
-    path?: readonly string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>>[];
-} & (Record<never, never> extends TInitialContext ? {
-    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
-} : {
-    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
-});
-/**
- * Create Server-side client from a procedure.
- *
- * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
- */
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
-
 /**
  * Represents a router, which defines a hierarchical structure of procedures.
  *
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
  */
-type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer USchemas, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, USchemas, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
 };
 type AnyRouter = Router<any, any>;
@@ -157,7 +102,7 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infe
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
 };
 /**
@@ -166,7 +111,7 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any> ? UCurrentContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
 };
 /**
@@ -175,7 +120,7 @@ type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any,
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferSchemaInput<USchemas['inputSchema']> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
@@ -184,9 +129,107 @@ type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infe
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as D, createProcedureClient as F, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, middlewareOutputFn as y };
-export type { AnyMiddleware as A, ProcedureDef as B, Context as C, ProcedureClientInterceptorOptions as E, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends (Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UErrorMap, infer UMeta>) ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
+};
+interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    errorMap: TErrorMap;
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface TraverseContractProceduresOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: AnyContractProcedure | AnyProcedure;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+/**
+ * @internal
+ */
+declare function lazyInternal<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T extends Router<ContractRouter<{}>, any>>(prefix: HTTPPath, loader: () => Promise<{
+    default: T;
+}>): EnhancedRouter<Lazy<T>, {}, {}, {}>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TSchemas['inputSchema']>, InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: unknown;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+} : {
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+/**
+ * Create Server-side client from a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ */
+declare function createProcedureClient<TInitialContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TSchemas, TErrorMap>;
+
+export { traverseContractProcedures as $, middlewareOutputFn as B, isProcedure as G, createProcedureClient as J, Procedure as P, getRouter as T, createAccessibleLazyRouter as V, enhanceRouter as W, resolveContractProcedures as a0, unlazyRouter as a2, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazyInternal as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u };
+export type { AnyMiddleware as A, Context as C, ProcedureHandlerOptions as D, EnhanceRouterOptions as E, ProcedureDef as F, ProcedureClientInterceptorOptions as H, InferRouterInitialContext as I, InferRouterInitialContexts as K, Lazy as L, Middleware as M, InferRouterCurrentContexts as N, ORPCErrorConstructorMap as O, InferRouterInputs as Q, Router as R, InferRouterOutputs as S, AccessibleLazyRouter as U, TraverseContractProceduresOptions as X, TraverseContractProcedureCallbackOptions as Y, ContractProcedureCallbackOptions as Z, LazyTraverseContractProceduresOptions as _, CreateProcedureClientOptions as a, UnlaziedRouter as a1, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, ProcedureHandler as e, EnhancedRouter as f, MapInputMiddleware as g, AnyProcedure as h, Lazyable as i, AnyRouter as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as v, MiddlewareNextFnOptions as w, MiddlewareNextFn as x, MiddlewareOutputFn as y, MiddlewareOptions as z };

package/dist/shared/server.BdGbIyq8.mjs

@@ -0,0 +1,396 @@
+import { isContractProcedure, mergePrefix, mergeErrorMap, enhanceRoute, validateORPCError, ValidationError } from '@temporary-name/contract';
+import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
+import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
+import { safeParseAsync } from '@temporary-name/zod';
+
+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];
+}
+
+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"] && "handler" in item["~orpc"];
+}
+
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
+      }
+      const item = (...rest) => {
+        const options = resolveMaybeOptionalOptions(rest);
+        const config = errors[code];
+        return new ORPCError(code, {
+          defined: Boolean(config),
+          status: config?.status,
+          message: options.message ?? config?.message,
+          data: options.data,
+          cause: options.cause
+        });
+      };
+      return item;
+    }
+  });
+  return proxy;
+}
+
+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 lazyInternal(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 = lazyInternal(
+      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 LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    errorMap: {},
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  return async (...[input, callerOptions]) => {
+    const path = toArray(options.path);
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options.context ?? {}, clientContext);
+    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+    const validateError = async (e) => {
+      if (e instanceof ORPCError) {
+        return await validateORPCError(procedure["~orpc"].errorMap, e);
+      }
+      return e;
+    };
+    try {
+      const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+        span?.setAttribute("procedure.path", [...path]);
+        return intercept(
+          toArray(options.interceptors),
+          {
+            context,
+            input,
+            // input only optional when it undefinable so we can safely cast it
+            errors,
+            path,
+            procedure,
+            signal: callerOptions?.signal,
+            lastEventId: callerOptions?.lastEventId
+          },
+          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+        );
+      });
+      if (isAsyncIteratorObject(output)) {
+        if (output instanceof HibernationEventIterator) {
+          return output;
+        }
+        return overlayProxy(
+          output,
+          mapEventIterator(
+            asyncIteratorWithSpan(
+              { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+              output
+            ),
+            {
+              value: (v) => v,
+              error: (e) => validateError(e)
+            }
+          )
+        );
+      }
+      return output;
+    } catch (e) {
+      throw await validateError(e);
+    }
+  };
+}
+async function validateInput(procedure, input) {
+  const schema = procedure["~orpc"].schemas.inputSchema;
+  if (!schema) {
+    return input;
+  }
+  return runWithSpan({ name: "validate_input" }, async () => {
+    const result = await safeParseAsync(schema, input);
+    if (!result.success) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "Input validation failed",
+        data: {
+          issues: result.error.issues
+        },
+        cause: new ValidationError({
+          message: "Input validation failed",
+          issues: result.error.issues,
+          data: input
+        })
+      });
+    }
+    return result.data;
+  });
+}
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].schemas.outputSchema;
+  if (!schema) {
+    return output;
+  }
+  return runWithSpan({ name: "validate_output" }, async () => {
+    const result = await safeParseAsync(schema, output);
+    if (!result.success) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Output validation failed",
+        cause: new ValidationError({
+          message: "Output validation failed",
+          issues: result.error.issues,
+          data: output
+        })
+      });
+    }
+    return result.data;
+  });
+}
+async function executeProcedureInternal(procedure, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].inputValidationIndex),
+    middlewares.length
+  );
+  const outputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].outputValidationIndex),
+    middlewares.length
+  );
+  const next = async (index, context, input) => {
+    let currentInput = input;
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
+      span?.setAttribute("middleware.index", index);
+      span?.setAttribute("middleware.name", mid.name);
+      const result = await mid(
+        {
+          ...options,
+          context,
+          next: async (...[nextOptions]) => {
+            const nextContext = nextOptions?.context ?? {};
+            return {
+              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              context: nextContext
+            };
+          }
+        },
+        currentInput,
+        middlewareOutputFn
+      );
+      return result.output;
+    }) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
+    );
+    if (index === outputValidationIndex) {
+      return await validateOutput(procedure, output);
+    }
+    return output;
+  };
+  return next(0, options.context, options.input);
+}
+
+export { LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, createORPCErrorConstructorMap as f, getLazyMeta as g, lazy as h, isProcedure as i, middlewareOutputFn as j, isStartWithMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, mergeMiddlewares as n, getHiddenRouterContract as o, createAccessibleLazyRouter as p, unlazyRouter as q, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };

package/dist/shared/{server.BeuTpcmO.d.mts → server.Bk8Hmx7Z.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.BKSOrA6h.mjs';
-import { c as StandardHandleOptions } from './server.C1fnTLq0.mjs';
+import { C as Context } from './server.B5czSQQh.mjs';
+import { c as StandardHandleOptions } from './server.TgmlNh8r.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;