@orpc/server 0.0.0-next.0787cc6 → 0.0.0-next.0c0619f

package/dist/src/procedure-decorated.d.ts

@@ -1,7 +1,10 @@
-import type { ClientRest, ErrorMap, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientContext, ClientRest } from '@orpc/client';
+import type { ErrorMap, MergedErrorMap, Meta, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
-import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
+import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
 import { Procedure } from './procedure';
 export declare class DecoratedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> {
     errors<U extends ErrorMap>(errors: U): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, MergedErrorMap<TErrorMap, U>, TMeta>;
@@ -12,10 +15,10 @@ export declare class DecoratedProcedure<TInitialContext extends Context, TCurren
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      */
-    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     /**
      * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
      */
-    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
+    actionable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

package/dist/src/procedure-utils.d.ts

@@ -1,8 +1,10 @@
-import type { ClientPromiseResult, ErrorFromErrorMap, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientPromiseResult } from '@orpc/client';
+import type { ErrorFromErrorMap, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
-import { type CreateProcedureClientRest } from './procedure-client';
+import type { CreateProcedureClientOptions } from './procedure-client';
 /**
  * Directly call a procedure without creating a client.
  *
@@ -13,5 +15,5 @@ import { type CreateProcedureClientRest } from './procedure-client';
  * ```
  *
  */
-export declare function call<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, input: SchemaInput<TInputSchema>, ...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, unknown>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+export declare function call<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, input: SchemaInput<TInputSchema>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, Record<never, never>>>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 //# sourceMappingURL=procedure-utils.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,6 +1,7 @@
-import type { ContractProcedureDef, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractProcedureDef, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
-import type { Context, TypeInitialContext } from './context';
+import type { Context } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { AnyMiddleware } from './middleware';
 export interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
@@ -8,13 +9,14 @@ export interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput
     path: string[];
     procedure: Procedure<Context, Context, Schema, Schema, unknown, ErrorMap, TMeta>;
     signal?: AbortSignal;
+    lastEventId: string | undefined;
     errors: TErrorConstructorMap;
 }
 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>>;
 }
 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>;
+    __initialContext?: (type: TInitialContext) => unknown;
     middlewares: AnyMiddleware[];
     inputValidationIndex: number;
     outputValidationIndex: number;

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

@@ -1,11 +1,12 @@
+import type { ClientContext } from '@orpc/client';
 import type { ErrorMap, Meta } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
-import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
-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> : {
+import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
+import type { AnyRouter, InferRouterInitialContext } from './router';
+export type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = Record<never, never>> = 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 CreateRouterClientRest<TRouter extends AnyRouter, TClientContext> = CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, undefined, unknown, ErrorMap, Meta, TClientContext>;
-export declare function createRouterClient<TRouter extends AnyRouter, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateRouterClientRest<TRouter, TClientContext>): RouterClient<TRouter, TClientContext>;
+export declare function createRouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext>(router: TRouter | Lazy<undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<TRouter>, undefined, undefined, unknown, ErrorMap, Meta, TClientContext>>): RouterClient<TRouter, TClientContext>;
 //# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -9,6 +9,7 @@ export type Router<TInitialContext extends Context, TContract extends AnyContrac
     [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
 }>;
 export type AnyRouter = Router<any, any>;
+export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
 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;
 };

package/dist/standard.js

@@ -1,17 +1,13 @@
 import {
   RPCCodec,
   RPCMatcher,
-  RPCSerializer,
-  StandardHandler,
-  serializeRPCJson
-} from "./chunk-BFGSRNYZ.js";
-import "./chunk-EDQKEHUX.js";
-import "./chunk-XFBAK67J.js";
+  StandardHandler
+} from "./chunk-7A2ZRAPK.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 export {
   RPCCodec,
   RPCMatcher,
-  RPCSerializer,
-  StandardHandler,
-  serializeRPCJson
+  StandardHandler
 };
 //# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.0787cc6",
+  "version": "0.0.0-next.0c0619f",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -63,9 +63,12 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@tinyhttp/content-disposition": "^2.2.2",
-    "@orpc/contract": "0.0.0-next.0787cc6",
-    "@orpc/shared": "0.0.0-next.0787cc6"
+    "@orpc/server-standard": "^0.4.0",
+    "@orpc/server-standard-fetch": "^0.4.0",
+    "@orpc/server-standard-node": "^0.4.0",
+    "@orpc/client": "0.0.0-next.0c0619f",
+    "@orpc/contract": "0.0.0-next.0c0619f",
+    "@orpc/shared": "0.0.0-next.0c0619f"
   },
   "devDependencies": {
     "light-my-request": "^6.5.1"

package/dist/chunk-2OH4QMZ4.js

@@ -1,145 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-BFGSRNYZ.js";
-
-// src/adapters/fetch/utils.ts
-import { once } from "@orpc/shared";
-import { contentDisposition, parse as parseContentDisposition } from "@tinyhttp/content-disposition";
-function fetchHeadersToStandardHeaders(headers) {
-  const standardHeaders = {};
-  for (const [key, value] of headers) {
-    if (Array.isArray(standardHeaders[key])) {
-      standardHeaders[key].push(value);
-    } else if (standardHeaders[key] !== void 0) {
-      standardHeaders[key] = [standardHeaders[key], value];
-    } else {
-      standardHeaders[key] = value;
-    }
-  }
-  return standardHeaders;
-}
-async function fetchReToStandardBody(re) {
-  if (!re.body) {
-    return void 0;
-  }
-  const contentDisposition2 = re.headers.get("content-disposition");
-  if (contentDisposition2) {
-    const fileName = parseContentDisposition(contentDisposition2).parameters.filename;
-    if (typeof fileName === "string") {
-      const blob2 = await re.blob();
-      return new File([blob2], fileName, {
-        type: blob2.type
-      });
-    }
-  }
-  const contentType = re.headers.get("content-type");
-  if (!contentType || contentType.startsWith("application/json")) {
-    const text = await re.text();
-    if (!text) {
-      return void 0;
-    }
-    return JSON.parse(text);
-  }
-  if (contentType.startsWith("multipart/form-data")) {
-    return await re.formData();
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    return new URLSearchParams(await re.text());
-  }
-  if (contentType.startsWith("text/")) {
-    return await re.text();
-  }
-  const blob = await re.blob();
-  return new File([blob], "blob", {
-    type: blob.type
-  });
-}
-function fetchRequestToStandardRequest(request) {
-  const url = new URL(request.url);
-  return {
-    raw: { request },
-    url,
-    signal: request.signal,
-    method: request.method,
-    body: once(() => {
-      return fetchReToStandardBody(request);
-    }),
-    get headers() {
-      const headers = fetchHeadersToStandardHeaders(request.headers);
-      Object.defineProperty(this, "headers", { value: headers, writable: true });
-      return headers;
-    },
-    set headers(value) {
-      Object.defineProperty(this, "headers", { value, writable: true });
-    }
-  };
-}
-function standardResponseToFetchHeaders(response) {
-  const fetchHeaders = new Headers();
-  for (const [key, value] of Object.entries(response.headers)) {
-    if (Array.isArray(value)) {
-      for (const v of value) {
-        fetchHeaders.append(key, v);
-      }
-    } else if (value !== void 0) {
-      fetchHeaders.append(key, value);
-    }
-  }
-  return fetchHeaders;
-}
-function standardResponseToFetchResponse(response) {
-  const resHeaders = standardResponseToFetchHeaders(response);
-  resHeaders.delete("content-type");
-  resHeaders.delete("content-disposition");
-  if (response.body === void 0) {
-    return new Response(void 0, { headers: resHeaders, status: response.status });
-  }
-  if (response.body instanceof Blob) {
-    resHeaders.set("content-type", response.body.type);
-    resHeaders.set("content-length", response.body.size.toString());
-    resHeaders.set(
-      "content-disposition",
-      contentDisposition(response.body instanceof File ? response.body.name : "blob", { type: "inline" })
-    );
-    return new Response(response.body, { headers: resHeaders, status: response.status });
-  }
-  if (response.body instanceof FormData) {
-    return new Response(response.body, { headers: resHeaders, status: response.status });
-  }
-  if (response.body instanceof URLSearchParams) {
-    return new Response(response.body, { headers: resHeaders, status: response.status });
-  }
-  resHeaders.set("content-type", "application/json");
-  return new Response(JSON.stringify(response.body), { headers: resHeaders, status: response.status });
-}
-
-// src/adapters/fetch/rpc-handler.ts
-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 = fetchRequestToStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: standardResponseToFetchResponse(result.response)
-    };
-  }
-};
-
-export {
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardResponseToFetchResponse,
-  RPCHandler
-};
-//# sourceMappingURL=chunk-2OH4QMZ4.js.map

package/dist/chunk-BFGSRNYZ.js

@@ -1,319 +0,0 @@
-import {
-  convertPathToHttpPath,
-  createContractedProcedure,
-  createProcedureClient,
-  eachContractProcedure,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-EDQKEHUX.js";
-import {
-  CompositePlugin
-} from "./chunk-XFBAK67J.js";
-
-// src/adapters/standard/handler.ts
-import { 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) => {
-        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);
-              const input = await this.codec.decode(request, match.params, match.procedure);
-              const output = await client(input, { signal: request.signal });
-              const response = this.codec.encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          const error = toORPCError(e);
-          const response = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      }
-    );
-  }
-};
-
-// src/adapters/standard/rpc-serializer.ts
-import { findDeepMatches, isObject, set } from "@orpc/shared";
-var RPCSerializer = class {
-  serialize(data) {
-    if (data === void 0) {
-      return void 0;
-    }
-    if (data instanceof Blob) {
-      return data;
-    }
-    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 (serialized === void 0) {
-      return void 0;
-    }
-    if (serialized instanceof Blob) {
-      return serialized;
-    }
-    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-BFGSRNYZ.js.map

package/dist/src/adapters/fetch/utils.d.ts

@@ -1,5 +0,0 @@
-import type { StandardBody, StandardRequest, StandardResponse } from '../standard';
-export declare function fetchReToStandardBody(re: Request | Response): Promise<StandardBody>;
-export declare function fetchRequestToStandardRequest(request: Request): StandardRequest;
-export declare function standardResponseToFetchResponse(response: StandardResponse): Response;
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/node/utils.d.ts

@@ -1,5 +0,0 @@
-import type { StandardRequest, StandardResponse } from '../standard';
-import type { NodeHttpRequest, NodeHttpResponse } from './types';
-export declare function nodeHttpToStandardRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardRequest;
-export declare function nodeHttpResponseSendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -1,16 +0,0 @@
-import type { Segment } from '@orpc/shared';
-export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
-export type RPCSerialized = {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-} | FormData | Blob | undefined;
-export type RPCSerializedFormDataMaps = Segment[][];
-export declare class RPCSerializer {
-    serialize(data: unknown): RPCSerialized;
-    deserialize(serialized: RPCSerialized): unknown;
-}
-export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-};
-//# sourceMappingURL=rpc-serializer.d.ts.map