@orpc/server 2.0.0-beta.44 → 2.0.0-beta.46

package/dist/plugins/index.mjs

@@ -1,7 +1,9 @@
 import { ORPCError } from '@orpc/client';
-import { toArray, value, promiseWithResolvers, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, isAcceptableEncoding, varyByAcceptEncoding, stringifyJSON, anyAbortSignal, override, wrapAsyncIterator, wrapReadableStream, AbortError } from '@orpc/shared';
+import { DEFAULT_BATCH_MAX_SIZE, BATCH_HEADER } from '@orpc/client/plugins';
+export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins';
+import { toArray, value, promiseWithResolvers, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, isAcceptableEncoding, varyByAcceptEncoding, stringifyJSON, anyAbortSignal, override, AsyncIteratorClass, runWithSignal, AbortError, wrapAsyncIterator, wrapReadableStream } from '@orpc/shared';
 import { flattenStandardHeader, parseStandardUrl, generateContentDisposition, mergeStandardHeaders } from '@standard-server/core';
-import { isClientPeerSendMessage, ServerPeer, encodePeerMessage } from '@standard-server/peer';
+import { ServerPeer, isPeerMessage, isClientPeerSendMessage, encodePeerMessage } from '@standard-server/peer';
 import { toFetchHeaders, toStandardBody, toStandardHeaders } from '@standard-server/fetch';
 export { R as RequestLimitHandlerPlugin } from '../shared/server.1ExWFMze.mjs';
 
@@ -17,6 +19,48 @@ async function encodeFrame(message) {
   const bytes = typeof encoded === "string" ? textEncoder.encode(encoded) : encoded;
   return [encodeLengthPrefix(bytes.byteLength), bytes];
 }
+function isBodyHeader(name) {
+  return name.startsWith("content-") || name === "standard-server";
+}
+function isClientPeerSendMessages(maybe) {
+  return Array.isArray(maybe) && maybe.every((m) => isPeerMessage(m) && isClientPeerSendMessage(m));
+}
+function internalError(err) {
+  Promise.reject(err);
+  return { status: 500, headers: {}, body: "Internal server error" };
+}
+function liftSubresponseHeaders(batchHeaders, subresponseHeaders) {
+  const [first = {}, ...rest] = subresponseHeaders;
+  const shared = {};
+  for (const [name, value2] of Object.entries(first)) {
+    if (value2 === void 0 || isBodyHeader(name)) {
+      continue;
+    }
+    const flattened = flattenStandardHeader(value2);
+    if (rest.every((other) => flattenStandardHeader(other[name]) === flattened)) {
+      shared[name] = value2;
+    }
+  }
+  const headers = { ...shared, ...batchHeaders };
+  const cookies = new Set([batchHeaders, ...subresponseHeaders].flatMap((other) => toArray(other["set-cookie"])));
+  if (cookies.size > 0) {
+    headers["set-cookie"] = [...cookies];
+  }
+  const varies = /* @__PURE__ */ new Map();
+  for (const value2 of [batchHeaders, ...subresponseHeaders].flatMap((other) => toArray(other.vary))) {
+    for (const field of value2.split(",")) {
+      const name = field.trim();
+      const key = name.toLowerCase();
+      if (name && !varies.has(key)) {
+        varies.set(key, name);
+      }
+    }
+  }
+  if (varies.size > 0) {
+    headers.vary = varies.has("*") ? "*" : [...varies.values()].join(", ");
+  }
+  return headers;
+}
 class BatchHandlerPlugin {
   name = "~batch";
   /**
@@ -26,12 +70,13 @@ class BatchHandlerPlugin {
   after = ["~tracing"];
   maxSize;
   mapSubrequest;
+  mapSubresponse;
   successStatus;
   headers;
   keepAliveEnabled;
   keepAliveInterval;
   constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 10;
+    this.maxSize = options.maxSize ?? DEFAULT_BATCH_MAX_SIZE;
     this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
       ...subRequest,
       headers: {
@@ -42,10 +87,19 @@ class BatchHandlerPlugin {
          * or `origin`, cannot be overridden by a subrequest, which is just request payload.
          */
         ...batchRequest.headers,
-        "orpc-batch": void 0
+        [BATCH_HEADER]: void 0
         // useful in case batch plugin is used multiple times
       }
     }));
+    this.mapSubresponse = options.mapSubresponse ?? ((subresponse, { headers: batchHeaders }) => {
+      const headers = {};
+      for (const [name, value2] of Object.entries(subresponse.headers)) {
+        if (name !== "set-cookie" && flattenStandardHeader(value2) !== flattenStandardHeader(batchHeaders[name])) {
+          headers[name] = value2;
+        }
+      }
+      return { ...subresponse, headers };
+    });
     this.successStatus = options.successStatus ?? 207;
     this.headers = options.headers ?? {};
     this.keepAliveEnabled = options.keepAlive?.enabled ?? true;
@@ -53,11 +107,9 @@ class BatchHandlerPlugin {
   }
   init(options) {
     const routingInterceptor = async (interceptorOptions) => {
-      const batchHeader = flattenStandardHeader(interceptorOptions.request.headers["orpc-batch"]);
-      if (batchHeader === void 0) {
+      if (flattenStandardHeader(interceptorOptions.request.headers[BATCH_HEADER]) === void 0) {
         return interceptorOptions.next();
       }
-      const mode = batchHeader === "buffered" ? "buffered" : "streaming";
       let messages;
       try {
         if (interceptorOptions.request.method === "GET") {
@@ -71,7 +123,7 @@ class BatchHandlerPlugin {
             };
           }
           const mightBeMessages = JSON.parse(data);
-          if (!Array.isArray(mightBeMessages) || mightBeMessages.some((m) => !isClientPeerSendMessage(m))) {
+          if (!isClientPeerSendMessages(mightBeMessages)) {
             return {
               matched: true,
               response: { status: 400, headers: {}, body: "Invalid batch request data parameter" }
@@ -80,7 +132,7 @@ class BatchHandlerPlugin {
           messages = mightBeMessages;
         } else {
           const mightBeMessages = await interceptorOptions.request.resolveBody();
-          if (!Array.isArray(mightBeMessages) || mightBeMessages.some((m) => !isClientPeerSendMessage(m))) {
+          if (!isClientPeerSendMessages(mightBeMessages)) {
             return {
               matched: true,
               response: { status: 400, headers: {}, body: "Invalid batch request body" }
@@ -117,6 +169,14 @@ class BatchHandlerPlugin {
       const bufferedMessages = [];
       let streamController;
       let keepAliveTimer;
+      const ready = messages.map(() => promiseWithResolvers());
+      const lifting = Promise.all(ready.map(({ promise }) => promise)).then((all) => {
+        const heads = all.filter((head) => head !== void 0);
+        return {
+          batchHeaders: liftSubresponseHeaders(headers, heads.map((head) => head.headers)),
+          streams: heads.some((head) => head.stream)
+        };
+      });
       const clearKeepAlive = () => {
         if (keepAliveTimer !== void 0) {
           clearInterval(keepAliveTimer);
@@ -143,50 +203,37 @@ class BatchHandlerPlugin {
         scheduleKeepAlive();
       };
       const peer = new ServerPeer(async (message) => {
-        if (mode === "streaming") {
-          startStreaming();
-        }
         if (streamController === void 0) {
           bufferedMessages.push(message);
         } else {
           await enqueueMessage(message);
         }
       });
-      const streaming = promiseWithResolvers();
-      function startStreaming() {
-        if (streamController !== void 0) {
-          return;
+      const handleIndividualRequest = async (request, markReady) => {
+        let response;
+        try {
+          request = this.mapSubrequest(request, interceptorOptions);
+          const result = await interceptorOptions.next({ ...interceptorOptions, request });
+          response = result.matched ? result.response : { status: 404, headers: {}, body: "No procedure matched" };
+        } catch (err) {
+          response = internalError(err);
         }
-        const body = new ReadableStream({
-          start(controller) {
-            streamController = controller;
-            scheduleKeepAlive();
-          },
-          async cancel(reason) {
-            clearKeepAlive();
-            await peer.close(reason);
-          }
+        markReady({
+          headers: response.headers,
+          stream: response.body instanceof ReadableStream || isAsyncIteratorObject(response.body)
         });
-        streaming.resolve({ body, flushed: Promise.all(bufferedMessages.splice(0).map(enqueueMessage)) });
-      }
-      const handleIndividualRequest = async (request) => {
+        const { batchHeaders: batchHeaders2 } = await lifting;
         try {
-          request = this.mapSubrequest(request, interceptorOptions);
-          const { matched, response } = await interceptorOptions.next({ ...interceptorOptions, request });
-          if (!matched) {
-            return { status: 404, headers: {}, body: "No procedure matched" };
-          }
-          if (response.body instanceof ReadableStream || isAsyncIteratorObject(response.body)) {
-            startStreaming();
-          }
-          return response;
+          return this.mapSubresponse(response, { status, headers: batchHeaders2 }, interceptorOptions);
         } catch (err) {
-          Promise.reject(err);
-          return { status: 500, headers: {}, body: "Internal server error" };
+          return internalError(err);
         }
       };
       const runSubrequests = async () => {
-        const promise = Promise.all(messages.map((msg) => peer.message(msg, handleIndividualRequest)));
+        const promise = Promise.all(messages.map((msg, i) => {
+          const { resolve } = ready[i];
+          return peer.message(msg, (request) => handleIndividualRequest(request, resolve)).finally(() => resolve(void 0));
+        }));
         const signal = interceptorOptions.request.signal;
         const closePeer = () => peer.close(signal?.reason);
         if (signal?.aborted) {
@@ -200,8 +247,9 @@ class BatchHandlerPlugin {
         }
       };
       const subrequests = runSubrequests();
-      const started = await Promise.race([streaming.promise, subrequests.then(() => void 0)]);
-      if (started === void 0) {
+      const { batchHeaders, streams } = await lifting;
+      if (!streams) {
+        await subrequests;
         await peer.close();
         if (bufferedMessages.some((msg) => msg.binary !== void 0)) {
           const chunks = (await Promise.all(bufferedMessages.map(encodeFrame))).flat();
@@ -209,17 +257,28 @@ class BatchHandlerPlugin {
             matched: true,
             response: {
               status,
-              headers,
+              headers: batchHeaders,
               body: new Blob(chunks, { type: BATCH_CONTENT_TYPE })
             }
           };
         }
         return {
           matched: true,
-          response: { status, headers, body: bufferedMessages }
+          response: { status, headers: batchHeaders, body: bufferedMessages }
         };
       }
-      Promise.all([started.flushed, subrequests]).then(async () => {
+      const body = new ReadableStream({
+        start(controller) {
+          streamController = controller;
+          scheduleKeepAlive();
+        },
+        async cancel(reason) {
+          clearKeepAlive();
+          await peer.close(reason);
+        }
+      });
+      const flushed = Promise.all(bufferedMessages.splice(0).map(enqueueMessage));
+      Promise.all([flushed, subrequests]).then(async () => {
         clearKeepAlive();
         streamController.close();
         await peer.close();
@@ -232,8 +291,8 @@ class BatchHandlerPlugin {
         matched: true,
         response: {
           status,
-          headers: { ...headers, "content-type": BATCH_CONTENT_TYPE },
-          body: started.body
+          headers: { ...batchHeaders, "content-type": BATCH_CONTENT_TYPE },
+          body
         }
       };
     };
@@ -774,6 +833,88 @@ class RethrowHandlerPlugin {
   }
 }
 
+class SignalSyncHandlerPlugin {
+  name = "~signal-sync";
+  init(options) {
+    const clientInterceptor = async (interceptorOptions) => {
+      const controller = new AbortController();
+      const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
+      const cancel = () => controller.abort(new AbortError("The response body was cancelled"));
+      const output = await interceptorOptions.next({ ...interceptorOptions, signal });
+      if (isAsyncIteratorObject(output)) {
+        return override(output, syncAsyncIterator(output, signal, cancel));
+      }
+      if (output instanceof ReadableStream) {
+        return override(output, syncReadableStream(output, signal, cancel));
+      }
+      return output;
+    };
+    return { ...options, clientInterceptors: [clientInterceptor, ...toArray(options.clientInterceptors)] };
+  }
+}
+function listenAbort(signal, onAbort) {
+  if (signal.aborted) {
+    onAbort();
+  } else {
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return () => signal.removeEventListener("abort", onAbort);
+}
+function syncAsyncIterator(iterator, signal, cancel) {
+  let cancelling;
+  const unlisten = listenAbort(signal, () => {
+    cancelling = (async () => iterator.return?.())();
+    cancelling.catch(() => {
+    });
+  });
+  return new AsyncIteratorClass(
+    () => runWithSignal(signal, () => iterator.next()),
+    async ({ kind }) => {
+      if (kind === "cancelled") {
+        cancel();
+        await cancelling;
+      }
+      unlisten();
+    }
+  );
+}
+function syncReadableStream(stream, signal, cancel) {
+  const reader = stream.getReader();
+  let cancelling;
+  let unlisten;
+  return new ReadableStream({
+    start(controller) {
+      unlisten = listenAbort(signal, () => {
+        controller.error(signal.reason);
+        cancelling = reader.cancel(signal.reason);
+        cancelling.catch(() => {
+        });
+      });
+    },
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (signal.aborted) {
+          return;
+        }
+        if (done) {
+          unlisten();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        unlisten();
+        throw error;
+      }
+    },
+    async cancel() {
+      cancel();
+      await cancelling;
+    }
+  }, { highWaterMark: 0 });
+}
+
 class TimeoutHandlerPlugin {
   timeout;
   streamingTimeout;
@@ -823,4 +964,4 @@ class TimeoutHandlerPlugin {
   }
 }
 
-export { BATCH_CONTENT_TYPE, BatchHandlerPlugin, CORSHandlerPlugin, CORSHandlerPlugin as CORSPlugin, GetMethodCsrfProtectionHandlerPlugin, MethodOverrideHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestHeadersHandlerPlugin as RequestHeadersPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, RethrowHandlerPlugin, TimeoutHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders };
+export { BATCH_CONTENT_TYPE, BatchHandlerPlugin, CORSHandlerPlugin, CORSHandlerPlugin as CORSPlugin, GetMethodCsrfProtectionHandlerPlugin, MethodOverrideHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestHeadersHandlerPlugin as RequestHeadersPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, RethrowHandlerPlugin, SignalSyncHandlerPlugin, TimeoutHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders };

package/dist/shared/{server.DJNkZPfD.d.ts → server.9B1jEm5a.d.mts}

@@ -1,7 +1,7 @@
 import { AnyORPCError } from '@orpc/client';
 import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BEdOJs6S.js';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.DFPxP2v3.mjs';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -27,12 +27,6 @@ interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
      */
     init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
-declare class CompositeStandardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    readonly name = "~composite";
-    protected readonly plugins: StandardHandlerPlugin<T>[];
-    constructor(plugins?: StandardHandlerPlugin<T>[]);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
 
 interface StandardHandlerHandleOptions<T extends Context> {
     prefix?: `/${string}` | undefined;
@@ -73,19 +67,19 @@ interface StandardHandlerOptions<TContext extends Context> {
      * - batch plugins - separate one request into multiple and call multiple next
      * - openapi spec plugin - to intercept a request and early response
      */
-    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[];
+    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[] | undefined;
     /**
      * interceptor run after routing and before error handler,
      * useful for error handling, logging, metrics, etc.
      */
-    interceptors?: StandardHandlerInterceptor<TContext>[];
+    interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
     /**
      *
      * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
      * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
      */
-    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[];
-    plugins?: StandardHandlerPlugin<TContext>[];
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
+    plugins?: StandardHandlerPlugin<TContext>[] | undefined;
 }
 declare class StandardHandler<T extends Context> {
     private readonly codec;
@@ -95,10 +89,6 @@ declare class StandardHandler<T extends Context> {
     constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
     handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
 }
-declare class TracingHandlerPlugin implements StandardHandlerPlugin<any> {
-    name: string;
-    init(options: StandardHandlerOptions<any>): StandardHandlerOptions<any>;
-}
 
 interface StandardHandlerCodecResolvedProcedure {
     path: string[];
@@ -111,5 +101,5 @@ interface StandardHandlerCodec<T extends Context> {
     encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S, TracingHandlerPlugin as T };
+export { StandardHandler as S };
 export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.FEqy7Hrj.mjs → server.BB464y-6.mjs}

@@ -120,7 +120,7 @@ async function executeProcedureInternal(procedure, options) {
   const inputSchemas = toArray(procedure["~orpc"].inputSchemas);
   const outputSchemas = toArray(procedure["~orpc"].outputSchemas);
   const orderedMiddlewares = procedure["~orpc"].orderedMiddlewares;
-  const next = async (midIndex, context, input) => {
+  const next = async (midIndex, context, input, signal) => {
     let currentInput = input;
     let middlewareInput = input;
     const startInputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0;
@@ -146,13 +146,15 @@ async function executeProcedureInternal(procedure, options) {
           {
             ...options,
             context,
+            signal,
             next: (...rest) => {
               const nextOptions = resolveMaybeOptionalOptions(rest);
               const nextContext = nextOptions.context ?? {};
               return next(
                 midIndex + 1,
                 { ...context, ...nextContext },
-                currentInput
+                currentInput,
+                nextOptions.signal ?? signal
               );
             },
             lastEventId: options.lastEventId
@@ -166,7 +168,7 @@ async function executeProcedureInternal(procedure, options) {
     } else {
       currentOutput = await runWithSpan(
         "handler",
-        () => procedure["~orpc"].handler({ ...options, context, input: currentInput }, currentInput)
+        () => procedure["~orpc"].handler({ ...options, context, input: currentInput, signal }, currentInput)
       );
     }
     const startOutputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0;
@@ -178,7 +180,7 @@ async function executeProcedureInternal(procedure, options) {
     }
     return { output: currentOutput, context: currentContext };
   };
-  const { output } = await next(0, options.context, options.input);
+  const { output } = await next(0, options.context, options.input, options.signal);
   return output;
 }
 

package/dist/shared/{server.DD1roZl9.d.mts → server.BC5BIu02.d.mts}

@@ -1,5 +1,5 @@
 import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
-import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BEdOJs6S.mjs';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.DFPxP2v3.mjs';
 
 type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;

package/dist/shared/{server.UG_xdTub.d.mts → server.BSYGskId.d.ts}

@@ -1,10 +1,10 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest } from '@standard-server/core';
-import { C as Context } from './server.BEdOJs6S.mjs';
-import { a as StandardHandlerHandleOptions } from './server.CVO0hWyj.mjs';
+import { C as Context } from './server.DFPxP2v3.js';
+import { a as StandardHandlerHandleOptions } from './server.DOg7ke6y.js';
 
 type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
 } : {
     context: Value<Promisable<T>, [request: StandardLazyRequest]>;
 });

package/dist/shared/{server.DFEuNUt4.d.ts → server.BvG3boBj.d.mts}

@@ -1,10 +1,10 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest } from '@standard-server/core';
-import { C as Context } from './server.BEdOJs6S.js';
-import { a as StandardHandlerHandleOptions } from './server.DJNkZPfD.js';
+import { C as Context } from './server.DFPxP2v3.mjs';
+import { a as StandardHandlerHandleOptions } from './server.9B1jEm5a.mjs';
 
 type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
 } : {
     context: Value<Promisable<T>, [request: StandardLazyRequest]>;
 });

package/dist/shared/{server.BllfVJLm.d.mts → server.CTV_mC2P.d.mts}

@@ -1,5 +1,5 @@
-import { C as Context } from './server.BEdOJs6S.mjs';
-import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.CVO0hWyj.mjs';
+import { C as Context } from './server.DFPxP2v3.mjs';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.9B1jEm5a.mjs';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/{server.BgvqVW_v.mjs → server.CYbIpHbH.mjs}

@@ -1,9 +1,9 @@
-import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.FEqy7Hrj.mjs';
-import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
-import { omit, isTypescriptObject, getOwn } from '@orpc/shared';
+import { ProcedureContract, resolveMetaPlugins, mergeErrorMap } from '@orpc/contract';
+import { isTypescriptObject, getOwn, omit } from '@orpc/shared';
+import { c as createProcedureClient, L as Lazy, u as unlazy, P as Procedure } from './server.BB464y-6.mjs';
 
 const DEFAULT_SUCCESS_STATUS = 200;
-const DEFAULT_ERROR_STATUS = 500;
+const DEFAULT_ERROR_STATUS = 400;
 
 function createGuardedProcedureLazy(lazy) {
   const guarded = new Lazy({
@@ -130,6 +130,18 @@ function augmentImplementedRouter(router, options) {
   }
   return enhanced;
 }
+async function resolveContractProcedure(router, contract, path) {
+  if (contract instanceof Procedure) {
+    return contract;
+  }
+  const { default: maybeProcedure } = await unlazy(getRouter(router, path));
+  if (!(maybeProcedure instanceof Procedure)) {
+    throw new TypeError(
+      `[Contract-First] Missing or invalid implementation for procedure at path: "${path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
+    );
+  }
+  return createContractProcedure(maybeProcedure, contract);
+}
 function getRouter(router, path) {
   let current = router;
   for (let i = 0; i < path.length; i++) {
@@ -224,4 +236,4 @@ async function unlazyRouter(router) {
   return unlazied;
 }
 
-export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, createContractProcedure as c, augmentImplementedRouter as d, withHiddenRouterContract as e, createGuardedProcedureLazy as f, getRouter as g, call as h, getHiddenRouterContract as i, walkProcedureContractsAsync as j, unlazyRouter as u, walkProcedureContractsSync as w };
+export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, augmentImplementedRouter as c, withHiddenRouterContract as d, createGuardedProcedureLazy as e, call as f, getRouter as g, walkProcedureContractsAsync as h, resolveContractProcedure as r, unlazyRouter as u, walkProcedureContractsSync as w };

package/dist/shared/{server.COfbQ0D8.d.ts → server.CgBF3Vj1.d.ts}

@@ -1,5 +1,5 @@
-import { C as Context } from './server.BEdOJs6S.js';
-import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.DJNkZPfD.js';
+import { C as Context } from './server.DFPxP2v3.js';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.DOg7ke6y.js';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/{server.B34dZrzY.mjs → server.Chq5FpXf.mjs}

@@ -1,8 +1,8 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
 import { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, wrapAsyncIterator, toTracingException, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
 import { flattenStandardHeader, parseStandardUrl, ErrorEvent } from '@standard-server/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.FEqy7Hrj.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BgvqVW_v.mjs';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.BB464y-6.mjs';
+import { w as walkProcedureContractsSync, r as resolveContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.CYbIpHbH.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -298,13 +298,7 @@ class RPCMatcher {
     this.pendingLazyRouters.delete(httpPathPrefix);
   }
   async resolveProcedure(entry) {
-    const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
-    if (!(maybeProcedure instanceof Procedure)) {
-      throw new TypeError(
-        `[Contract-First] Missing or invalid implementation for procedure at path: "${entry.path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
-      );
-    }
-    entry.procedure = createContractProcedure(maybeProcedure, entry.contract);
+    entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
     return entry.procedure;
   }
 }
@@ -356,4 +350,4 @@ class RPCHandlerCodec {
   }
 }
 
-export { CompositeStandardHandlerPlugin as C, RPCHandlerCodec as R, StandardHandler as S, TracingHandlerPlugin as T, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };
+export { RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };

package/dist/shared/{server.BEdOJs6S.d.mts → server.DFPxP2v3.d.mts}

@@ -12,16 +12,19 @@ type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     output: TOutput;
     context: TOutContext;
 }>;
-type MiddlewareNextOptions<TOutContext extends Context> = object extends TOutContext ? {
-    context?: TOutContext;
+type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
+    context?: TOutContext | undefined;
 } : {
     context: TOutContext;
+}) & {
+    /** Overrides the signal for the rest of the chain. */
+    signal?: AbortSignal | undefined;
 };
 interface MiddlewareNext<TOutput> {
     <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
 }
 type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
-    context?: TOutContext;
+    context?: TOutContext | undefined;
 } : {
     context: TOutContext;
 }) & {
@@ -150,14 +153,14 @@ interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TEr
 }
 type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
 type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
-    path?: string[];
-    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[];
+    path?: string[] | undefined;
+    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
 } & (object extends TInitialContext ? {
-    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]> | undefined;
 } : {
     context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 });
 declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
-export { Procedure as a, Lazy as h, createProcedureClient as u, unlazy as v };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, OrderedMiddleware as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureConfig as f, AnyMiddleware as g, ProcedureHandler as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ProcedureClientInterceptorOptions as r, ProcedureDefinition as s, ProcedureHandlerOptions as t };
+export { Procedure as a, Lazy as f, createProcedureClient as u, unlazy as v };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, OrderedMiddleware as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureHandler as g, ProcedureConfig as h, AnyMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ProcedureClientInterceptorOptions as r, ProcedureDefinition as s, ProcedureHandlerOptions as t };