@orpc/server 0.0.0-next.6acfc62 → 0.0.0-next.6affcc9

package/dist/chunk-L4ESXQX7.js

@@ -0,0 +1,32 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-NXEANHUK.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-L4ESXQX7.js.map

package/dist/{chunk-SUGWQSMQ.js → chunk-NXEANHUK.js}

@@ -6,13 +6,13 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-NOA3GBJQ.js";
+} from "./chunk-XXBE6CYD.js";
 import {
   CompositePlugin
-} from "./chunk-OWMUECGT.js";
+} from "./chunk-XI6WGCB3.js";
 
 // src/adapters/standard/handler.ts
-import { toORPCError } from "@orpc/contract";
+import { ORPCError, toORPCError } from "@orpc/contract";
 import { intercept, trim } from "@orpc/shared";
 var StandardHandler = class {
   constructor(router, matcher, codec, options = {}) {
@@ -25,30 +25,39 @@ var StandardHandler = class {
   }
   plugin;
   handle(request, ...[options]) {
-    const handleOptions = options ?? {};
-    handleOptions.context ??= {};
     return intercept(
       this.options.interceptorsRoot ?? [],
-      { request, ...handleOptions },
-      async (interceptorRootOptions) => {
+      {
+        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 ?? [],
-            interceptorRootOptions,
-            async ({ request: request2, context }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
+            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 client = createProcedureClient(match.procedure, {
-                context,
+              const clientOptions = {
+                context: interceptorOptions2.context,
                 path: match.path
-              });
-              const input = await this.codec.decode(request2, match.params, match.procedure);
-              const output = await client(input, { signal: request2.signal });
+              };
+              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,
@@ -57,7 +66,10 @@ var StandardHandler = class {
             }
           );
         } catch (e) {
-          const error = toORPCError(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,
@@ -70,11 +82,27 @@ var StandardHandler = class {
 };
 
 // src/adapters/standard/rpc-serializer.ts
-import { findDeepMatches, isPlainObject, set } from "@orpc/shared";
+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 (data instanceof Blob) {
-      return 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);
@@ -90,8 +118,23 @@ var RPCSerializer = class {
     return form;
   }
   deserialize(serialized) {
-    if (serialized instanceof Blob) {
-      return 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);
@@ -126,7 +169,7 @@ function serializeRPCJson(value, segments = [], meta = []) {
     meta.push(["url", segments]);
     return { json: value.toString(), meta };
   }
-  if (isPlainObject(value)) {
+  if (isObject(value)) {
     const json = {};
     for (const k in value) {
       json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
@@ -305,4 +348,4 @@ export {
   RPCCodec,
   RPCMatcher
 };
-//# sourceMappingURL=chunk-SUGWQSMQ.js.map
+//# sourceMappingURL=chunk-NXEANHUK.js.map

package/dist/{chunk-OWMUECGT.js → chunk-XI6WGCB3.js}

@@ -8,6 +8,11 @@ var CompositePlugin = class {
       plugin.init?.(options);
     }
   }
+  beforeCreateProcedureClient(clientOptions, interceptorOptions) {
+    for (const plugin of this.plugins) {
+      plugin.beforeCreateProcedureClient?.(clientOptions, interceptorOptions);
+    }
+  }
 };
 
 // src/plugins/cors.ts
@@ -16,7 +21,7 @@ var CORSPlugin = class {
   options;
   constructor(options) {
     const defaults = {
-      origin: "*",
+      origin: (origin) => origin,
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
     };
     this.options = {
@@ -60,12 +65,21 @@ var CORSPlugin = class {
       const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
       const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
       const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
-      if (allowedOriginArr.includes(origin) || allowedOriginArr.includes("*")) {
-        result.response.headers["access-control-allow-origin"] = origin;
-      }
-      if (!allowedOriginArr.includes("*")) {
+      if (allowedOriginArr.includes("*")) {
+        result.response.headers["access-control-allow-origin"] = "*";
+      } else {
+        if (allowedOriginArr.includes(origin)) {
+          result.response.headers["access-control-allow-origin"] = origin;
+        }
         result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
       }
+      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
+      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
+      if (allowedTimingOriginArr.includes("*")) {
+        result.response.headers["timing-allow-origin"] = "*";
+      } else if (allowedTimingOriginArr.includes(origin)) {
+        result.response.headers["timing-allow-origin"] = origin;
+      }
       if (this.options.credentials) {
         result.response.headers["access-control-allow-credentials"] = "true";
       }
@@ -108,4 +122,4 @@ export {
   CORSPlugin,
   ResponseHeadersPlugin
 };
-//# sourceMappingURL=chunk-OWMUECGT.js.map
+//# sourceMappingURL=chunk-XI6WGCB3.js.map

package/dist/{chunk-NOA3GBJQ.js → chunk-XXBE6CYD.js}

@@ -63,30 +63,29 @@ function middlewareOutputFn(output) {
 
 // src/procedure-client.ts
 import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
-import { executeWithHooks, toError, value } from "@orpc/shared";
+import { intercept, toError, value } from "@orpc/shared";
 function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
     const path = options?.path ?? [];
     const { default: procedure } = await unlazy(lazyableProcedure);
-    const context = await value(options?.context ?? {}, callerOptions?.context);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options?.context ?? {}, clientContext);
     const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const executeOptions = {
-      input,
-      context,
-      errors,
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
     try {
-      const output = await executeWithHooks({
-        hooks: options,
-        input,
-        context,
-        meta: executeOptions,
-        execute: () => executeProcedureInternal(procedure, executeOptions)
-      });
-      return output;
+      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)
+      );
     } catch (e) {
       if (!(e instanceof ORPCError)) {
         throw toError(e);
@@ -377,4 +376,4 @@ export {
   convertPathToHttpPath,
   createContractedProcedure
 };
-//# sourceMappingURL=chunk-NOA3GBJQ.js.map
+//# sourceMappingURL=chunk-XXBE6CYD.js.map

package/dist/fetch.js

@@ -1,18 +1,10 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-JBPBLCBJ.js";
-import "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+  RPCHandler
+} from "./chunk-L4ESXQX7.js";
+import "./chunk-NXEANHUK.js";
+import "./chunk-XXBE6CYD.js";
+import "./chunk-XI6WGCB3.js";
 export {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  RPCHandler
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,13 +1,9 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-JBPBLCBJ.js";
-import "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+  RPCHandler
+} from "./chunk-L4ESXQX7.js";
+import "./chunk-NXEANHUK.js";
+import "./chunk-XXBE6CYD.js";
+import "./chunk-XI6WGCB3.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
@@ -26,17 +22,13 @@ function createMiddleware(handler, ...[options]) {
     const context = await value(options?.context ?? {}, c);
     const { matched, response } = await handler.handle(request, { ...options, context });
     if (matched) {
-      return c.body(response.body, response);
+      return c.newResponse(response.body, response);
     }
     await next();
   };
 }
 export {
   RPCHandler,
-  createMiddleware,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  createMiddleware
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-NOA3GBJQ.js";
+} from "./chunk-XXBE6CYD.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
@@ -50,10 +50,14 @@ function decorateMiddleware(middleware) {
   decorated.concat = (concatMiddleware, mapInput) => {
     const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
     const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const next = async (...[nextOptions]) => {
-        return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
-      };
-      const merged = middleware({ ...options, next }, input, output, ...rest);
+      const merged = middleware({
+        ...options,
+        next: (...[nextOptions1]) => mapped({
+          ...options,
+          context: { ...options.context, ...nextOptions1?.context },
+          next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
+        }, input, output, ...rest)
+      }, input, output, ...rest);
       return merged;
     });
     return concatted;
@@ -357,7 +361,8 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { eventIterator, isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { getEventMeta, withEventMeta } from "@orpc/server-standard";
 import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
 export {
   Builder,
@@ -378,8 +383,10 @@ export {
   deepSetLazyRouterPrefix,
   eachAllContractProcedure,
   eachContractProcedure,
+  eventIterator,
   fallbackConfig,
   flatLazy,
+  getEventMeta,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
@@ -399,6 +406,7 @@ export {
   safe,
   setRouterContract,
   type,
-  unlazy
+  unlazy,
+  withEventMeta
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,13 +1,9 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-JBPBLCBJ.js";
-import "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
+  RPCHandler
+} from "./chunk-L4ESXQX7.js";
+import "./chunk-NXEANHUK.js";
+import "./chunk-XXBE6CYD.js";
+import "./chunk-XI6WGCB3.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -30,10 +26,6 @@ function serve(handler, ...[options]) {
 }
 export {
   RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  serve,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  serve
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -2,154 +2,12 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-SUGWQSMQ.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OWMUECGT.js";
-
-// src/adapters/node/utils.ts
-import { Buffer, File } from "node:buffer";
-import { Readable } from "node:stream";
-import { once } from "@orpc/shared";
-import cd from "content-disposition";
-function nodeHttpToStandardRequest(req, res) {
-  const method = req.method ?? "GET";
-  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = req.headers.host ?? "localhost";
-  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  return {
-    raw: { request: req, response: res },
-    method,
-    url,
-    headers: req.headers,
-    body: once(() => {
-      return nodeHttpRequestToStandardBody(req);
-    }),
-    get signal() {
-      const signal = nodeHttpResponseToAbortSignal(res);
-      Object.defineProperty(this, "signal", { value: signal, writable: true });
-      return signal;
-    },
-    set signal(value) {
-      Object.defineProperty(this, "signal", { value, writable: true });
-    }
-  };
-}
-function nodeHttpResponseSendStandardResponse(res, standardResponse) {
-  return new Promise((resolve, reject) => {
-    res.on("error", reject);
-    res.on("finish", resolve);
-    if (standardResponse.body === void 0) {
-      res.writeHead(standardResponse.status, standardResponse.headers);
-      res.end();
-      return;
-    }
-    if (standardResponse.body instanceof Blob) {
-      const resHeaders = {
-        ...standardResponse.headers,
-        "content-type": standardResponse.body.type,
-        "content-length": standardResponse.body.size.toString()
-      };
-      if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
-        resHeaders["content-disposition"] = cd(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
-      }
-      res.writeHead(standardResponse.status, resHeaders);
-      Readable.fromWeb(
-        standardResponse.body.stream()
-        // Conflict between types=node and lib=dom so we need to cast it
-      ).pipe(res);
-      return;
-    }
-    if (standardResponse.body instanceof FormData) {
-      const response = new Response(standardResponse.body);
-      res.writeHead(standardResponse.status, {
-        ...standardResponse.headers,
-        "content-type": response.headers.get("content-type")
-      });
-      Readable.fromWeb(
-        response.body
-        // Conflict between types=node and lib=dom so we need to cast it
-      ).pipe(res);
-      return;
-    }
-    if (standardResponse.body instanceof URLSearchParams) {
-      res.writeHead(standardResponse.status, {
-        ...standardResponse.headers,
-        "content-type": "application/x-www-form-urlencoded"
-      });
-      const string2 = standardResponse.body.toString();
-      res.end(string2);
-      return;
-    }
-    res.writeHead(standardResponse.status, {
-      ...standardResponse.headers,
-      "content-type": "application/json"
-    });
-    const string = JSON.stringify(standardResponse.body);
-    res.end(string);
-  });
-}
-async function nodeHttpRequestToStandardBody(req) {
-  const method = req.method ?? "GET";
-  if (method === "GET" || method === "HEAD") {
-    return void 0;
-  }
-  const contentDisposition = req.headers["content-disposition"];
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-  const contentType = req.headers["content-type"];
-  if (fileName) {
-    return await streamToFile(req, fileName, contentType || "application/octet-stream");
-  }
-  if (!contentType || contentType.startsWith("application/json")) {
-    const text = await streamToString(req);
-    if (!text) {
-      return void 0;
-    }
-    return JSON.parse(text);
-  }
-  if (contentType.startsWith("multipart/form-data")) {
-    return await streamToFormData(req, contentType);
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    const text = await streamToString(req);
-    return new URLSearchParams(text);
-  }
-  if (contentType.startsWith("text/")) {
-    return await streamToString(req);
-  }
-  return streamToFile(req, "blob", contentType);
-}
-function streamToFormData(stream, contentType) {
-  const response = new Response(stream, {
-    // Conflict between types=node and lib=dom so we need to cast it
-    headers: {
-      "content-type": contentType
-    }
-  });
-  return response.formData();
-}
-async function streamToString(stream) {
-  let string = "";
-  for await (const chunk of stream) {
-    string += chunk.toString();
-  }
-  return string;
-}
-async function streamToFile(stream, fileName, contentType) {
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-  }
-  return new File([Buffer.concat(chunks)], fileName, { type: contentType });
-}
-function nodeHttpResponseToAbortSignal(res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
-  return controller.signal;
-}
+} from "./chunk-NXEANHUK.js";
+import "./chunk-XXBE6CYD.js";
+import "./chunk-XI6WGCB3.js";
 
 // src/adapters/node/rpc-handler.ts
+import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";
 var RPCHandler = class {
   standardHandler;
   constructor(router, options) {
@@ -158,18 +16,16 @@ var RPCHandler = class {
     this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
   async handle(req, res, ...rest) {
-    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const standardRequest = toStandardRequest(req, res);
     const result = await this.standardHandler.handle(standardRequest, ...rest);
     if (!result.matched) {
       return { matched: false };
     }
-    await nodeHttpResponseSendStandardResponse(res, result.response);
+    await sendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
 export {
-  RPCHandler,
-  nodeHttpResponseSendStandardResponse,
-  nodeHttpToStandardRequest
+  RPCHandler
 };
 //# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -2,7 +2,7 @@ import {
   CORSPlugin,
   CompositePlugin,
   ResponseHeadersPlugin
-} from "./chunk-OWMUECGT.js";
+} from "./chunk-XI6WGCB3.js";
 export {
   CORSPlugin,
   CompositePlugin,

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

@@ -1,4 +1,3 @@
 export * from './rpc-handler';
 export * from './types';
-export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/rpc-handler.d.ts

@@ -1,10 +1,11 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
 import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
 import type { FetchHandler, FetchHandleResult } from './types';
 export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
     private readonly standardHandler;
     constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,5 +1,6 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
+import type { StandardHandleOptions } from '../standard';
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -8,6 +9,6 @@ export type FetchHandleResult = {
     response: undefined;
 };
 export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map