@orpc/server 0.0.0-next.bf323bf → 0.0.0-next.c0088c7

package/dist/shared/server.ptXwNGQr.d.ts

@@ -0,0 +1,158 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { IsNever, MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, SchemaInput, HTTPPath, Meta, Schema, ContractProcedureDef, SchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure, MergedErrorMap } from '@orpc/contract';
+
+type Context = Record<string, any>;
+type MergedContext<T extends Context, U extends Context> = T & U;
+declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
+type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {
+    [K in keyof T]: IsNever<T[K]>;
+}[keyof T] ? never : unknown;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
+};
+
+declare const LAZY_LOADER_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_LOADER_SYMBOL](): Promise<{
+        default: T;
+    }>;
+}
+type Lazyable<T> = T | Lazy<T>;
+interface LazyOptions {
+    prefix?: HTTPPath;
+}
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TInContext extends Context, TOutput> {
+    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TInContext, TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+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 Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, THandlerOutput, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: SchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: string[];
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+
+type AccessibleLazyRouter<T extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : Lazy<T> & (T extends AnyProcedure | undefined ? unknown : {
+    [K in keyof T]: T[K] extends AnyRouter ? AccessibleLazyRouter<T[K]> : never;
+});
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+
+type Router<TInitialContext extends Context, TContract extends AnyContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, any, UErrorMap, UMeta> : {
+    [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
+}>;
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : T extends Procedure<infer UInitialContext, any, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInitialContexts<T[K]> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : T extends Procedure<any, infer UCurrentContext, any, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterCurrentContexts<T[K]> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
+    [K in keyof T]: T[K] extends AnyRouter ? InferRouterOutputs<T[K]> : never;
+};
+type AdaptedRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap> = TRouter extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<AdaptedRouter<U, TInitialContext, TErrorMap>> : TRouter extends Procedure<any, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, UCurrentContext, UInputSchema, UOutputSchema, UFuncOutput, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? AdaptedRouter<TRouter[K], TInitialContext, TErrorMap> : never;
+};
+interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
+    middlewares: AnyMiddleware[];
+    tags?: readonly string[];
+    prefix?: HTTPPath;
+    errorMap: TErrorMap;
+}
+declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
+declare function getRouterChild<T extends AnyRouter | Lazy<undefined>>(router: T, ...path: string[]): T extends Lazy<any> ? Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter>> | Lazy<undefined> : AnyRouter | Lazy<undefined> | undefined;
+
+export { type AnyProcedure as A, type ProcedureDef as B, type Context as C, isProcedure as D, createProcedureClient as E, type InferRouterInitialContexts as F, type InferRouterCurrentContexts as G, type InferRouterInputs as H, type InferRouterInitialContext as I, type InferRouterOutputs as J, adaptRouter as K, type Lazy as L, type Middleware as M, getRouterChild as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type AccessibleLazyRouter as Q, type Router as R, createAccessibleLazyRouter as S, type AnyRouter as a, Procedure as b, type ConflictContextGuard as c, type MergedContext as d, type MapInputMiddleware as e, type CreateProcedureClientOptions as f, type ProcedureClient as g, type ProcedureHandler as h, type AdaptRouterOptions as i, type AdaptedRouter as j, type AnyMiddleware as k, type Lazyable as l, mergeContext as m, LAZY_LOADER_SYMBOL as n, type LazyMeta as o, type LazyOptions as p, lazy as q, isLazy as r, type MiddlewareResult as s, type MiddlewareNextFnOptions as t, unlazy as u, type MiddlewareNextFn as v, type MiddlewareOutputFn as w, type MiddlewareOptions as x, middlewareOutputFn as y, type ProcedureHandlerOptions as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.bf323bf",
+  "version": "0.0.0-next.c0088c7",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,47 +15,42 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
     "./plugins": {
-      "types": "./dist/src/plugins/index.d.ts",
-      "import": "./dist/plugins.js",
-      "default": "./dist/plugins.js"
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
     },
     "./standard": {
-      "types": "./dist/src/adapters/standard/index.d.ts",
-      "import": "./dist/standard.js",
-      "default": "./dist/standard.js"
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     },
     "./hono": {
-      "types": "./dist/src/adapters/hono/index.d.ts",
-      "import": "./dist/hono.js",
-      "default": "./dist/hono.js"
+      "types": "./dist/adapters/hono/index.d.mts",
+      "import": "./dist/adapters/hono/index.mjs",
+      "default": "./dist/adapters/hono/index.mjs"
     },
     "./next": {
-      "types": "./dist/src/adapters/next/index.d.ts",
-      "import": "./dist/next.js",
-      "default": "./dist/next.js"
+      "types": "./dist/adapters/next/index.d.mts",
+      "import": "./dist/adapters/next/index.mjs",
+      "default": "./dist/adapters/next/index.mjs"
     },
     "./node": {
-      "types": "./dist/src/adapters/node/index.d.ts",
-      "import": "./dist/node.js",
-      "default": "./dist/node.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
@@ -63,17 +58,18 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/server-standard-node": "^0.4.0",
-    "@orpc/contract": "0.0.0-next.bf323bf",
-    "@orpc/shared": "0.0.0-next.bf323bf"
+    "@orpc/client": "0.0.0-next.c0088c7",
+    "@orpc/contract": "0.0.0-next.c0088c7",
+    "@orpc/shared": "0.0.0-next.c0088c7",
+    "@orpc/standard-server": "0.0.0-next.c0088c7",
+    "@orpc/standard-server-node": "0.0.0-next.c0088c7",
+    "@orpc/standard-server-fetch": "0.0.0-next.c0088c7"
   },
   "devDependencies": {
     "light-my-request": "^6.5.1"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-6TBBWYQ3.js

@@ -1,351 +0,0 @@
-import {
-  convertPathToHttpPath,
-  createContractedProcedure,
-  createProcedureClient,
-  eachContractProcedure,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-RDEUEBK3.js";
-import {
-  CompositePlugin
-} from "./chunk-XI6WGCB3.js";
-
-// src/adapters/standard/handler.ts
-import { ORPCError, toORPCError } from "@orpc/contract";
-import { intercept, trim } from "@orpc/shared";
-var StandardHandler = class {
-  constructor(router, matcher, codec, options = {}) {
-    this.matcher = matcher;
-    this.codec = codec;
-    this.options = options;
-    this.plugin = new CompositePlugin(options?.plugins);
-    this.plugin.init(this.options);
-    this.matcher.init(router);
-  }
-  plugin;
-  handle(request, ...[options]) {
-    return intercept(
-      this.options.interceptorsRoot ?? [],
-      {
-        request,
-        ...options,
-        context: options?.context ?? {}
-        // context is optional only when all fields are optional so we can safely force it to have a context
-      },
-      async (interceptorOptions) => {
-        let isDecoding = false;
-        try {
-          return await intercept(
-            this.options.interceptors ?? [],
-            interceptorOptions,
-            async (interceptorOptions2) => {
-              const method = interceptorOptions2.request.method;
-              const url = interceptorOptions2.request.url;
-              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
-              const match = await this.matcher.match(method, pathname);
-              if (!match) {
-                return { matched: false, response: void 0 };
-              }
-              const clientOptions = {
-                context: interceptorOptions2.context,
-                path: match.path
-              };
-              this.plugin.beforeCreateProcedureClient(clientOptions, interceptorOptions2);
-              const client = createProcedureClient(match.procedure, clientOptions);
-              isDecoding = true;
-              const input = await this.codec.decode(request, match.params, match.procedure);
-              isDecoding = false;
-              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
-              const output = await client(input, { signal: request.signal, lastEventId });
-              const response = this.codec.encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          const error = isDecoding ? new ORPCError("BAD_REQUEST", {
-            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
-            cause: e
-          }) : toORPCError(e);
-          const response = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      }
-    );
-  }
-};
-
-// src/adapters/standard/rpc-serializer.ts
-import { mapEventIterator, ORPCError as ORPCError2, toORPCError as toORPCError2 } from "@orpc/contract";
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches, isObject, set } from "@orpc/shared";
-var RPCSerializer = class {
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => serializeRPCJson(value),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: serializeRPCJson(e.data),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: serializeRPCJson(toORPCError2(e).toJSON()),
-            cause: e
-          });
-        }
-      });
-    }
-    const serializedJSON = serializeRPCJson(data);
-    const { maps, values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON.json);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    form.set("data", JSON.stringify(serializedJSON));
-    form.set("maps", JSON.stringify(maps));
-    for (const i in blobs) {
-      form.set(i, blobs[i]);
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
-        value: async (value) => deserializeRPCJson(value),
-        error: async (e) => {
-          if (!(e instanceof ErrorEvent)) {
-            return e;
-          }
-          const deserialized = deserializeRPCJson(e.data);
-          if (ORPCError2.isValidJSON(deserialized)) {
-            return ORPCError2.fromJSON(deserialized, { cause: e });
-          }
-          return new ErrorEvent({
-            data: deserialized,
-            cause: e
-          });
-        }
-      });
-    }
-    if (!(serialized instanceof FormData)) {
-      return deserializeRPCJson(serialized);
-    }
-    const data = JSON.parse(serialized.get("data"));
-    const maps = JSON.parse(serialized.get("maps"));
-    for (const i in maps) {
-      data.json = set(data.json, maps[i], serialized.get(i));
-    }
-    return deserializeRPCJson(data);
-  }
-};
-function serializeRPCJson(value, segments = [], meta = []) {
-  if (typeof value === "bigint") {
-    meta.push(["bigint", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof Date) {
-    meta.push(["date", segments]);
-    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-    return { json: data, meta };
-  }
-  if (Number.isNaN(value)) {
-    meta.push(["nan", segments]);
-    return { json: "NaN", meta };
-  }
-  if (value instanceof RegExp) {
-    meta.push(["regexp", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof URL) {
-    meta.push(["url", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (isObject(value)) {
-    const json = {};
-    for (const k in value) {
-      json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
-    }
-    return { json, meta };
-  }
-  if (Array.isArray(value)) {
-    const json = value.map((v, i) => {
-      if (v === void 0) {
-        meta.push(["undefined", [...segments, i]]);
-        return null;
-      }
-      return serializeRPCJson(v, [...segments, i], meta).json;
-    });
-    return { json, meta };
-  }
-  if (value instanceof Set) {
-    const result = serializeRPCJson(Array.from(value), segments, meta);
-    meta.push(["set", segments]);
-    return result;
-  }
-  if (value instanceof Map) {
-    const result = serializeRPCJson(Array.from(value.entries()), segments, meta);
-    meta.push(["map", segments]);
-    return result;
-  }
-  return { json: value, meta };
-}
-function deserializeRPCJson({
-  json,
-  meta
-}) {
-  if (meta.length === 0) {
-    return json;
-  }
-  const ref = { data: json };
-  for (const [type, segments] of meta) {
-    let currentRef = ref;
-    let preSegment = "data";
-    for (let i = 0; i < segments.length; i++) {
-      currentRef = currentRef[preSegment];
-      preSegment = segments[i];
-    }
-    switch (type) {
-      case "nan":
-        currentRef[preSegment] = Number.NaN;
-        break;
-      case "bigint":
-        currentRef[preSegment] = BigInt(currentRef[preSegment]);
-        break;
-      case "date":
-        currentRef[preSegment] = new Date(currentRef[preSegment]);
-        break;
-      case "regexp": {
-        const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
-        currentRef[preSegment] = new RegExp(pattern, flags);
-        break;
-      }
-      case "url":
-        currentRef[preSegment] = new URL(currentRef[preSegment]);
-        break;
-      case "undefined":
-        currentRef[preSegment] = void 0;
-        break;
-      case "map":
-        currentRef[preSegment] = new Map(currentRef[preSegment]);
-        break;
-      case "set":
-        currentRef[preSegment] = new Set(currentRef[preSegment]);
-        break;
-      /* v8 ignore next 3 */
-      default: {
-        const _expected = type;
-      }
-    }
-  }
-  return ref.data;
-}
-
-// src/adapters/standard/rpc-codec.ts
-var RPCCodec = class {
-  serializer;
-  constructor(options = {}) {
-    this.serializer = options.serializer ?? new RPCSerializer();
-  }
-  async decode(request, _params, _procedure) {
-    const serialized = request.method === "GET" ? JSON.parse(request.url.searchParams.getAll("data").at(-1)) : await request.body();
-    return this.serializer.deserialize(serialized);
-  }
-  encode(output, _procedure) {
-    return {
-      status: 200,
-      headers: {},
-      body: this.serializer.serialize(output)
-    };
-  }
-  encodeError(error) {
-    return {
-      status: error.status,
-      headers: {},
-      body: this.serializer.serialize(error.toJSON())
-    };
-  }
-};
-
-// src/adapters/standard/rpc-matcher.ts
-var RPCMatcher = class {
-  tree = {};
-  pendingRouters = [];
-  init(router, path = []) {
-    const laziedOptions = eachContractProcedure({
-      router,
-      path
-    }, ({ path: path2, contract }) => {
-      const httpPath = convertPathToHttpPath(path2);
-      if (isProcedure(contract)) {
-        this.tree[httpPath] = {
-          path: path2,
-          contract,
-          procedure: contract,
-          // this mean dev not used contract-first so we can used contract as procedure directly
-          router
-        };
-      } else {
-        this.tree[httpPath] = {
-          path: path2,
-          contract,
-          procedure: void 0,
-          router
-        };
-      }
-    });
-    this.pendingRouters.push(...laziedOptions.map((option) => ({
-      ...option,
-      httpPathPrefix: convertPathToHttpPath(option.path)
-    })));
-  }
-  async match(_method, pathname) {
-    if (this.pendingRouters.length) {
-      const newPendingRouters = [];
-      for (const pendingRouter of this.pendingRouters) {
-        if (pathname.startsWith(pendingRouter.httpPathPrefix)) {
-          const { default: router } = await unlazy(pendingRouter.lazied);
-          this.init(router, pendingRouter.path);
-        } else {
-          newPendingRouters.push(pendingRouter);
-        }
-      }
-      this.pendingRouters = newPendingRouters;
-    }
-    const match = this.tree[pathname];
-    if (!match) {
-      return void 0;
-    }
-    if (!match.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouterChild(match.router, ...match.path));
-      if (!isProcedure(maybeProcedure)) {
-        throw new Error(`
-          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.path)}.
-          Ensure that the procedure is correctly defined and matches the expected contract.
-        `);
-      }
-      match.procedure = createContractedProcedure(match.contract, maybeProcedure);
-    }
-    return {
-      path: match.path,
-      procedure: match.procedure
-    };
-  }
-};
-
-export {
-  StandardHandler,
-  RPCSerializer,
-  serializeRPCJson,
-  RPCCodec,
-  RPCMatcher
-};
-//# sourceMappingURL=chunk-6TBBWYQ3.js.map

package/dist/chunk-SVWPMCP4.js

@@ -1,32 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-6TBBWYQ3.js";
-
-// src/adapters/fetch/rpc-handler.ts
-import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
-var RPCHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const matcher = options?.matcher ?? new RPCMatcher();
-    const codec = options?.codec ?? new RPCCodec();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(request, ...rest) {
-    const standardRequest = toStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: toFetchResponse(result.response)
-    };
-  }
-};
-
-export {
-  RPCHandler
-};
-//# sourceMappingURL=chunk-SVWPMCP4.js.map

package/dist/fetch.js

@@ -1,10 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-SVWPMCP4.js";
-import "./chunk-6TBBWYQ3.js";
-import "./chunk-RDEUEBK3.js";
-import "./chunk-XI6WGCB3.js";
-export {
-  RPCHandler
-};
-//# sourceMappingURL=fetch.js.map