@orpc/server 2.0.0-beta.43 → 2.0.0-beta.45

package/dist/plugins/index.mjs

@@ -1,11 +1,63 @@
 import { ORPCError } from '@orpc/client';
-import { toArray, value, isPlainObject, isTypescriptObject, isAsyncIteratorObject, override, wrapAsyncIterator, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, isAcceptableEncoding, varyByAcceptEncoding, stringifyJSON, anyAbortSignal, 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 { toFetchHeaders, toStandardBody, toStandardHeaders } from '@standard-server/fetch';
 export { R as RequestLimitHandlerPlugin } from '../shared/server.1ExWFMze.mjs';
 
 const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
+const textEncoder = new TextEncoder();
+function encodeLengthPrefix(length) {
+  const prefix = new Uint8Array(4);
+  new DataView(prefix.buffer).setUint32(0, length, false);
+  return prefix;
+}
+async function encodeFrame(message) {
+  const encoded = await encodePeerMessage(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 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";
   /**
@@ -15,12 +67,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: {
@@ -31,10 +84,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;
@@ -42,11 +104,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") {
@@ -101,23 +161,78 @@ class BatchHandlerPlugin {
           response: { status: 413, headers: {}, body: "Batch request size exceeds the maximum allowed size" }
         };
       }
-      const handleIndividualRequest = async (request) => {
+      const status = await value(this.successStatus, interceptorOptions);
+      const headers = await value(this.headers, interceptorOptions);
+      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);
+          keepAliveTimer = void 0;
+        }
+      };
+      const scheduleKeepAlive = () => {
+        if (!this.keepAliveEnabled) {
+          return;
+        }
+        clearKeepAlive();
+        keepAliveTimer = setInterval(() => {
+          try {
+            streamController.enqueue(encodeLengthPrefix(0));
+          } catch {
+            clearKeepAlive();
+          }
+        }, this.keepAliveInterval);
+      };
+      const enqueueMessage = async (message) => {
+        for (const chunk of await encodeFrame(message)) {
+          streamController.enqueue(chunk);
+        }
+        scheduleKeepAlive();
+      };
+      const peer = new ServerPeer(async (message) => {
+        if (streamController === void 0) {
+          bufferedMessages.push(message);
+        } else {
+          await enqueueMessage(message);
+        }
+      });
+      const handleIndividualRequest = async (request, markReady) => {
+        let response;
         try {
           request = this.mapSubrequest(request, interceptorOptions);
-          const { matched, response } = await interceptorOptions.next({ ...interceptorOptions, request });
-          if (!matched) {
-            return { status: 404, headers: {}, body: "No procedure matched" };
-          }
-          return response;
+          const result = await interceptorOptions.next({ ...interceptorOptions, request });
+          response = result.matched ? result.response : { status: 404, headers: {}, body: "No procedure matched" };
         } catch (err) {
-          Promise.reject(err);
-          return { status: 500, headers: {}, body: "Internal server error" };
+          response = internalError(err);
+        }
+        markReady({
+          headers: response.headers,
+          stream: response.body instanceof ReadableStream || isAsyncIteratorObject(response.body)
+        });
+        const { batchHeaders: batchHeaders2 } = await lifting;
+        try {
+          return this.mapSubresponse(response, { status, headers: batchHeaders2 }, interceptorOptions);
+        } catch (err) {
+          return internalError(err);
         }
       };
-      const runSubrequests = async (peer2) => {
-        const promise = Promise.all(messages.map((msg) => peer2.message(msg, handleIndividualRequest)));
+      const runSubrequests = async () => {
+        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 = () => peer2.close(signal?.reason);
+        const closePeer = () => peer.close(signal?.reason);
         if (signal?.aborted) {
           closePeer();
         }
@@ -128,72 +243,28 @@ class BatchHandlerPlugin {
           signal?.removeEventListener("abort", closePeer);
         }
       };
-      const status = await value(this.successStatus, interceptorOptions);
-      const headers = await value(this.headers, interceptorOptions);
-      if (mode === "buffered") {
-        const responseMessages = [];
-        const peer2 = new ServerPeer(async (message) => {
-          responseMessages.push(message);
-        });
-        await runSubrequests(peer2);
-        await peer2.close();
-        if (responseMessages.some((msg) => msg.binary !== void 0)) {
-          const chunks = [];
-          for (const message of responseMessages) {
-            const encoded = await encodePeerMessage(message);
-            const bytes = typeof encoded === "string" ? new TextEncoder().encode(encoded) : encoded;
-            const lengthBuffer = new ArrayBuffer(4);
-            new DataView(lengthBuffer).setUint32(0, bytes.byteLength, false);
-            chunks.push(new Uint8Array(lengthBuffer));
-            chunks.push(bytes);
-          }
+      const subrequests = runSubrequests();
+      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();
           return {
             matched: true,
             response: {
               status,
-              headers,
+              headers: batchHeaders,
               body: new Blob(chunks, { type: BATCH_CONTENT_TYPE })
             }
           };
         }
         return {
           matched: true,
-          response: { status, headers, body: responseMessages }
+          response: { status, headers: batchHeaders, body: bufferedMessages }
         };
       }
-      let streamController;
-      let keepAliveTimer;
-      const clearKeepAlive = () => {
-        if (keepAliveTimer !== void 0) {
-          clearInterval(keepAliveTimer);
-          keepAliveTimer = void 0;
-        }
-      };
-      const scheduleKeepAlive = () => {
-        if (!this.keepAliveEnabled) {
-          return;
-        }
-        clearKeepAlive();
-        keepAliveTimer = setInterval(() => {
-          try {
-            const lengthBuffer = new ArrayBuffer(4);
-            new DataView(lengthBuffer).setUint32(0, 0, false);
-            streamController.enqueue(new Uint8Array(lengthBuffer));
-          } catch {
-            clearKeepAlive();
-          }
-        }, this.keepAliveInterval);
-      };
-      const peer = new ServerPeer(async (message) => {
-        const encoded = await encodePeerMessage(message);
-        const bytes = typeof encoded === "string" ? new TextEncoder().encode(encoded) : encoded;
-        const lengthBuffer = new ArrayBuffer(4);
-        new DataView(lengthBuffer).setUint32(0, bytes.byteLength, false);
-        streamController.enqueue(new Uint8Array(lengthBuffer));
-        streamController.enqueue(bytes);
-        scheduleKeepAlive();
-      });
-      const stream = new ReadableStream({
+      const body = new ReadableStream({
         start(controller) {
           streamController = controller;
           scheduleKeepAlive();
@@ -203,7 +274,8 @@ class BatchHandlerPlugin {
           await peer.close(reason);
         }
       });
-      runSubrequests(peer).then(async () => {
+      const flushed = Promise.all(bufferedMessages.splice(0).map(enqueueMessage));
+      Promise.all([flushed, subrequests]).then(async () => {
         clearKeepAlive();
         streamController.close();
         await peer.close();
@@ -216,8 +288,8 @@ class BatchHandlerPlugin {
         matched: true,
         response: {
           status,
-          headers: { ...headers, "content-type": BATCH_CONTENT_TYPE },
-          body: stream
+          headers: { ...batchHeaders, "content-type": BATCH_CONTENT_TYPE },
+          body
         }
       };
     };
@@ -405,75 +477,6 @@ class MethodOverrideHandlerPlugin {
   }
 }
 
-class PrototypePollutionProtectionHandlerPlugin {
-  name = "~prototype-pollution-protection";
-  init(options) {
-    const interceptor = (interceptorOptions) => {
-      const input = interceptorOptions.input;
-      if (isAsyncIteratorObject(input)) {
-        const guardedInput = override(input, wrapAsyncIterator(input, {
-          mapResult: (result) => {
-            this.rejectPollutingInput(result.value);
-            return result;
-          }
-        }));
-        return interceptorOptions.next({ ...interceptorOptions, input: guardedInput });
-      }
-      this.rejectPollutingInput(input);
-      return interceptorOptions.next();
-    };
-    return {
-      ...options,
-      clientInterceptors: [interceptor, ...toArray(options.clientInterceptors)]
-    };
-  }
-  rejectPollutingInput(input) {
-    if (this.containsPollutingKey(input)) {
-      throw new ORPCError("BAD_REQUEST", { message: "Request blocked by prototype pollution protection." });
-    }
-  }
-  /**
-   * Walks the containers the built-in codecs can produce: arrays, maps, sets, and plain
-   * objects, including null-prototype ones. Arrays get the same key checks as plain objects,
-   * since structured clone, as used over MessagePort, keeps named keys like `__proto__` on
-   * them. Other objects, such as files and dates, carry no attacker-authored keys and are
-   * left alone. The walk is iterative, so input nested deeper than the call stack allows
-   * still gets the intended verdict instead of a `RangeError`.
-   */
-  containsPollutingKey(root) {
-    const visited = /* @__PURE__ */ new WeakSet();
-    const stack = [root];
-    while (stack.length !== 0) {
-      const value = stack.pop();
-      if (typeof value !== "object" || value === null || visited.has(value)) {
-        continue;
-      }
-      visited.add(value);
-      if (value instanceof Map || value instanceof Set) {
-        for (const entry of value) {
-          stack.push(entry);
-        }
-        continue;
-      }
-      if (!Array.isArray(value) && !isPlainObject(value)) {
-        continue;
-      }
-      if (Object.hasOwn(value, "__proto__")) {
-        return true;
-      }
-      if (Object.hasOwn(value, "constructor") && isTypescriptObject(value.constructor) && Object.hasOwn(value.constructor, "prototype")) {
-        return true;
-      }
-      for (const item of Object.values(value)) {
-        if (typeof item === "object" && item !== null) {
-          stack.push(item);
-        }
-      }
-    }
-    return false;
-  }
-}
-
 const MAX_CONTENT_ENCODINGS = 5;
 class RequestCompressionHandlerPlugin {
   name = "~request-compression";
@@ -608,7 +611,8 @@ class ResponseCompressionHandlerPlugin {
           };
         }
       } else if (body instanceof Blob) {
-        if ((!Number.isFinite(body.size) || body.size >= this.threshold) && this.isCompressibleContentType(body.type, interceptorOptions)) {
+        const contentType = headers["content-type"] ?? body.type;
+        if ((!Number.isFinite(body.size) || body.size >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(contentType), interceptorOptions)) {
           const contentDisposition = headers["content-disposition"] ?? generateContentDisposition(
             body instanceof File ? body.name : "blob"
           );
@@ -620,7 +624,7 @@ class ResponseCompressionHandlerPlugin {
               headers: {
                 ...toCompressedHeaders(headers, encoding),
                 "standard-server": "file",
-                "content-type": body.type,
+                "content-type": contentType,
                 "content-disposition": contentDisposition
               }
             }
@@ -826,6 +830,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;
@@ -875,4 +961,4 @@ class TimeoutHandlerPlugin {
   }
 }
 
-export { BATCH_CONTENT_TYPE, BatchHandlerPlugin, CORSHandlerPlugin, CORSHandlerPlugin as CORSPlugin, GetMethodCsrfProtectionHandlerPlugin, MethodOverrideHandlerPlugin, PrototypePollutionProtectionHandlerPlugin, 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.BllfVJLm.d.mts → server.B4hFgqPr.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.BWhT-63L.mjs';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.TVSii8T9.mjs';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/{server.BEdOJs6S.d.mts → server.BWhT-63L.d.mts}

@@ -13,7 +13,7 @@ type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     context: TOutContext;
 }>;
 type MiddlewareNextOptions<TOutContext extends Context> = object extends TOutContext ? {
-    context?: TOutContext;
+    context?: TOutContext | undefined;
 } : {
     context: TOutContext;
 };
@@ -21,7 +21,7 @@ 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,10 +150,10 @@ 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]>;
 });

package/dist/shared/{server.BEdOJs6S.d.ts → server.BWhT-63L.d.ts}

@@ -13,7 +13,7 @@ type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     context: TOutContext;
 }>;
 type MiddlewareNextOptions<TOutContext extends Context> = object extends TOutContext ? {
-    context?: TOutContext;
+    context?: TOutContext | undefined;
 } : {
     context: TOutContext;
 };
@@ -21,7 +21,7 @@ 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,10 +150,10 @@ 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]>;
 });

package/dist/shared/{server.CVO0hWyj.d.mts → server.BYNQ06wN.d.ts}

@@ -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.mjs';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BWhT-63L.js';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -73,19 +73,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;

package/dist/shared/{server.BgvqVW_v.mjs → server.BcxD3fmU.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 { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.FEqy7Hrj.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, createContractProcedure as h, getHiddenRouterContract as i, walkProcedureContractsAsync as j, resolveContractProcedure as r, unlazyRouter as u, walkProcedureContractsSync as w };

package/dist/shared/{server.COfbQ0D8.d.ts → server.CI0qiBzm.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.BWhT-63L.js';
+import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.BYNQ06wN.js';
 
 interface RequestLimitHandlerPluginOptions {
     /**

package/dist/shared/{server.DFEuNUt4.d.ts → server.CO_upro1.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.js';
-import { a as StandardHandlerHandleOptions } from './server.DJNkZPfD.js';
+import { C as Context } from './server.BWhT-63L.js';
+import { a as StandardHandlerHandleOptions } from './server.BYNQ06wN.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.DZeVx8K9.d.ts → server.DcDZdSrg.d.ts}

@@ -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.js';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BWhT-63L.js';
 
 type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;