@orpc/server 0.0.0-next.b6b0cc3 → 0.0.0-next.b77809d

package/dist/index.mjs

@@ -1,11 +1,11 @@
-import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter } from '@orpc/contract';
+import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter, fallbackContractConfig } from '@orpc/contract';
 export { ValidationError, eventIterator, type } from '@orpc/contract';
-import { P as Procedure, b as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, d as isLazy, f as createAssertedLazyProcedure, g as getRouter } from './shared/server.DG7Tamti.mjs';
-export { L as LAZY_SYMBOL, p as call, r as createAccessibleLazyRouter, a as createContractedProcedure, h as createORPCErrorConstructorMap, q as getHiddenRouterContract, j as getLazyMeta, n as isStartWithMiddlewares, m as mergeCurrentContext, o as mergeMiddlewares, k as middlewareOutputFn, w as resolveContractProcedures, t as traverseContractProcedures, u as unlazy, x as unlazyRouter, v as validateORPCError } from './shared/server.DG7Tamti.mjs';
+import { P as Procedure, b as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, u as unlazy, g as getRouter, i as isProcedure, d as isLazy, f as createAssertedLazyProcedure } from './shared/server.B_fj3X5m.mjs';
+export { L as LAZY_SYMBOL, p as call, r as createAccessibleLazyRouter, a as createContractedProcedure, h as createORPCErrorConstructorMap, q as getHiddenRouterContract, j as getLazyMeta, n as isStartWithMiddlewares, m as mergeCurrentContext, o as mergeMiddlewares, k as middlewareOutputFn, w as resolveContractProcedures, t as traverseContractProcedures, x as unlazyRouter, v as validateORPCError } from './shared/server.B_fj3X5m.mjs';
 import { toORPCError } from '@orpc/client';
 export { ORPCError, isDefinedError, safe } from '@orpc/client';
 import { resolveMaybeOptionalOptions } from '@orpc/shared';
-export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 const DEFAULT_CONFIG = {
@@ -151,7 +151,7 @@ class Builder {
   /**
    * Sets or overrides the config.
    *
-   * @see {@link https://orpc.unnoq.com/docs/lifecycle#middlewares-order Middlewares Order Docs}
+   * @see {@link https://orpc.unnoq.com/docs/client/server-side#middlewares-order Middlewares Order Docs}
    * @see {@link https://orpc.unnoq.com/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
    */
   $config(config) {
@@ -448,12 +448,26 @@ function implement(contract, config = {}) {
   return impl;
 }
 
+function inferRPCMethodFromRouter(router) {
+  return async (_, path) => {
+    const { default: procedure } = await unlazy(getRouter(router, path));
+    if (!isProcedure(procedure)) {
+      throw new Error(
+        `[inferRPCMethodFromRouter] No valid procedure found at path "${path.join(".")}". This may happen when the router is not properly configured.`
+      );
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    return method === "HEAD" ? "GET" : method;
+  };
+}
+
 function createRouterClient(router, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
   if (isProcedure(router)) {
-    const caller = createProcedureClient(router, resolveMaybeOptionalOptions(rest));
+    const caller = createProcedureClient(router, options);
     return caller;
   }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), resolveMaybeOptionalOptions(rest)) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
@@ -472,4 +486,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, Procedure, addMiddleware, createActionableClient, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, os, setHiddenRouterContract };
+export { Builder, DecoratedProcedure, Procedure, addMiddleware, createActionableClient, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, inferRPCMethodFromRouter, isLazy, isProcedure, lazy, os, setHiddenRouterContract, unlazy };

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 { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.Dq8xr7PQ.mjs';
-import { C as Context, F as ProcedureClientInterceptorOptions } from '../shared/server.DD2C4ujN.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';
 
@@ -33,10 +33,10 @@ interface BatchHandlerOptions<T extends Context> {
     headers?: Value<Promisable<StandardHeaders>, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
 }
 /**
- * The Batch Request/Response Plugin allows you to combine multiple requests and responses into a single batch,
+ * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
  * reducing the overhead of sending each one separately.
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/batch-request-response Batch Request/Response Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/plugins/batch-requests Batch Requests Plugin Docs}
  */
 declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     private readonly maxSize;
@@ -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 { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.-ACo36I0.js';
-import { C as Context, F as ProcedureClientInterceptorOptions } from '../shared/server.DD2C4ujN.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';
 
@@ -33,10 +33,10 @@ interface BatchHandlerOptions<T extends Context> {
     headers?: Value<Promisable<StandardHeaders>, [responses: Promise<BatchResponseBodyItem>[], batchOptions: StandardHandlerInterceptorOptions<T>]>;
 }
 /**
- * The Batch Request/Response Plugin allows you to combine multiple requests and responses into a single batch,
+ * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
  * reducing the overhead of sending each one separately.
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/batch-request-response Batch Request/Response Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/plugins/batch-requests Batch Requests Plugin Docs}
  */
 declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     private readonly maxSize;
@@ -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 } from '@orpc/shared';
-import { parseBatchRequest, toBatchResponse } from '@orpc/standard-server/batch';
+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';
@@ -26,69 +27,80 @@ class BatchHandlerPlugin {
   init(options) {
     options.rootInterceptors ??= [];
     options.rootInterceptors.unshift(async (options2) => {
-      if (options2.request.headers["x-orpc-batch"] !== "1") {
+      const xHeader = flattenHeader(options2.request.headers["x-orpc-batch"]);
+      if (xHeader === void 0) {
         return options2.next();
       }
       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 = toBatchResponse({
-          status,
-          headers,
-          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 {
@@ -175,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 ??= [];
@@ -190,7 +218,7 @@ class ResponseHeadersPlugin {
       if (!result.matched) {
         return result;
       }
-      const responseHeaders = result.response.headers;
+      const responseHeaders = clone(result.response.headers);
       for (const [key, value] of resHeaders) {
         if (Array.isArray(responseHeaders[key])) {
           responseHeaders[key].push(value);
@@ -200,7 +228,13 @@ class ResponseHeadersPlugin {
           responseHeaders[key] = value;
         }
       }
-      return result;
+      return {
+        ...result,
+        response: {
+          ...result.response,
+          headers: responseHeaders
+        }
+      };
     });
   }
 }
@@ -248,4 +282,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };

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

@@ -0,0 +1,12 @@
+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;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/server.BEFBl-Cb.d.mts

@@ -0,0 +1,12 @@
+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;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

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

@@ -0,0 +1,32 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+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.DhJj-1X9.mjs';
+
+interface StandardRPCMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private pendingRouters;
+    constructor(options?: StandardRPCMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions, StandardRPCMatcherOptions {
+}
+declare class StandardRPCHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options?: StandardRPCHandlerOptions<T>);
+}
+
+export { StandardRPCHandler as a, StandardRPCMatcher as c };
+export type { StandardRPCHandlerOptions as S, StandardRPCMatcherOptions as b };

package/dist/shared/{server.DG7Tamti.mjs → server.B_fj3X5m.mjs}

@@ -1,6 +1,7 @@
 import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, asyncIteratorWithSpan } from '@orpc/shared';
 import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { value, intercept } from '@orpc/shared';
+import { HibernationEventIterator } from '@orpc/standard-server';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -71,14 +72,15 @@ function createORPCErrorConstructorMap(errors) {
       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;
@@ -106,28 +108,45 @@ 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);
     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)
+          );
+        }
       );
+      if (isAsyncIteratorObject(output)) {
+        if (output instanceof HibernationEventIterator) {
+          return output;
+        }
+        return asyncIteratorWithSpan(
+          { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+          output
+        );
+      }
+      return output;
     } catch (e) {
       if (!(e instanceof ORPCError)) {
         throw e;
@@ -142,31 +161,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;
@@ -178,17 +207,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);
     }
@@ -361,7 +401,8 @@ function createContractedProcedure(procedure, contract) {
   });
 }
 function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
+  const options = resolveMaybeOptionalOptions(rest);
+  return createProcedureClient(procedure, options)(input, options);
 }
 
 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, validateORPCError as v, resolveContractProcedures as w, unlazyRouter as x };

package/dist/shared/{server.-ACo36I0.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, f as AnyRouter, h as AnyProcedure, F as ProcedureClientInterceptorOptions } from './server.DD2C4ujN.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;
@@ -70,5 +70,5 @@ declare class StandardHandler<T extends Context> {
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as i };
-export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardCodec as c, StandardParams as d, StandardMatcher as e, StandardMatchResult as f, StandardHandleOptions as g, StandardHandleResult as h };
+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 };