@orpc/server 0.0.0-next.caefe3a → 0.0.0-next.cc4cb21

package/README.md

@@ -0,0 +1,118 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/server">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fserver?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/server`
+
+Build your API or implement API contract. Read the [documentation](https://orpc.unnoq.com/docs/getting-started) for more information.
+
+```ts
+import type { IncomingHttpHeaders } from 'node:http'
+import { ORPCError, os } from '@orpc/server'
+import { z } from 'zod'
+
+const PlanetSchema = z.object({
+  id: z.number().int().min(1),
+  name: z.string(),
+  description: z.string().optional(),
+})
+
+export const listPlanet = os
+  .input(
+    z.object({
+      limit: z.number().int().min(1).max(100).optional(),
+      cursor: z.number().int().min(0).default(0),
+    }),
+  )
+  .handler(async ({ input }) => {
+    // your list code here
+    return [{ id: 1, name: 'name' }]
+  })
+
+export const findPlanet = os
+  .input(PlanetSchema.pick({ id: true }))
+  .handler(async ({ input }) => {
+    // your find code here
+    return { id: 1, name: 'name' }
+  })
+
+export const createPlanet = os
+  .$context<{ headers: IncomingHttpHeaders }>()
+  .use(({ context, next }) => {
+    const user = parseJWT(context.headers.authorization?.split(' ')[1])
+
+    if (user) {
+      return next({ context: { user } })
+    }
+
+    throw new ORPCError('UNAUTHORIZED')
+  })
+  .input(PlanetSchema.omit({ id: true }))
+  .handler(async ({ input, context }) => {
+    // your create code here
+    return { id: 1, name: 'name' }
+  })
+
+export const router = { planet: { list: listPlanet, find: findPlanet, create: createPlanet } }
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/chunk-EWOWWNDI.js

@@ -0,0 +1,182 @@
+import {
+  convertPathToHttpPath,
+  createContractedProcedure,
+  createProcedureClient,
+  eachContractProcedure,
+  getRouterChild,
+  isProcedure,
+  unlazy
+} from "./chunk-MHVECKBC.js";
+import {
+  CompositePlugin
+} from "./chunk-TXHKQO7N.js";
+
+// src/adapters/standard/handler.ts
+import { ORPCError, toORPCError } from "@orpc/client";
+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.rootInterceptors ?? [],
+      {
+        request,
+        ...options,
+        context: options?.context ?? {}
+        // context is optional only when all fields are optional so we can safely force it to have a context
+      },
+      async (interceptorOptions) => {
+        let isDecoding = false;
+        try {
+          return await intercept(
+            this.options.interceptors ?? [],
+            interceptorOptions,
+            async (interceptorOptions2) => {
+              const method = interceptorOptions2.request.method;
+              const url = interceptorOptions2.request.url;
+              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
+              const match = await this.matcher.match(method, pathname);
+              if (!match) {
+                return { matched: false, response: void 0 };
+              }
+              const client = createProcedureClient(match.procedure, {
+                context: interceptorOptions2.context,
+                path: match.path,
+                interceptors: this.options.clientInterceptors
+              });
+              isDecoding = true;
+              const input = await this.codec.decode(request, match.params, match.procedure);
+              isDecoding = false;
+              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
+              const output = await client(input, { signal: request.signal, lastEventId });
+              const response = this.codec.encode(output, match.procedure);
+              return {
+                matched: true,
+                response
+              };
+            }
+          );
+        } catch (e) {
+          const error = isDecoding ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = this.codec.encodeError(error);
+          return {
+            matched: true,
+            response
+          };
+        }
+      }
+    );
+  }
+};
+
+// src/adapters/standard/rpc-codec.ts
+import { RPCSerializer } from "@orpc/client/rpc";
+import { parseEmptyableJSON } from "@orpc/shared";
+var RPCCodec = class {
+  serializer;
+  constructor(options = {}) {
+    this.serializer = options.serializer ?? new RPCSerializer();
+  }
+  async decode(request, _params, _procedure) {
+    const serialized = request.method === "GET" ? parseEmptyableJSON(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,
+  RPCCodec,
+  RPCMatcher
+};
+//# sourceMappingURL=chunk-EWOWWNDI.js.map

package/dist/{chunk-OEPDHGQ4.js → chunk-MHVECKBC.js}

@@ -62,31 +62,74 @@ function middlewareOutputFn(output) {
 }
 
 // src/procedure-client.ts
-import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
+import { ORPCError as ORPCError2 } from "@orpc/client";
+import { ValidationError } from "@orpc/contract";
 import { intercept, toError, value } from "@orpc/shared";
+
+// src/error.ts
+import { fallbackORPCErrorStatus, ORPCError } from "@orpc/client";
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
+      }
+      const item = (...[options]) => {
+        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
+        });
+      };
+      return item;
+    }
+  });
+  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 });
+}
+
+// src/procedure-client.ts
 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 interceptorOptions = {
-      context,
-      input,
-      // input only optional when it undefinable so we can safely cast it
-      errors,
-      path,
-      procedure,
-      signal: callerOptions?.signal
-    };
     try {
       return await intercept(
         options?.interceptors ?? [],
-        interceptorOptions,
-        (interceptorOptions2) => executeProcedureInternal(interceptorOptions2.procedure, interceptorOptions2)
+        {
+          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)) {
+      if (!(e instanceof ORPCError2)) {
         throw toError(e);
       }
       const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
@@ -101,7 +144,7 @@ async function validateInput(procedure, input) {
   }
   const result = await schema["~standard"].validate(input);
   if (result.issues) {
-    throw new ORPCError("BAD_REQUEST", {
+    throw new ORPCError2("BAD_REQUEST", {
       message: "Input validation failed",
       data: {
         issues: result.issues
@@ -118,7 +161,7 @@ async function validateOutput(procedure, output) {
   }
   const result = await schema["~standard"].validate(output);
   if (result.issues) {
-    throw new ORPCError("INTERNAL_SERVER_ERROR", {
+    throw new ORPCError2("INTERNAL_SERVER_ERROR", {
       message: "Output validation failed",
       cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
     });
@@ -375,4 +418,4 @@ export {
   convertPathToHttpPath,
   createContractedProcedure
 };
-//# sourceMappingURL=chunk-OEPDHGQ4.js.map
+//# sourceMappingURL=chunk-MHVECKBC.js.map

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

@@ -16,7 +16,7 @@ var CORSPlugin = class {
   options;
   constructor(options) {
     const defaults = {
-      origin: "*",
+      origin: (origin) => origin,
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
     };
     this.options = {
@@ -25,8 +25,8 @@ var CORSPlugin = class {
     };
   }
   init(options) {
-    options.interceptorsRoot ??= [];
-    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
       if (interceptorOptions.request.method === "OPTIONS") {
         const resHeaders = {};
         if (this.options.maxAge !== void 0) {
@@ -52,7 +52,7 @@ var CORSPlugin = class {
       }
       return interceptorOptions.next();
     });
-    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
       const result = await interceptorOptions.next();
       if (!result.matched) {
         return result;
@@ -60,12 +60,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";
       }
@@ -80,8 +89,8 @@ var CORSPlugin = class {
 // src/plugins/response-headers.ts
 var ResponseHeadersPlugin = class {
   init(options) {
-    options.interceptorsRoot ??= [];
-    options.interceptorsRoot.push(async (interceptorOptions) => {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push(async (interceptorOptions) => {
       const headers = new Headers();
       interceptorOptions.context.resHeaders = headers;
       const result = await interceptorOptions.next();
@@ -108,4 +117,4 @@ export {
   CORSPlugin,
   ResponseHeadersPlugin
 };
-//# sourceMappingURL=chunk-OWMUECGT.js.map
+//# sourceMappingURL=chunk-TXHKQO7N.js.map

package/dist/chunk-XT6IYOIS.js

@@ -0,0 +1,32 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-EWOWWNDI.js";
+
+// src/adapters/fetch/rpc-handler.ts
+import { toFetchResponse, toStandardRequest } from "@orpc/standard-server-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-XT6IYOIS.js.map

package/dist/fetch.js

@@ -1,18 +1,10 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-M65OCXNG.js";
-import "./chunk-PZ44ZPVC.js";
-import "./chunk-OEPDHGQ4.js";
-import "./chunk-OWMUECGT.js";
+  RPCHandler
+} from "./chunk-XT6IYOIS.js";
+import "./chunk-EWOWWNDI.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.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-M65OCXNG.js";
-import "./chunk-PZ44ZPVC.js";
-import "./chunk-OEPDHGQ4.js";
-import "./chunk-OWMUECGT.js";
+  RPCHandler
+} from "./chunk-XT6IYOIS.js";
+import "./chunk-EWOWWNDI.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.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-OEPDHGQ4.js";
+} from "./chunk-MHVECKBC.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,8 +361,10 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { isDefinedError, ORPCError, safe } from "@orpc/client";
+import { eventIterator, type, ValidationError } from "@orpc/contract";
 import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
+import { getEventMeta, withEventMeta } from "@orpc/standard-server";
 export {
   Builder,
   DecoratedProcedure,
@@ -378,8 +384,10 @@ export {
   deepSetLazyRouterPrefix,
   eachAllContractProcedure,
   eachContractProcedure,
+  eventIterator,
   fallbackConfig,
   flatLazy,
+  getEventMeta,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
@@ -399,6 +407,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-M65OCXNG.js";
-import "./chunk-PZ44ZPVC.js";
-import "./chunk-OEPDHGQ4.js";
-import "./chunk-OWMUECGT.js";
+  RPCHandler
+} from "./chunk-XT6IYOIS.js";
+import "./chunk-EWOWWNDI.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.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