@orpc/server 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/plugins/index.mjs

@@ -1,9 +1,9 @@
-import { toArray, value } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl, mergeStandardHeaders } from '@standardserver/core';
+import { toArray, value, isCompressibleContentType, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl, generateContentDisposition, mergeStandardHeaders } from '@standardserver/core';
 import { isClientPeerSendMessage, ServerPeer, encodePeerMessage } from '@standardserver/peer';
 export { C as CSRFGuardHandlerPlugin } from '../shared/server.D_QauotT.mjs';
-import { toFetchHeaders, toStandardHeaders } from '@standardserver/fetch';
-import '@orpc/client';
+import { toFetchHeaders, toStandardBody, toStandardHeaders } from '@standardserver/fetch';
+import { ORPCError } from '@orpc/client';
 
 class BatchHandlerPlugin {
   name = "~batch";
@@ -16,6 +16,8 @@ class BatchHandlerPlugin {
   mapSubrequest;
   successStatus;
   headers;
+  keepAliveEnabled;
+  keepAliveInterval;
   constructor(options = {}) {
     this.maxSize = options.maxSize ?? 10;
     this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
@@ -29,6 +31,8 @@ class BatchHandlerPlugin {
     }));
     this.successStatus = options.successStatus ?? 207;
     this.headers = options.headers ?? {};
+    this.keepAliveEnabled = options.keepAlive?.enabled ?? true;
+    this.keepAliveInterval = options.keepAlive?.interval ?? 15e3;
   }
   init(options) {
     const routingInterceptor = async (interceptorOptions) => {
@@ -127,9 +131,35 @@ class BatchHandlerPlugin {
         };
       }
       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 stream = new ReadableStream({
         start(controller) {
           streamController = controller;
+          scheduleKeepAlive();
+        },
+        cancel() {
+          clearKeepAlive();
         }
       });
       const peer = new ServerPeer(async (message) => {
@@ -139,11 +169,14 @@ class BatchHandlerPlugin {
         new DataView(lengthBuffer).setUint32(0, bytes.byteLength, false);
         streamController.enqueue(new Uint8Array(lengthBuffer));
         streamController.enqueue(bytes);
+        scheduleKeepAlive();
       });
       Promise.all(messages.map((msg) => peer.message(msg, handleIndividualRequest))).then(async () => {
+        clearKeepAlive();
         streamController.close();
         await peer.close();
       }).catch(async (error) => {
+        clearKeepAlive();
         streamController.error(error);
         await peer.close(error);
       });
@@ -193,7 +226,10 @@ class CORSHandlerPlugin {
         if (allowedOrigins.includes(origin)) {
           resHeaders["access-control-allow-origin"] = origin;
         }
-        resHeaders.vary = interceptorOptions.request.headers.vary ?? "origin";
+        const existingVary = flattenStandardHeader(resHeaders.vary);
+        if (!existingVary?.split(",").some((v) => v.trim().toLowerCase() === "origin")) {
+          resHeaders.vary = existingVary ? `${existingVary}, Origin` : "Origin";
+        }
       }
       const allowedTimingOrigins = toArray(await value(this.options.timingOrigin, origin, interceptorOptions));
       if (allowedTimingOrigins.includes("*")) {
@@ -244,6 +280,69 @@ class CORSHandlerPlugin {
   }
 }
 
+class RequestCompressionHandlerPlugin {
+  name = "~request-compression";
+  /**
+   * Should decompress the original batch request body instead of sub-requests.
+   */
+  after = ["~batch"];
+  init(options) {
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      const encodings = parseContentEncodings(
+        flattenStandardHeader(interceptorOptions.request.headers["content-encoding"])
+      );
+      if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
+        return next();
+      }
+      const decompressedHeaders = {
+        ...interceptorOptions.request.headers,
+        "content-length": void 0,
+        "content-encoding": void 0
+      };
+      return next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          headers: decompressedHeaders,
+          async resolveBody(hint) {
+            const stream = await interceptorOptions.request.resolveBody("octet-stream");
+            if (!(stream instanceof ReadableStream)) {
+              return stream;
+            }
+            let decompressedStream = stream;
+            for (let i = encodings.length - 1; i >= 0; i--) {
+              decompressedStream = decompressedStream.pipeThrough(
+                new DecompressionStream(encodings[i])
+              );
+            }
+            const response = new Response(decompressedStream, {
+              headers: toFetchHeaders(decompressedHeaders)
+            });
+            return toStandardBody(response, { hint });
+          }
+        }
+      });
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+const SUPPORTED_ENCODINGS = ["gzip", "deflate", "deflate-raw"];
+function isSupportedEncoding(encoding) {
+  return SUPPORTED_ENCODINGS.includes(encoding);
+}
+function parseContentEncodings(header) {
+  if (header === void 0) {
+    return [];
+  }
+  return header.split(",").map((part) => part.trim().toLowerCase());
+}
+
 class RequestHeadersHandlerPlugin {
   name = "~request-headers";
   init(options) {
@@ -266,6 +365,243 @@ class RequestHeadersHandlerPlugin {
   }
 }
 
+class RequestLimitHandlerPlugin {
+  name = "~request-limit";
+  /**
+   * Should limit the original batch request body instead of sub-requests.
+   */
+  after = ["~batch"];
+  /**
+   * Should limit the final body size instead of the compressed one.
+   */
+  before = ["~request-compression"];
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  init(options) {
+    const maxBodySize = this.maxBodySize;
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      return next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          async resolveBody(hint) {
+            const contentLength = Number(
+              flattenStandardHeader(interceptorOptions.request.headers["content-length"])
+            );
+            if (Number.isFinite(contentLength) && contentLength > maxBodySize) {
+              throw new ORPCError("PAYLOAD_TOO_LARGE");
+            }
+            const stream = await interceptorOptions.request.resolveBody("octet-stream");
+            if (!(stream instanceof ReadableStream)) {
+              return stream;
+            }
+            let currentBodySize = 0;
+            const limitedStream = stream.pipeThrough(
+              new TransformStream({
+                transform(chunk, controller) {
+                  currentBodySize += chunk.byteLength;
+                  if (currentBodySize > maxBodySize) {
+                    controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                    return;
+                  }
+                  controller.enqueue(chunk);
+                }
+              })
+            );
+            const response = new Response(limitedStream, {
+              headers: toFetchHeaders(interceptorOptions.request.headers)
+            });
+            return toStandardBody(response, { hint });
+          }
+        }
+      });
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+
+const AVG_BYTES_PER_CHAR = 1.2;
+class ResponseCompressionHandlerPlugin {
+  name = "~response-compression";
+  /**
+   * Compression should be done after batching, to compress the final response.
+   * Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+   */
+  after = ["~batch", "~response-headers"];
+  encodings;
+  threshold;
+  constructor(options = {}) {
+    this.encodings = options.encodings ?? ["gzip", "deflate"];
+    this.threshold = options.threshold ?? 1024;
+  }
+  init(options) {
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      const result = await next();
+      if (!result.matched) {
+        return result;
+      }
+      const response = result.response;
+      const contentEncoding = flattenStandardHeader(response.headers["content-encoding"])?.trim()?.toLowerCase();
+      if (contentEncoding !== void 0) {
+        return result;
+      }
+      if (isNoTransformCacheControl(flattenStandardHeader(response.headers["cache-control"]))) {
+        return result;
+      }
+      const acceptEncodings = parseAcceptEncodings(
+        flattenStandardHeader(interceptorOptions.request.headers["accept-encoding"])
+      );
+      const encoding = this.encodings.find((enc) => acceptEncodings.includes(enc));
+      if (encoding === void 0) {
+        return result;
+      }
+      const body = response.body;
+      const headers = response.headers;
+      if (body instanceof ReadableStream) {
+        const contentLength = Number(flattenStandardHeader(headers["content-length"]));
+        if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && isCompressibleContentType(flattenStandardHeader(headers["content-type"]))) {
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: body.pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": "octet-stream",
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body instanceof Blob) {
+        if ((!Number.isFinite(body.size) || body.size >= this.threshold) && isCompressibleContentType(body.type)) {
+          const contentDisposition = headers["content-disposition"] ?? generateContentDisposition(
+            body instanceof File ? body.name : "blob"
+          );
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: body.stream().pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": "file",
+                "content-type": body.type,
+                "content-length": [],
+                "content-disposition": contentDisposition,
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body instanceof FormData) {
+        const PART_OVERHEAD = 64;
+        let contentLength = 0;
+        for (const [key, value] of body) {
+          contentLength += PART_OVERHEAD + key.length;
+          if (value instanceof Blob) {
+            if (!Number.isFinite(value.size)) {
+              if (!isCompressibleContentType(value.type)) {
+                contentLength = -Infinity;
+                break;
+              }
+              contentLength = Infinity;
+            } else {
+              contentLength += isCompressibleContentType(value.type) ? value.size : -value.size;
+            }
+          } else {
+            contentLength += value.length * AVG_BYTES_PER_CHAR;
+          }
+        }
+        if (contentLength >= this.threshold) {
+          const res = new Response(body);
+          const compressedStream = res.body.pipeThrough(new CompressionStream(encoding));
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: compressedStream,
+              headers: {
+                ...headers,
+                "standard-server": [],
+                "content-type": res.headers.get("content-type"),
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body instanceof URLSearchParams) {
+        const string = body.toString();
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": [],
+                "content-type": "application/x-www-form-urlencoded",
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body !== void 0 && !isAsyncIteratorObject(body)) {
+        const string = stringifyJSON(body);
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": [],
+                "content-type": "application/json",
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      }
+      return result;
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+function parseAcceptEncodings(header) {
+  if (header === void 0) {
+    return [];
+  }
+  return header.split(",").map((part) => part.trim().split(";")[0].trim().toLowerCase()).filter(Boolean);
+}
+const CACHE_CONTROL_NO_TRANSFORM_REGEX = /(?:^|,)\s*no-transform\s*(?:,|$)/i;
+function isNoTransformCacheControl(cacheControl) {
+  if (cacheControl === void 0) {
+    return false;
+  }
+  return CACHE_CONTROL_NO_TRANSFORM_REGEX.test(cacheControl);
+}
+
 class ResponseHeadersHandlerPlugin {
   name = "~response-headers";
   /**
@@ -302,4 +638,56 @@ class ResponseHeadersHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSHandlerPlugin, RequestHeadersHandlerPlugin, ResponseHeadersHandlerPlugin };
+class RethrowHandlerPlugin {
+  name = "~rethrow";
+  filter;
+  CONTEXT_SYMBOL = Symbol("ORPC_RETHROW_HANDLER_PLUGIN_CONTEXT");
+  constructor(options) {
+    this.filter = options.filter;
+  }
+  init(options) {
+    const routingInterceptor = 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;
+    };
+    const interceptor = 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 (this.filter(error, options2)) {
+          pluginContext.error = { value: error };
+        }
+        throw error;
+      }
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        ...toArray(options.routingInterceptors),
+        routingInterceptor
+        // rethrow as early as possible and keep it close to `interceptor` to avoid a corrupted or modified context
+      ],
+      interceptors: [
+        interceptor,
+        // catch as many errors as possible
+        ...toArray(options.interceptors)
+      ]
+    };
+  }
+}
+
+export { BatchHandlerPlugin, CORSHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestLimitHandlerPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };

package/dist/shared/{server.BsNNjG5J.d.mts → server.15O7oC1p.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.BL22TloH.mjs';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.CcR4kgje.mjs';
 
 type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
     [k: string]: Lazyable<Router<TInitialContext>>;

package/dist/shared/{server.B_U9y00a.d.mts → server.B4BnEWWm.d.mts}

@@ -1,10 +1,10 @@
 import { RPCSerializer, AnyORPCError } from '@orpc/client';
 import { Value, Promisable } from '@orpc/shared';
 import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { A as AnyProcedure, C as Context } from './server.BL22TloH.mjs';
-import { A as AnyRouter } from './server.BsNNjG5J.mjs';
+import { A as AnyProcedure, C as Context } from './server.CcR4kgje.mjs';
+import { A as AnyRouter } from './server.15O7oC1p.mjs';
 import { AnyProcedureContract } from '@orpc/contract';
-import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.BB_Ik9Ph.mjs';
+import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.DDFizwfU.mjs';
 
 interface RPCMatcherOptions {
     /**
@@ -38,14 +38,15 @@ interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
     /**
      * Resolve HTTP status for encoded successful outputs.
      *
-     * Value should be in range `200-299`
+     * Value should be in the `2xx` range and must be less than `400`.
      * Return `undefined` or `null` to fallback to default
      *
-     * @default DEFAULT_ERROR_STATUS, DEFAULT_ERROR_STATUS
+     * @default DEFAULT_SUCCESS_STATUS (200)
      */
     outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
     /**
      * Mapping ORPCError Code -> HTTP Status Code
+     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
      *
      * @default COMMON_ERROR_STATUS_MAP
      */

package/dist/shared/{server.EOHJ3NJr.d.ts → server.BhsVw7m7.d.ts}

@@ -1,7 +1,7 @@
 import { AnyORPCError } from '@orpc/client';
 import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BL22TloH.js';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.CcR4kgje.js';
 import { Schema, ErrorMap } from '@orpc/contract';
 
 interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
@@ -101,4 +101,4 @@ interface StandardHandlerCodec<T extends Context> {
 }
 
 export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
-export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerHandleResult as g, StandardHandlerInterceptor as h, StandardHandlerInterceptorOptions as i, StandardHandlerRoutingInterceptor as j };
+export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.BwHnWUuN.mjs → server.BoiFpNT7.mjs}

@@ -1,6 +1,6 @@
-import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.CrlKQucM.mjs';
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.DofEOwf-.mjs';
 import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
-import { getOrBind, isTypescriptObject } from '@orpc/shared';
+import { getOrBind, omit, isTypescriptObject } from '@orpc/shared';
 
 const DEFAULT_SUCCESS_STATUS = 200;
 const DEFAULT_ERROR_STATUS = 500;
@@ -77,6 +77,7 @@ function augmentRouter(router, options) {
       router["~orpc"].metaPlugins
     );
     const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares", "errorMap", "meta", "metaPlugins"]),
       ...router["~orpc"],
       meta,
       metaPlugins,
@@ -111,6 +112,7 @@ function augmentImplementedRouter(router, options) {
   }
   if (router instanceof Procedure) {
     const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares"]),
       ...router["~orpc"],
       orderedMiddlewares: [
         ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),

package/dist/shared/{server.GDpX6Df8.mjs → server.COPVXhDG.mjs}

@@ -1,8 +1,8 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
 import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON } from '@orpc/shared';
 import { flattenStandardHeader, parseStandardUrl } from '@standardserver/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.CrlKQucM.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BwHnWUuN.mjs';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.DofEOwf-.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BoiFpNT7.mjs';
 
 class CompositeStandardHandlerPlugin {
   name = "~composite";
@@ -64,7 +64,7 @@ class StandardHandler {
               let input = await runWithSpan("decode_input", decodeInput2);
               step = void 0;
               if (isAsyncIteratorObject(input)) {
-                input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
               }
               const client = createProcedureClient(procedure2, {
                 context: context3,

package/dist/shared/{server.BL22TloH.d.mts → server.CcR4kgje.d.mts}

@@ -119,7 +119,29 @@ interface OrderedMiddleware {
     outputSchemasLengthAtUse?: number | undefined;
     middleware: AnyMiddleware;
 }
-interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap> {
+interface ProcedureConfig {
+    /**
+     * When enabled, input schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * @warning Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableInputValidation?: boolean | undefined;
+    /**
+     * When enabled, output schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * Useful when output schemas exist only for specification generation.
+     *
+     * @warning Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableOutputValidation?: boolean | undefined;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
     __TInitialContext?: (type: TInitialContext) => unknown;
     __TInjectedContext?: (type: TInjectedContext) => unknown;
     __TReturnedError?: () => TReturnedError;
@@ -180,5 +202,5 @@ type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema exten
 });
 declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
 
-export { Procedure as a, Lazy as g, createORPCErrorConstructorMap as w, createProcedureClient as x, unlazy as y };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, AnyMiddleware as f, ProcedureHandler as h, OrderedMiddleware 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, ORPCErrorConstructorMapItem as r, ORPCErrorConstructorMapItemOptions as s, ProcedureClientInterceptorOptions as t, ProcedureDefinition as u, ProcedureHandlerOptions as v };
+export { Procedure as a, Lazy as h, createORPCErrorConstructorMap as x, createProcedureClient as y, unlazy as z };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap 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, OrderedMiddleware as j, LazyDefinition as k, MiddlewareDefinition as l, MiddlewareDone as m, MiddlewareDoneOptions as n, MiddlewareNext as o, MiddlewareNextOptions as p, MiddlewareOptions as q, MiddlewareResult as r, ORPCErrorConstructorMapItem as s, ORPCErrorConstructorMapItemOptions as t, ProcedureClientInterceptorOptions as u, ProcedureDefinition as v, ProcedureHandlerOptions as w };

package/dist/shared/{server.BL22TloH.d.ts → server.CcR4kgje.d.ts}

@@ -119,7 +119,29 @@ interface OrderedMiddleware {
     outputSchemasLengthAtUse?: number | undefined;
     middleware: AnyMiddleware;
 }
-interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap> {
+interface ProcedureConfig {
+    /**
+     * When enabled, input schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * @warning Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableInputValidation?: boolean | undefined;
+    /**
+     * When enabled, output schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * Useful when output schemas exist only for specification generation.
+     *
+     * @warning Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableOutputValidation?: boolean | undefined;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
     __TInitialContext?: (type: TInitialContext) => unknown;
     __TInjectedContext?: (type: TInjectedContext) => unknown;
     __TReturnedError?: () => TReturnedError;
@@ -180,5 +202,5 @@ type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema exten
 });
 declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
 
-export { Procedure as a, Lazy as g, createORPCErrorConstructorMap as w, createProcedureClient as x, unlazy as y };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, AnyMiddleware as f, ProcedureHandler as h, OrderedMiddleware 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, ORPCErrorConstructorMapItem as r, ORPCErrorConstructorMapItemOptions as s, ProcedureClientInterceptorOptions as t, ProcedureDefinition as u, ProcedureHandlerOptions as v };
+export { Procedure as a, Lazy as h, createORPCErrorConstructorMap as x, createProcedureClient as y, unlazy as z };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap 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, OrderedMiddleware as j, LazyDefinition as k, MiddlewareDefinition as l, MiddlewareDone as m, MiddlewareDoneOptions as n, MiddlewareNext as o, MiddlewareNextOptions as p, MiddlewareOptions as q, MiddlewareResult as r, ORPCErrorConstructorMapItem as s, ORPCErrorConstructorMapItemOptions as t, ProcedureClientInterceptorOptions as u, ProcedureDefinition as v, ProcedureHandlerOptions as w };