@orpc/server 0.0.0-next.d452413 → 0.0.0-next.d583bc4

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

@@ -0,0 +1,74 @@
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta } from '@orpc/contract';
+import { Interceptor } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.B4BGqy3Y.js';
+
+interface StandardHandlerPlugin<T extends Context> {
+    order?: number;
+    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: StandardHandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+export { CompositeStandardHandlerPlugin as C, StandardHandler as f };
+export type { StandardCodec as S, StandardParams as a, StandardHandleOptions as b, StandardHandleResult as c, StandardHandlerInterceptorOptions as d, StandardHandlerOptions as e, StandardHandlerPlugin as g, StandardMatchResult as h, StandardMatcher as i };

package/dist/shared/server.DZ5BIITo.mjs

@@ -0,0 +1,9 @@
+function resolveFriendlyStandardHandleOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+
+export { resolveFriendlyStandardHandleOptions as r };

package/dist/shared/{server.CMrS28Go.mjs → server.Ds4HPpvH.mjs}

@@ -1,6 +1,7 @@
-import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
-import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { value, intercept, toError } from '@orpc/shared';
+import { isContractProcedure, validateORPCError, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@orpc/shared';
+import { ORPCError, mapEventIterator } from '@orpc/client';
+import { HibernationEventIterator } from '@orpc/standard-server';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -21,7 +22,24 @@ function unlazy(lazied) {
   return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
 }
 
-function mergeMiddlewares(first, second) {
+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) {
@@ -29,6 +47,9 @@ function addMiddleware(middlewares, addition) {
 }
 
 class Procedure {
+  /**
+   * This property holds the defined options.
+   */
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
@@ -41,20 +62,25 @@ function isProcedure(item) {
   return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" 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 = (...[options]) => {
+      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
+          message: options.message ?? config?.message,
+          data: options.data,
+          cause: options.cause
         });
       };
       return item;
@@ -62,54 +88,64 @@ function createORPCErrorConstructorMap(errors) {
   });
   return proxy;
 }
-async function validateORPCError(map, error) {
-  const { code, status, message, data, cause, defined } = error;
-  const config = map?.[error.code];
-  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
-    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
-  }
-  if (!config.data) {
-    return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
-  }
-  const validated = await config.data["~standard"].validate(error.data);
-  if (validated.issues) {
-    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
-  }
-  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
-}
 
 function middlewareOutputFn(output) {
   return { output, context: {} };
 }
 
-function createProcedureClient(lazyableProcedure, ...[options]) {
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
   return async (...[input, callerOptions]) => {
-    const path = options?.path ?? [];
+    const path = toArray(options.path);
     const { default: procedure } = await unlazy(lazyableProcedure);
     const clientContext = callerOptions?.context ?? {};
-    const context = await value(options?.context ?? {}, clientContext);
+    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 {
-      return await intercept(
-        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)
+      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)
+          );
+        }
       );
-    } catch (e) {
-      if (!(e instanceof ORPCError)) {
-        throw toError(e);
+      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)
+          }
+        ));
       }
-      const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
-      throw validated;
+      return output;
+    } catch (e) {
+      throw await validateError(e);
     }
   };
 }
@@ -118,58 +154,88 @@ async function validateInput(procedure, input) {
   if (!schema) {
     return input;
   }
-  const result = await schema["~standard"].validate(input);
-  if (result.issues) {
-    throw new ORPCError("BAD_REQUEST", {
-      message: "Input validation failed",
-      data: {
-        issues: result.issues
-      },
-      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
+  return runWithSpan(
+    { name: "validate_input" },
+    async () => {
+      const result = await schema["~standard"].validate(input);
+      if (result.issues) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Input validation failed",
+          data: {
+            issues: result.issues
+          },
+          cause: new ValidationError({
+            message: "Input validation failed",
+            issues: result.issues,
+            data: input
+          })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 async function validateOutput(procedure, output) {
   const schema = procedure["~orpc"].outputSchema;
   if (!schema) {
     return output;
   }
-  const result = await schema["~standard"].validate(output);
-  if (result.issues) {
-    throw new ORPCError("INTERNAL_SERVER_ERROR", {
-      message: "Output validation failed",
-      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
+  return runWithSpan(
+    { name: "validate_output" },
+    async () => {
+      const result = await schema["~standard"].validate(output);
+      if (result.issues) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Output validation failed",
+          cause: new ValidationError({
+            message: "Output validation failed",
+            issues: result.issues,
+            data: output
+          })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 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);
-  let currentIndex = 0;
-  let currentContext = options.context;
-  let currentInput = options.input;
-  const next = async (...[nextOptions]) => {
-    const index = currentIndex;
-    currentIndex += 1;
-    currentContext = { ...currentContext, ...nextOptions?.context };
+  const next = async (index, context, input) => {
+    let currentInput = input;
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
     const mid = middlewares[index];
-    const result = mid ? await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn) : { output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput }), context: currentContext };
+    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) {
-      const validatedOutput = await validateOutput(procedure, result.output);
-      return {
-        ...result,
-        output: validatedOutput
-      };
+      return await validateOutput(procedure, output);
     }
-    return result;
+    return output;
   };
-  return (await next({})).output;
+  return next(0, options.context, options.input);
 }
 
 const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
@@ -239,7 +305,7 @@ function enhanceRouter(router, options) {
     return accessible;
   }
   if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares);
+    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"],
@@ -336,11 +402,8 @@ function createContractedProcedure(procedure, contract) {
   });
 }
 function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-function toHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
+  const options = resolveMaybeOptionalOptions(rest);
+  return createProcedureClient(procedure, options)(input, options);
 }
 
-export { LAZY_SYMBOL as L, Procedure as P, toHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, enhanceRouter as e, isLazy as f, getRouter as g, createAssertedLazyProcedure as h, isProcedure as i, getLazyMeta as j, call as k, lazy as l, middlewareOutputFn as m, getHiddenRouterContract as n, createAccessibleLazyRouter as o, unlazyRouter as p, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, resolveContractProcedures as v, unlazyRouter as w };

package/dist/shared/server.DzV1hr3z.d.mts

@@ -0,0 +1,42 @@
+import { ErrorMap, EnhanceRouteOptions, MergedErrorMap, AnyContractRouter, AnyContractProcedure } from '@orpc/contract';
+import { a as AnyMiddleware, L as Lazyable, b as AnyRouter, C as Context, c as Lazy, A as AnyProcedure, P as Procedure, M as MergedInitialContext } from './server.B4BGqy3Y.mjs';
+
+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 UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, 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>>;
+
+export { createAccessibleLazyRouter as c, enhanceRouter as e, getRouter as g, resolveContractProcedures as r, traverseContractProcedures as t, unlazyRouter as u };
+export type { AccessibleLazyRouter as A, ContractProcedureCallbackOptions as C, EnhanceRouterOptions as E, LazyTraverseContractProceduresOptions as L, TraverseContractProcedureCallbackOptions as T, UnlaziedRouter as U, EnhancedRouter as a, TraverseContractProceduresOptions as b };

package/dist/shared/server.TEVCLCFC.mjs

@@ -0,0 +1,39 @@
+import { ORPCError, fallbackContractConfig } from '@orpc/contract';
+
+const STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL = Symbol("STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT");
+class StrictGetMethodPlugin {
+  error;
+  /**
+   * make sure execute before batch plugin to get real method
+   */
+  order = 7e6;
+  constructor(options = {}) {
+    this.error = options.error ?? new ORPCError("METHOD_NOT_SUPPORTED");
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.clientInterceptors ??= [];
+    options.rootInterceptors.unshift((options2) => {
+      const isGetMethod = options2.request.method === "GET";
+      return options2.next({
+        ...options2,
+        context: {
+          ...options2.context,
+          [STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL]: isGetMethod
+        }
+      });
+    });
+    options.clientInterceptors.unshift((options2) => {
+      if (typeof options2.context[STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL] !== "boolean") {
+        throw new TypeError("[StrictGetMethodPlugin] strict GET method context has been corrupted or modified by another plugin or interceptor");
+      }
+      const procedureMethod = fallbackContractConfig("defaultMethod", options2.procedure["~orpc"].route.method);
+      if (options2.context[STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL] && procedureMethod !== "GET") {
+        throw this.error;
+      }
+      return options2.next();
+    });
+  }
+}
+
+export { StrictGetMethodPlugin as S };

package/dist/shared/server.UVMTOWrk.mjs

@@ -0,0 +1,26 @@
+import '@orpc/client';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import '@orpc/client/standard';
+import { r as resolveFriendlyStandardHandleOptions } from './server.DZ5BIITo.mjs';
+
+async function handleStandardServerPeerMessage(handler, peer, message, options) {
+  const [id, request] = await peer.message(message);
+  if (!request) {
+    return;
+  }
+  const handle = createServerPeerHandleRequestFn(handler, options);
+  await peer.response(id, await handle(request));
+}
+function createServerPeerHandleRequestFn(handler, options) {
+  return async (request) => {
+    const { response } = await handler.handle(
+      { ...request, body: () => Promise.resolve(request.body) },
+      resolveFriendlyStandardHandleOptions(options)
+    );
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createServerPeerHandleRequestFn as c, handleStandardServerPeerMessage as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.d452413",
+  "version": "0.0.0-next.d583bc4",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,54 +19,105 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./helpers": {
+      "types": "./dist/helpers/index.d.mts",
+      "import": "./dist/helpers/index.mjs",
+      "default": "./dist/helpers/index.mjs"
+    },
     "./plugins": {
       "types": "./dist/plugins/index.d.mts",
       "import": "./dist/plugins/index.mjs",
       "default": "./dist/plugins/index.mjs"
     },
+    "./hibernation": {
+      "types": "./dist/hibernation/index.d.mts",
+      "import": "./dist/hibernation/index.mjs",
+      "default": "./dist/hibernation/index.mjs"
+    },
     "./standard": {
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
       "default": "./dist/adapters/standard/index.mjs"
     },
+    "./standard-peer": {
+      "types": "./dist/adapters/standard-peer/index.d.mts",
+      "import": "./dist/adapters/standard-peer/index.mjs",
+      "default": "./dist/adapters/standard-peer/index.mjs"
+    },
     "./fetch": {
       "types": "./dist/adapters/fetch/index.d.mts",
       "import": "./dist/adapters/fetch/index.mjs",
       "default": "./dist/adapters/fetch/index.mjs"
     },
-    "./hono": {
-      "types": "./dist/adapters/hono/index.d.mts",
-      "import": "./dist/adapters/hono/index.mjs",
-      "default": "./dist/adapters/hono/index.mjs"
-    },
-    "./next": {
-      "types": "./dist/adapters/next/index.d.mts",
-      "import": "./dist/adapters/next/index.mjs",
-      "default": "./dist/adapters/next/index.mjs"
-    },
     "./node": {
       "types": "./dist/adapters/node/index.d.mts",
       "import": "./dist/adapters/node/index.mjs",
       "default": "./dist/adapters/node/index.mjs"
+    },
+    "./aws-lambda": {
+      "types": "./dist/adapters/aws-lambda/index.d.mts",
+      "import": "./dist/adapters/aws-lambda/index.mjs",
+      "default": "./dist/adapters/aws-lambda/index.mjs"
+    },
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
+    },
+    "./crossws": {
+      "types": "./dist/adapters/crossws/index.d.mts",
+      "import": "./dist/adapters/crossws/index.mjs",
+      "default": "./dist/adapters/crossws/index.mjs"
+    },
+    "./ws": {
+      "types": "./dist/adapters/ws/index.d.mts",
+      "import": "./dist/adapters/ws/index.mjs",
+      "default": "./dist/adapters/ws/index.mjs"
+    },
+    "./bun-ws": {
+      "types": "./dist/adapters/bun-ws/index.d.mts",
+      "import": "./dist/adapters/bun-ws/index.mjs",
+      "default": "./dist/adapters/bun-ws/index.mjs"
+    },
+    "./message-port": {
+      "types": "./dist/adapters/message-port/index.d.mts",
+      "import": "./dist/adapters/message-port/index.mjs",
+      "default": "./dist/adapters/message-port/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "peerDependencies": {
-    "hono": ">=4.6.0",
-    "next": ">=14.0.0"
+    "crossws": ">=0.3.4",
+    "ws": ">=8.18.1"
+  },
+  "peerDependenciesMeta": {
+    "crossws": {
+      "optional": true
+    },
+    "ws": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.d452413",
-    "@orpc/client": "0.0.0-next.d452413",
-    "@orpc/standard-server": "0.0.0-next.d452413",
-    "@orpc/standard-server-fetch": "0.0.0-next.d452413",
-    "@orpc/standard-server-node": "0.0.0-next.d452413",
-    "@orpc/shared": "0.0.0-next.d452413"
+    "cookie": "^1.0.2",
+    "@orpc/client": "0.0.0-next.d583bc4",
+    "@orpc/interop": "0.0.0-next.d583bc4",
+    "@orpc/shared": "0.0.0-next.d583bc4",
+    "@orpc/contract": "0.0.0-next.d583bc4",
+    "@orpc/standard-server": "0.0.0-next.d583bc4",
+    "@orpc/standard-server-aws-lambda": "0.0.0-next.d583bc4",
+    "@orpc/standard-server-node": "0.0.0-next.d583bc4",
+    "@orpc/standard-server-fetch": "0.0.0-next.d583bc4",
+    "@orpc/standard-server-peer": "0.0.0-next.d583bc4"
   },
   "devDependencies": {
-    "light-my-request": "^6.5.1"
+    "@types/ws": "^8.18.1",
+    "crossws": "^0.4.1",
+    "next": "^15.5.4",
+    "supertest": "^7.1.4",
+    "ws": "^8.18.3"
   },
   "scripts": {
     "build": "unbuild",