@orpc/server 0.0.0-next.14dd190 → 0.0.0-next.150aa84

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardRequest, StandardHeaders } from '@orpc/standard-server';
 import { BatchResponseBodyItem } from '@orpc/standard-server/batch';
-import { d as StandardHandlerInterceptorOptions, g as StandardHandlerPlugin, e as StandardHandlerOptions } from '../shared/server.DHgXKx3q.mjs';
-import { C as Context, d as ProcedureClientInterceptorOptions } from '../shared/server.wMv480px.mjs';
+import { d as StandardHandlerInterceptorOptions, g as StandardHandlerPlugin, e as StandardHandlerOptions } from '../shared/server.gqRxT-yN.mjs';
+import { C as Context, d as ProcedureClientInterceptorOptions } from '../shared/server.CYNGeoCm.mjs';
 import { Meta, ORPCError as ORPCError$1 } from '@orpc/contract';
 import { ORPCError } from '@orpc/client';
 
@@ -69,6 +69,19 @@ declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T>
     init(options: StandardHandlerOptions<T>): void;
 }
 
+interface RequestHeadersPluginContext {
+    reqHeaders?: Headers;
+}
+/**
+ * The Request Headers Plugin injects a `reqHeaders` instance into the context,
+ * allowing access to request headers in oRPC.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/request-headers Request Headers Plugin Docs}
+ */
+declare class RequestHeadersPlugin<T extends RequestHeadersPluginContext> implements StandardHandlerPlugin<T> {
+    init(options: StandardHandlerOptions<T>): void;
+}
+
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
@@ -152,5 +165,5 @@ declare class StrictGetMethodPlugin<T extends Context> implements StandardHandle
     init(options: StandardHandlerOptions<T>): void;
 }
 
-export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin, StrictGetMethodPlugin };
-export type { BatchHandlerOptions, CORSOptions, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions, StrictGetMethodPluginOptions };
+export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin, StrictGetMethodPlugin };
+export type { BatchHandlerOptions, CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions, StrictGetMethodPluginOptions };

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardRequest, StandardHeaders } from '@orpc/standard-server';
 import { BatchResponseBodyItem } from '@orpc/standard-server/batch';
-import { d as StandardHandlerInterceptorOptions, g as StandardHandlerPlugin, e as StandardHandlerOptions } from '../shared/server.DVBSOxWU.js';
-import { C as Context, d as ProcedureClientInterceptorOptions } from '../shared/server.wMv480px.js';
+import { d as StandardHandlerInterceptorOptions, g as StandardHandlerPlugin, e as StandardHandlerOptions } from '../shared/server.Bmh5xd4n.js';
+import { C as Context, d as ProcedureClientInterceptorOptions } from '../shared/server.CYNGeoCm.js';
 import { Meta, ORPCError as ORPCError$1 } from '@orpc/contract';
 import { ORPCError } from '@orpc/client';
 
@@ -69,6 +69,19 @@ declare class CORSPlugin<T extends Context> implements StandardHandlerPlugin<T>
     init(options: StandardHandlerOptions<T>): void;
 }
 
+interface RequestHeadersPluginContext {
+    reqHeaders?: Headers;
+}
+/**
+ * The Request Headers Plugin injects a `reqHeaders` instance into the context,
+ * allowing access to request headers in oRPC.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/request-headers Request Headers Plugin Docs}
+ */
+declare class RequestHeadersPlugin<T extends RequestHeadersPluginContext> implements StandardHandlerPlugin<T> {
+    init(options: StandardHandlerOptions<T>): void;
+}
+
 interface ResponseHeadersPluginContext {
     resHeaders?: Headers;
 }
@@ -152,5 +165,5 @@ declare class StrictGetMethodPlugin<T extends Context> implements StandardHandle
     init(options: StandardHandlerOptions<T>): void;
 }
 
-export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin, StrictGetMethodPlugin };
-export type { BatchHandlerOptions, CORSOptions, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions, StrictGetMethodPluginOptions };
+export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin, StrictGetMethodPlugin };
+export type { BatchHandlerOptions, CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions, StrictGetMethodPluginOptions };

package/dist/plugins/index.mjs

@@ -1,6 +1,7 @@
-import { value, isAsyncIteratorObject, clone } from '@orpc/shared';
+import { runWithSpan, value, setSpanError, isAsyncIteratorObject, clone } from '@orpc/shared';
 import { flattenHeader } from '@orpc/standard-server';
 import { parseBatchRequest, toBatchResponse } from '@orpc/standard-server/batch';
+import { toFetchHeaders } from '@orpc/standard-server-fetch';
 import { ORPCError } from '@orpc/client';
 export { S as StrictGetMethodPlugin } from '../shared/server.BW-nUGgA.mjs';
 import '@orpc/contract';
@@ -32,65 +33,74 @@ class BatchHandlerPlugin {
       }
       let isParsing = false;
       try {
-        isParsing = true;
-        const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
-        isParsing = false;
-        const maxSize = await value(this.maxSize, options2);
-        if (parsed.length > maxSize) {
-          return {
-            matched: true,
-            response: {
-              status: 413,
-              headers: {},
-              body: "Batch request size exceeds the maximum allowed size"
-            }
-          };
-        }
-        const responses = parsed.map(
-          (request, index) => {
-            const mapped = this.mapRequestItem(request, options2);
-            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
-              if (matched) {
-                if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
-                  return {
-                    index,
-                    status: 500,
-                    headers: {},
-                    body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
-                  };
-                }
-                return { ...response2, index };
+        return await runWithSpan({ name: "handle_batch_request" }, async (span) => {
+          const mode = xHeader === "buffered" ? "buffered" : "streaming";
+          isParsing = true;
+          const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
+          isParsing = false;
+          span?.setAttribute("batch.mode", mode);
+          span?.setAttribute("batch.size", parsed.length);
+          const maxSize = await value(this.maxSize, options2);
+          if (parsed.length > maxSize) {
+            const message = "Batch request size exceeds the maximum allowed size";
+            setSpanError(span, message);
+            return {
+              matched: true,
+              response: {
+                status: 413,
+                headers: {},
+                body: message
               }
-              return { index, status: 404, headers: {}, body: "No procedure matched" };
-            }).catch(() => {
-              return { index, status: 500, headers: {}, body: "Internal server error" };
-            });
+            };
           }
-        );
-        await Promise.race(responses);
-        const status = await value(this.successStatus, responses, options2);
-        const headers = await value(this.headers, responses, options2);
-        const response = await toBatchResponse({
-          status,
-          headers,
-          mode: xHeader === "buffered" ? "buffered" : "streaming",
-          body: async function* () {
-            const promises = [...responses];
-            while (true) {
-              const handling = promises.filter((p) => p !== void 0);
-              if (handling.length === 0) {
-                return;
-              }
-              const result = await Promise.race(handling);
-              promises[result.index] = void 0;
-              yield result;
+          const responses = parsed.map(
+            (request, index) => {
+              const mapped = this.mapRequestItem(request, options2);
+              return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
+                span?.addEvent(`response.${index}.${matched ? "success" : "not_matched"}`);
+                if (matched) {
+                  if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
+                    return {
+                      index,
+                      status: 500,
+                      headers: {},
+                      body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
+                    };
+                  }
+                  return { ...response2, index };
+                }
+                return { index, status: 404, headers: {}, body: "No procedure matched" };
+              }).catch((err) => {
+                Promise.reject(err);
+                return { index, status: 500, headers: {}, body: "Internal server error" };
+              });
             }
-          }()
+          );
+          await Promise.race(responses);
+          const status = await value(this.successStatus, responses, options2);
+          const headers = await value(this.headers, responses, options2);
+          const response = await toBatchResponse({
+            status,
+            headers,
+            mode,
+            body: (async function* () {
+              const promises = [...responses];
+              while (true) {
+                const handling = promises.filter((p) => p !== void 0);
+                if (handling.length === 0) {
+                  return;
+                }
+                const result = await Promise.race(handling);
+                promises[result.index] = void 0;
+                yield result;
+              }
+            })()
+          });
+          return {
+            matched: true,
+            response
+          };
         });
-        return {
-          matched: true,
-          response
-        };
       } catch (cause) {
         if (isParsing) {
           return {
@@ -177,6 +187,22 @@ class CORSPlugin {
   }
 }
 
+class RequestHeadersPlugin {
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push((interceptorOptions) => {
+      const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
+      return interceptorOptions.next({
+        ...interceptorOptions,
+        context: {
+          ...interceptorOptions.context,
+          reqHeaders
+        }
+      });
+    });
+  }
+}
+
 class ResponseHeadersPlugin {
   init(options) {
     options.rootInterceptors ??= [];
@@ -256,4 +282,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };

package/dist/shared/{server.NeumLVdS.mjs → server.7jWaIryJ.mjs}

@@ -1,6 +1,7 @@
 import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
-import { resolveMaybeOptionalOptions, toArray, value, intercept } from '@orpc/shared';
-import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, asyncIteratorWithSpan } from '@orpc/shared';
+import { ORPCError, fallbackORPCErrorStatus, mapEventIterator } from '@orpc/client';
+import { HibernationEventIterator } from '@orpc/standard-server';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -115,27 +116,51 @@ function createProcedureClient(lazyableProcedure, ...rest) {
     const clientContext = callerOptions?.context ?? {};
     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(
-        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)
+      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 e;
+      if (isAsyncIteratorObject(output)) {
+        if (output instanceof HibernationEventIterator) {
+          return output;
+        }
+        return 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);
     }
   };
 }
@@ -144,31 +169,41 @@ 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 })
+        });
+      }
+      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 })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 async function executeProcedureInternal(procedure, options) {
   const middlewares = procedure["~orpc"].middlewares;
@@ -180,17 +215,28 @@ async function executeProcedureInternal(procedure, options) {
       currentInput = await validateInput(procedure, currentInput);
     }
     const mid = middlewares[index];
-    const output = mid ? (await mid({
-      ...options,
-      context,
-      next: async (...[nextOptions]) => {
-        const nextContext = nextOptions?.context ?? {};
-        return {
-          output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
-          context: nextContext
-        };
+    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;
       }
-    }, currentInput, middlewareOutputFn)).output : await procedure["~orpc"].handler({ ...options, context, input: currentInput });
+    ) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
+    );
     if (index === outputValidationIndex) {
       return await validateOutput(procedure, output);
     }

package/dist/shared/{server.CNZgPgce.d.ts → server.B7b2w3_i.d.ts}

@@ -1,5 +1,5 @@
-import { C as Context } from './server.wMv480px.js';
-import { b as StandardHandleOptions } from './server.DVBSOxWU.js';
+import { C as Context } from './server.CYNGeoCm.js';
+import { b as StandardHandleOptions } from './server.Bmh5xd4n.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.Cu-7se50.d.mts → server.BEFBl-Cb.d.mts}

@@ -1,5 +1,5 @@
-import { C as Context } from './server.wMv480px.mjs';
-import { b as StandardHandleOptions } from './server.DHgXKx3q.mjs';
+import { C as Context } from './server.CYNGeoCm.mjs';
+import { b as StandardHandleOptions } from './server.gqRxT-yN.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.CIL9uKTN.mjs → server.BHZCyRuJ.mjs}

@@ -1,8 +1,8 @@
 import { toHttpPath, StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
 import { ORPCError, toORPCError } from '@orpc/client';
-import { toArray, intercept, parseEmptyableJSON, NullProtoObj, value } from '@orpc/shared';
+import { toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, parseEmptyableJSON, NullProtoObj, value } from '@orpc/shared';
 import { flattenHeader } from '@orpc/standard-server';
-import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.NeumLVdS.mjs';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.7jWaIryJ.mjs';
 
 class CompositeStandardHandlerPlugin {
   plugins;
@@ -39,49 +39,74 @@ class StandardHandler {
       this.rootInterceptors,
       { ...options, request, prefix },
       async (interceptorOptions) => {
-        let isDecoding = false;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`);
-              if (!match) {
-                return { matched: false, response: void 0 };
+        return runWithSpan(
+          { name: `${request.method} ${request.url.pathname}` },
+          async (span) => {
+            let step;
+            try {
+              return await intercept(
+                this.interceptors,
+                interceptorOptions,
+                async ({ request: request2, context, prefix: prefix2 }) => {
+                  const method = request2.method;
+                  const url = request2.url;
+                  const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
+                  const match = await runWithSpan(
+                    { name: "find_procedure" },
+                    () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+                  );
+                  if (!match) {
+                    return { matched: false, response: void 0 };
+                  }
+                  span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
+                  span?.setAttribute("rpc.system", ORPC_NAME);
+                  span?.setAttribute("rpc.method", match.path.join("."));
+                  step = "decode_input";
+                  let input = await runWithSpan(
+                    { name: "decode_input" },
+                    () => this.codec.decode(request2, match.params, match.procedure)
+                  );
+                  step = void 0;
+                  if (isAsyncIteratorObject(input)) {
+                    input = asyncIteratorWithSpan(
+                      { name: "consume_event_iterator_input", signal: request2.signal },
+                      input
+                    );
+                  }
+                  const client = createProcedureClient(match.procedure, {
+                    context,
+                    path: match.path,
+                    interceptors: this.clientInterceptors
+                  });
+                  step = "call_procedure";
+                  const output = await client(input, {
+                    signal: request2.signal,
+                    lastEventId: flattenHeader(request2.headers["last-event-id"])
+                  });
+                  step = void 0;
+                  const response = this.codec.encode(output, match.procedure);
+                  return {
+                    matched: true,
+                    response
+                  };
+                }
+              );
+            } catch (e) {
+              if (step !== "call_procedure") {
+                setSpanError(span, e);
               }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              isDecoding = true;
-              const input = await this.codec.decode(request2, match.params, match.procedure);
-              isDecoding = false;
-              const output = await client(input, {
-                signal: request2.signal,
-                lastEventId: flattenHeader(request2.headers["last-event-id"])
-              });
-              const response = this.codec.encode(output, match.procedure);
+              const error = step === "decode_input" && !(e instanceof ORPCError) ? 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
               };
             }
-          );
-        } catch (e) {
-          const error = isDecoding && !(e instanceof ORPCError) ? 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
-          };
-        }
+          }
+        );
       }
     );
   }

package/dist/shared/{server.CC8z0B3U.d.mts → server.BU4WI18A.d.mts}

@@ -1,9 +1,9 @@
 import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { b as AnyRouter, C as Context, R as Router } from './server.wMv480px.mjs';
-import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.DHgXKx3q.mjs';
+import { b as AnyRouter, C as Context, R as Router } from './server.CYNGeoCm.mjs';
+import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.gqRxT-yN.mjs';
 import { HTTPPath } from '@orpc/client';
 import { Value } from '@orpc/shared';
-import { T as TraverseContractProcedureCallbackOptions } from './server.Cwq7K86l.mjs';
+import { T as TraverseContractProcedureCallbackOptions } from './server.DhJj-1X9.mjs';
 
 interface StandardRPCMatcherOptions {
     /**

package/dist/shared/{server.DVBSOxWU.d.ts → server.Bmh5xd4n.d.ts}

@@ -2,7 +2,7 @@ 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.wMv480px.js';
+import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.CYNGeoCm.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;

package/dist/shared/{server.wMv480px.d.mts → server.CYNGeoCm.d.mts}

@@ -29,7 +29,9 @@ interface Lazy<T> {
 }
 type Lazyable<T> = T | Lazy<T>;
 /**
- * Create a lazy thing.
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazy(...)` instead.
  */
 declare function lazy<T>(loader: () => Promise<{
     default: T;

package/dist/shared/{server.wMv480px.d.ts → server.CYNGeoCm.d.ts}

@@ -29,7 +29,9 @@ interface Lazy<T> {
 }
 type Lazyable<T> = T | Lazy<T>;
 /**
- * Create a lazy thing.
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazy(...)` instead.
  */
 declare function lazy<T>(loader: () => Promise<{
     default: T;

package/dist/shared/{server.DOwaI1le.d.ts → server.D0H-iaY3.d.ts}

@@ -1,9 +1,9 @@
 import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { b as AnyRouter, C as Context, R as Router } from './server.wMv480px.js';
-import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.DVBSOxWU.js';
+import { b as AnyRouter, C as Context, R as Router } from './server.CYNGeoCm.js';
+import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.Bmh5xd4n.js';
 import { HTTPPath } from '@orpc/client';
 import { Value } from '@orpc/shared';
-import { T as TraverseContractProcedureCallbackOptions } from './server.a_VzWVCm.js';
+import { T as TraverseContractProcedureCallbackOptions } from './server.jMTkVNIb.js';
 
 interface StandardRPCMatcherOptions {
     /**

package/dist/shared/{server.Cwq7K86l.d.mts → server.DhJj-1X9.d.mts}

@@ -1,5 +1,5 @@
 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.wMv480px.mjs';
+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.CYNGeoCm.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> & {