@orpc/server 0.0.0-next.c6c659d → 0.0.0-next.ccd4e42

package/dist/src/procedure.d.ts

@@ -1,43 +1,29 @@
-import type { ContractProcedure, ErrorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { AbortSignal, ContractProcedureDef, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
-import type { ORPCErrorConstructorMap } from './error';
-import type { Lazy } from './lazy';
-import type { Middleware } from './middleware';
-import type { AbortSignal, Context, MergeContext } from './types';
-export interface ProcedureHandlerOptions<TContext extends Context, TExtraContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    context: MergeContext<TContext, TExtraContext>;
+import type { Context, TypeInitialContext } from './context';
+import type { AnyMiddleware } from './middleware';
+export interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
     input: TInput;
     path: string[];
-    procedure: ANY_PROCEDURE;
+    procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
     signal?: AbortSignal;
     errors: TErrorConstructorMap;
 }
-export interface ProcedureHandler<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> {
-    (opt: ProcedureHandlerOptions<TContext, TExtraContext, SchemaOutput<TInputSchema>, ORPCErrorConstructorMap<TErrorMap>>): Promisable<SchemaInput<TOutputSchema, THandlerOutput>>;
+export interface ProcedureHandler<TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, SchemaOutput<TInputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<SchemaInput<TOutputSchema, THandlerOutput>>;
 }
-/**
- * Why is `ErrorConstructorMap` passed to `Middleware` as `any`?
- * Why is `ErrorMap` passed to `ProcedureHandler` as `any`?
- *
- * Passing `ErrorMap/ErrorConstructorMap` directly to `Middleware/ProcedureHandler`
- * causes unexpected errors in the router (the root cause is unclear, but it occurs consistently).
- * To avoid these issues, `any` is used as a workaround.
- *
- * This approach is still functional because `ProcedureDef` can infer the `ErrorMap` from `ContractProcedure`.
- * The only downside is that direct access to them requires careful type checking to ensure safety.
- */
-export interface ProcedureDef<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> {
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, SchemaOutput<TInputSchema>, any, any>[];
-    contract: ContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-    handler: ProcedureHandler<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, any>;
+export interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: TypeInitialContext<TInitialContext>;
+    middlewares: AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, THandlerOutput, any, any>;
 }
-export declare class Procedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> {
-    '~type': "Procedure";
-    '~orpc': ProcedureDef<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
-    constructor(def: ProcedureDef<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>);
+export declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, 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>);
 }
-export type ANY_PROCEDURE = Procedure<any, any, any, any, any, any>;
-export type WELL_PROCEDURE = Procedure<Context, Context, Schema, Schema, unknown, any>;
-export type ANY_LAZY_PROCEDURE = Lazy<ANY_PROCEDURE>;
-export declare function isProcedure(item: unknown): item is ANY_PROCEDURE;
+export type AnyProcedure = Procedure<any, any, any, any, any, any, any>;
+export declare function isProcedure(item: unknown): item is AnyProcedure;
 //# sourceMappingURL=procedure.d.ts.map

package/dist/src/router-accessible-lazy.d.ts

@@ -0,0 +1,8 @@
+import type { Lazy } from './lazy';
+import type { AnyProcedure } from './procedure';
+import type { AnyRouter } from './router';
+export 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;
+});
+export declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+//# sourceMappingURL=router-accessible-lazy.d.ts.map

package/dist/src/router-client.d.ts

@@ -1,17 +1,12 @@
-import type { ContractProcedure, ContractRouter, ErrorFromErrorMap, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Hooks, Value } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
 import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
-import type { Meta } from './types';
-import { type ANY_ROUTER, type Router } from './router';
-/**
- * FIXME: separate RouterClient and ContractRouterClient, don't mix them
- */
-export type RouterClient<TRouter extends ANY_ROUTER | ContractRouter, TClientContext> = TRouter extends Lazy<infer U extends ANY_ROUTER | ContractRouter> ? RouterClient<U, TClientContext> : TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> | Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap> ? ProcedureClient<TClientContext, SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>, ErrorFromErrorMap<UErrorMap>> : {
-    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER | ContractRouter ? RouterClient<TRouter[K], TClientContext> : never;
+import type { AnyRouter, Router } from './router';
+export type RouterClient<TRouter extends AnyRouter, TClientContext> = TRouter extends Lazy<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyRouter ? RouterClient<TRouter[K], TClientContext> : never;
 };
-export type CreateRouterClientOptions<TRouter extends ANY_ROUTER> = {
+export type CreateRouterClientOptions<TRouter extends AnyRouter> = {
     /**
      * This is helpful for logging and analytics.
      *
@@ -22,6 +17,6 @@ export type CreateRouterClientOptions<TRouter extends ANY_ROUTER> = {
     context?: Value<UContext>;
 } : {
     context: Value<UContext>;
-} : never) & Hooks<unknown, unknown, TRouter extends Router<infer UContext, any> ? UContext : never, Meta>;
-export declare function createRouterClient<TRouter extends ANY_ROUTER, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, unknown, TClientContext>): RouterClient<TRouter, TClientContext>;
+} : never) & Hooks<unknown, unknown, TRouter extends Router<infer UContext, any> ? UContext : never, any>;
+export declare function createRouterClient<TRouter extends AnyRouter, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, unknown, TClientContext>): RouterClient<TRouter, TClientContext>;
 //# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -1,16 +1,29 @@
-import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { ANY_LAZY, Lazy, Lazyable } from './lazy';
-import type { ANY_PROCEDURE, Procedure } from './procedure';
-import type { Context } from './types';
-export type Router<TContext extends Context, TContract extends ContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any, UErrorMap> : {
-    [K in keyof TContract]: TContract[K] extends ContractRouter ? Router<TContext, TContract[K]> : never;
+import type { AnyContractRouter, ContractProcedure, ErrorMap, HTTPPath, MergedErrorMap, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Context } from './context';
+import type { Lazy, Lazyable } from './lazy';
+import type { AnyMiddleware } from './middleware';
+import type { AnyProcedure } from './procedure';
+import { Procedure } from './procedure';
+import { type AccessibleLazyRouter } from './router-accessible-lazy';
+export 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;
 }>;
-export type ANY_ROUTER = Router<any, any>;
-export type InferRouterInputs<T extends ANY_ROUTER> = T extends Lazy<infer U extends ANY_ROUTER> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends ANY_ROUTER ? InferRouterInputs<T[K]> : never;
+export type AnyRouter = Router<any, any>;
+export 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;
 };
-export type InferRouterOutputs<T extends ANY_ROUTER> = T extends Lazy<infer U extends ANY_ROUTER> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput, any> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
-    [K in keyof T]: T[K] extends ANY_ROUTER ? InferRouterOutputs<T[K]> : never;
+export 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;
 };
-export declare function getRouterChild<T extends ANY_ROUTER | Lazy<undefined>>(router: T, ...path: string[]): T extends ANY_LAZY ? Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER>> | Lazy<undefined> : ANY_ROUTER | Lazy<undefined> | undefined;
+export 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;
+};
+export interface AdaptRouterOptions<TErrorMap extends ErrorMap> {
+    middlewares: AnyMiddleware[];
+    tags?: readonly string[];
+    prefix?: HTTPPath;
+    errorMap: TErrorMap;
+}
+export declare function adaptRouter<TRouter extends AnyRouter, TInitialContext extends Context, TErrorMap extends ErrorMap>(router: TRouter, options: AdaptRouterOptions<TErrorMap>): AdaptedRouter<TRouter, TInitialContext, TErrorMap>;
+export 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;
 //# sourceMappingURL=router.d.ts.map

package/dist/src/utils.d.ts

@@ -1,3 +1,24 @@
-import type { Context, MergeContext } from './types';
-export declare function mergeContext<A extends Context, B extends Context>(a: A, b: B): MergeContext<A, B>;
+import type { AnyContractProcedure, AnyContractRouter, HTTPPath } from '@orpc/contract';
+import type { Lazy } from './lazy';
+import type { AnyProcedure } from './procedure';
+import type { AnyRouter } from './router';
+export interface EachContractProcedureOptions {
+    router: AnyRouter | AnyContractRouter;
+    path: string[];
+}
+export interface EachContractProcedureCallbackOptions {
+    contract: AnyContractProcedure;
+    path: string[];
+}
+export interface EachContractProcedureLaziedOptions {
+    lazied: Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter> | AnyProcedure>;
+    path: string[];
+}
+export declare function eachContractProcedure(options: EachContractProcedureOptions, callback: (options: EachContractProcedureCallbackOptions) => void, laziedOptions?: EachContractProcedureLaziedOptions[]): EachContractProcedureLaziedOptions[];
+export declare function eachAllContractProcedure(options: EachContractProcedureOptions, callback: (options: EachContractProcedureCallbackOptions) => void): Promise<void>;
+export declare function convertPathToHttpPath(path: string[]): HTTPPath;
+/**
+ * Create a new procedure that ensure the contract is applied to the procedure.
+ */
+export declare function createContractedProcedure(contract: AnyContractProcedure, procedure: AnyProcedure): AnyProcedure;
 //# sourceMappingURL=utils.d.ts.map

package/dist/standard.js

@@ -0,0 +1,16 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  RPCSerializer,
+  StandardHandler,
+  serializeRPCJson
+} from "./chunk-JHLUGXCM.js";
+import "./chunk-NOA3GBJQ.js";
+export {
+  RPCCodec,
+  RPCMatcher,
+  RPCSerializer,
+  StandardHandler,
+  serializeRPCJson
+};
+//# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.c6c659d",
+  "version": "0.0.0-next.ccd4e42",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./standard": {
+      "types": "./dist/src/adapters/standard/index.d.ts",
+      "import": "./dist/standard.js",
+      "default": "./dist/standard.js"
+    },
     "./fetch": {
       "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
@@ -53,8 +58,12 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.c6c659d",
-    "@orpc/shared": "0.0.0-next.c6c659d"
+    "content-disposition": "^0.5.4",
+    "@orpc/contract": "0.0.0-next.ccd4e42",
+    "@orpc/shared": "0.0.0-next.ccd4e42"
+  },
+  "devDependencies": {
+    "light-my-request": "^6.5.1"
   },
   "scripts": {
     "build": "tsup --onSuccess='tsc -b --noCheck'",

package/dist/chunk-MB74GD7C.js

@@ -1,301 +0,0 @@
-import {
-  __export,
-  createProcedureClient,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-ZBJYYEII.js";
-
-// src/adapters/fetch/super-json.ts
-var super_json_exports = {};
-__export(super_json_exports, {
-  deserialize: () => deserialize,
-  serialize: () => serialize
-});
-
-// ../../node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/getType.js
-function getType(payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
-}
-
-// ../../node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/isPlainObject.js
-function isPlainObject(payload) {
-  if (getType(payload) !== "Object")
-    return false;
-  const prototype = Object.getPrototypeOf(payload);
-  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
-}
-
-// src/adapters/fetch/super-json.ts
-function serialize(value, segments = [], meta = []) {
-  if (typeof value === "bigint") {
-    meta.push(["bigint", segments]);
-    return { data: value.toString(), meta };
-  }
-  if (value instanceof Date) {
-    meta.push(["date", segments]);
-    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-    return { data, meta };
-  }
-  if (Number.isNaN(value)) {
-    meta.push(["nan", segments]);
-    return { data: "NaN", meta };
-  }
-  if (value instanceof RegExp) {
-    meta.push(["regexp", segments]);
-    return { data: value.toString(), meta };
-  }
-  if (value instanceof URL) {
-    meta.push(["url", segments]);
-    return { data: value.toString(), meta };
-  }
-  if (isPlainObject(value)) {
-    const data = {};
-    for (const k in value) {
-      data[k] = serialize(value[k], [...segments, k], meta).data;
-    }
-    return { data, meta };
-  }
-  if (Array.isArray(value)) {
-    const data = value.map((v, i) => {
-      if (v === void 0) {
-        meta.push(["undefined", [...segments, i]]);
-        return null;
-      }
-      return serialize(v, [...segments, i], meta).data;
-    });
-    return { data, meta };
-  }
-  if (value instanceof Set) {
-    const result = serialize(Array.from(value), segments, meta);
-    meta.push(["set", segments]);
-    return result;
-  }
-  if (value instanceof Map) {
-    const result = serialize(Array.from(value.entries()), segments, meta);
-    meta.push(["map", segments]);
-    return result;
-  }
-  return { data: value, meta };
-}
-function deserialize({
-  data,
-  meta
-}) {
-  if (meta.length === 0) {
-    return data;
-  }
-  const ref = { data };
-  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/fetch/orpc-payload-codec.ts
-import { ORPCError } from "@orpc/contract";
-import { findDeepMatches, set } from "@orpc/shared";
-var ORPCPayloadCodec = class {
-  /**
-   * If method is GET, the payload will be encoded as query string.
-   * If method is GET and payload contain file, the method will be fallback to fallbackMethod. (fallbackMethod = GET will force to use GET method)
-   */
-  encode(payload, method = "POST", fallbackMethod = "POST") {
-    const { data, meta } = serialize(payload);
-    const { maps, values } = findDeepMatches((v) => v instanceof Blob, data);
-    if (method === "GET" && (values.length === 0 || fallbackMethod === "GET")) {
-      const query = new URLSearchParams({
-        data: JSON.stringify(data),
-        meta: JSON.stringify(meta)
-      });
-      return {
-        query,
-        method: "GET"
-      };
-    }
-    const nonGETMethod = method === "GET" ? fallbackMethod : method;
-    if (values.length > 0) {
-      const form = new FormData();
-      if (data !== void 0) {
-        form.append("data", JSON.stringify(data));
-      }
-      form.append("meta", JSON.stringify(meta));
-      form.append("maps", JSON.stringify(maps));
-      for (const i in values) {
-        const value = values[i];
-        form.append(i, value);
-      }
-      return {
-        body: form,
-        method: nonGETMethod
-      };
-    }
-    return {
-      body: JSON.stringify({ data, meta }),
-      headers: new Headers({
-        "content-type": "application/json"
-      }),
-      method: nonGETMethod
-    };
-  }
-  async decode(re) {
-    try {
-      if ("method" in re && re.method === "GET") {
-        const url = new URL(re.url);
-        const query = url.searchParams;
-        const data = JSON.parse(query.getAll("data").at(-1));
-        const meta = JSON.parse(query.getAll("meta").at(-1));
-        return deserialize({
-          data,
-          meta
-        });
-      }
-      if (re.headers.get("content-type")?.startsWith("multipart/form-data")) {
-        const form = await re.formData();
-        const rawData = form.get("data");
-        const rawMeta = form.get("meta");
-        const rawMaps = form.get("maps");
-        let data = JSON.parse(rawData);
-        const meta = JSON.parse(rawMeta);
-        const maps = JSON.parse(rawMaps);
-        for (const i in maps) {
-          data = set(data, maps[i], form.get(i));
-        }
-        return deserialize({
-          data,
-          meta
-        });
-      }
-      const json = await re.json();
-      return deserialize(json);
-    } catch (e) {
-      throw new ORPCError({
-        code: "BAD_REQUEST",
-        message: "Cannot parse request/response. Please check the request/response body and Content-Type header.",
-        cause: e
-      });
-    }
-  }
-};
-
-// src/adapters/fetch/orpc-procedure-matcher.ts
-import { trim } from "@orpc/shared";
-var ORPCProcedureMatcher = class {
-  constructor(router) {
-    this.router = router;
-  }
-  async match(pathname) {
-    const path = trim(pathname, "/").split("/").map(decodeURIComponent);
-    const match = getRouterChild(this.router, ...path);
-    const { default: maybeProcedure } = await unlazy(match);
-    if (!isProcedure(maybeProcedure)) {
-      return void 0;
-    }
-    return {
-      procedure: maybeProcedure,
-      path
-    };
-  }
-};
-
-// src/adapters/fetch/orpc-handler.ts
-import { ORPCError as ORPCError2 } from "@orpc/contract";
-import { executeWithHooks, trim as trim2 } from "@orpc/shared";
-var RPCHandler = class {
-  constructor(router, options) {
-    this.options = options;
-    this.procedureMatcher = options?.procedureMatcher ?? new ORPCProcedureMatcher(router);
-    this.payloadCodec = options?.payloadCodec ?? new ORPCPayloadCodec();
-  }
-  procedureMatcher;
-  payloadCodec;
-  async handle(request, ...[options]) {
-    const context = options?.context;
-    const execute = async () => {
-      const url = new URL(request.url);
-      const pathname = `/${trim2(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
-      const match = await this.procedureMatcher.match(pathname);
-      if (!match) {
-        return { matched: false, response: void 0 };
-      }
-      const input = await this.payloadCodec.decode(request);
-      const client = createProcedureClient(match.procedure, {
-        context,
-        path: match.path
-      });
-      const output = await client(input, { signal: request.signal });
-      const { body, headers } = this.payloadCodec.encode(output);
-      const response = new Response(body, { headers });
-      return { matched: true, response };
-    };
-    try {
-      const result = await executeWithHooks({
-        context,
-        execute,
-        input: request,
-        hooks: this.options,
-        meta: {
-          signal: request.signal
-        }
-      });
-      return result;
-    } catch (e) {
-      const error = e instanceof ORPCError2 ? e : new ORPCError2({
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: e
-      });
-      const { body, headers } = this.payloadCodec.encode(error.toJSON());
-      const response = new Response(body, {
-        headers,
-        status: error.status
-      });
-      return { matched: true, response };
-    }
-  }
-};
-
-export {
-  super_json_exports,
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler
-};
-//# sourceMappingURL=chunk-MB74GD7C.js.map

package/dist/chunk-WUOGVGWG.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-WUOGVGWG.js.map