@orpc/server 0.0.0-next.752b165 → 0.0.0-next.756e0cb

package/dist/plugins/index.mjs

@@ -1,8 +1,9 @@
-import { value, isAsyncIteratorObject, clone } from '@orpc/shared';
+import { runWithSpan, value, setSpanError, isAsyncIteratorObject, AsyncIteratorClass, 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';
+export { S as StrictGetMethodPlugin } from '../shared/server.TEVCLCFC.mjs';
 import '@orpc/contract';
 
 class BatchHandlerPlugin {
@@ -32,65 +33,76 @@ 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 promises = [...responses];
+          const response = await toBatchResponse({
+            status,
+            headers,
+            mode,
+            body: new AsyncIteratorClass(
+              async () => {
+                const handling = promises.filter((p) => p !== void 0);
+                if (handling.length <= 0) {
+                  return { done: true, value: void 0 };
+                }
+                const value2 = await Promise.race(handling);
+                promises[value2.index] = void 0;
+                return { done: false, value: value2 };
+              },
+              async () => {
+              }
+            )
+          });
+          return {
+            matched: true,
+            response
+          };
         });
-        return {
-          matched: true,
-          response
-        };
       } catch (cause) {
         if (isParsing) {
           return {
@@ -177,6 +189,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 ??= [];
@@ -213,6 +241,47 @@ class ResponseHeadersPlugin {
   }
 }
 
+class experimental_RethrowHandlerPlugin {
+  filter;
+  CONTEXT_SYMBOL = Symbol("ORPC_RETHROW_HANDLER_PLUGIN_CONTEXT");
+  constructor(options) {
+    this.filter = options.filter;
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.interceptors ??= [];
+    options.rootInterceptors.push(async (options2) => {
+      const pluginContext = {};
+      const result = await options2.next({
+        ...options2,
+        context: {
+          ...options2.context,
+          [this.CONTEXT_SYMBOL]: pluginContext
+        }
+      });
+      if (pluginContext.error) {
+        throw pluginContext.error.value;
+      }
+      return result;
+    });
+    options.interceptors.unshift(async (options2) => {
+      const pluginContext = options2.context[this.CONTEXT_SYMBOL];
+      if (!pluginContext) {
+        throw new TypeError("[RethrowHandlerPlugin] Rethrow handler context has been corrupted or modified by another plugin or interceptor");
+      }
+      try {
+        return await options2.next();
+      } catch (error) {
+        if (value(this.filter, error, options2)) {
+          pluginContext.error = { value: error };
+          return { matched: false, response: void 0 };
+        }
+        throw error;
+      }
+    });
+  }
+}
+
 const SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL = Symbol("SIMPLE_CSRF_PROTECTION_CONTEXT");
 class SimpleCsrfProtectionHandlerPlugin {
   headerName;
@@ -256,4 +325,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin, experimental_RethrowHandlerPlugin };

package/dist/shared/{server.BX8Iro5z.d.ts → server.7cEtMB30.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.CRejaM08.js';
+import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.qKsRrdxW.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;

package/dist/shared/{server.VjZAmjFs.d.mts → server.B8gYOD5g.d.mts}

@@ -1,5 +1,5 @@
-import { C as Context } from './server.CRejaM08.mjs';
-import { b as StandardHandleOptions } from './server.De2J-WNx.mjs';
+import { C as Context } from './server.qKsRrdxW.mjs';
+import { b as StandardHandleOptions } from './server.BqadksTP.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.De2J-WNx.d.mts → server.BqadksTP.d.mts}

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

package/dist/shared/{server.Aqc4pYFD.mjs → server.Bxx6tqNe.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.DLJzqnSX.mjs';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.Ds4HPpvH.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.DrG30u7a.d.mts → server.C8_sRzQB.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.CRejaM08.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.qKsRrdxW.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> & {

package/dist/shared/{server.C-F_fMXW.d.mts → server.ChUyt5-i.d.mts}

@@ -1,9 +1,9 @@
 import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { b as AnyRouter, C as Context, R as Router } from './server.CRejaM08.mjs';
-import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.De2J-WNx.mjs';
+import { b as AnyRouter, C as Context, R as Router } from './server.qKsRrdxW.mjs';
+import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.BqadksTP.mjs';
 import { HTTPPath } from '@orpc/client';
 import { Value } from '@orpc/shared';
-import { T as TraverseContractProcedureCallbackOptions } from './server.DrG30u7a.mjs';
+import { T as TraverseContractProcedureCallbackOptions } from './server.C8_sRzQB.mjs';
 
 interface StandardRPCMatcherOptions {
     /**

package/dist/shared/{server.Bi2_bIHo.d.ts → server.ChyoA9XY.d.ts}

@@ -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.CRejaM08.js';
+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.qKsRrdxW.js';
 
 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> & {

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

@@ -1,6 +1,7 @@
-import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
-import { value, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
+import { isContractProcedure, validateORPCError, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@orpc/shared';
+import { ORPCError, mapEventIterator } from '@orpc/client';
+import { HibernationEventIterator } from '@orpc/standard-server';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -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;
@@ -86,54 +88,64 @@ function createORPCErrorConstructorMap(errors) {
   });
   return proxy;
 }
-async function validateORPCError(map, error) {
-  const { code, status, message, data, cause, defined } = error;
-  const config = map?.[error.code];
-  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
-    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
-  }
-  if (!config.data) {
-    return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
-  }
-  const validated = await config.data["~standard"].validate(error.data);
-  if (validated.issues) {
-    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
-  }
-  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
-}
 
 function middlewareOutputFn(output) {
   return { output, context: {} };
 }
 
-function createProcedureClient(lazyableProcedure, ...[options]) {
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
   return async (...[input, callerOptions]) => {
-    const path = options?.path ?? [];
+    const path = toArray(options.path);
     const { default: procedure } = await unlazy(lazyableProcedure);
     const clientContext = callerOptions?.context ?? {};
-    const context = await value(options?.context ?? {}, clientContext);
+    const context = await value(options.context ?? {}, clientContext);
     const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+    const validateError = async (e) => {
+      if (e instanceof ORPCError) {
+        return await validateORPCError(procedure["~orpc"].errorMap, e);
+      }
+      return e;
+    };
     try {
-      return await intercept(
-        options?.interceptors ?? [],
-        {
-          context,
-          input,
-          // input only optional when it undefinable so we can safely cast it
-          errors,
-          path,
-          procedure,
-          signal: callerOptions?.signal,
-          lastEventId: callerOptions?.lastEventId
-        },
-        (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+      const output = await runWithSpan(
+        { name: "call_procedure", signal: callerOptions?.signal },
+        (span) => {
+          span?.setAttribute("procedure.path", [...path]);
+          return intercept(
+            toArray(options.interceptors),
+            {
+              context,
+              input,
+              // input only optional when it undefinable so we can safely cast it
+              errors,
+              path,
+              procedure,
+              signal: callerOptions?.signal,
+              lastEventId: callerOptions?.lastEventId
+            },
+            (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+          );
+        }
       );
-    } catch (e) {
-      if (!(e instanceof ORPCError)) {
-        throw e;
+      if (isAsyncIteratorObject(output)) {
+        if (output instanceof HibernationEventIterator) {
+          return output;
+        }
+        return overlayProxy(output, mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
+          {
+            value: (v) => v,
+            error: (e) => validateError(e)
+          }
+        ));
       }
-      const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
-      throw validated;
+      return output;
+    } catch (e) {
+      throw await validateError(e);
     }
   };
 }
@@ -142,31 +154,49 @@ async function validateInput(procedure, input) {
   if (!schema) {
     return input;
   }
-  const result = await schema["~standard"].validate(input);
-  if (result.issues) {
-    throw new ORPCError("BAD_REQUEST", {
-      message: "Input validation failed",
-      data: {
-        issues: result.issues
-      },
-      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
+  return runWithSpan(
+    { name: "validate_input" },
+    async () => {
+      const result = await schema["~standard"].validate(input);
+      if (result.issues) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Input validation failed",
+          data: {
+            issues: result.issues
+          },
+          cause: new ValidationError({
+            message: "Input validation failed",
+            issues: result.issues,
+            data: input
+          })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 async function validateOutput(procedure, output) {
   const schema = procedure["~orpc"].outputSchema;
   if (!schema) {
     return output;
   }
-  const result = await schema["~standard"].validate(output);
-  if (result.issues) {
-    throw new ORPCError("INTERNAL_SERVER_ERROR", {
-      message: "Output validation failed",
-      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
-    });
-  }
-  return result.value;
+  return runWithSpan(
+    { name: "validate_output" },
+    async () => {
+      const result = await schema["~standard"].validate(output);
+      if (result.issues) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Output validation failed",
+          cause: new ValidationError({
+            message: "Output validation failed",
+            issues: result.issues,
+            data: output
+          })
+        });
+      }
+      return result.value;
+    }
+  );
 }
 async function executeProcedureInternal(procedure, options) {
   const middlewares = procedure["~orpc"].middlewares;
@@ -178,17 +208,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);
     }
@@ -365,4 +406,4 @@ function call(procedure, input, ...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 };
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, resolveContractProcedures as v, unlazyRouter as w };