@orpc/client 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/shared/{client.DMXKFDyV.mjs → client.BnATe4Ob.mjs}

@@ -1,6 +1,6 @@
-import { isPlainObject, wrapAsyncIterator, isTypescriptObject, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { isPlainObject, wrapAsyncIterator, isTypescriptObject, NullProtoObj, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
 import { getEventMeta, withEventMeta, ErrorEvent } from '@standardserver/core';
-import { O as ORPCError } from './client.Dnfj8jnT.mjs';
+import { O as ORPCError, M as MalformedResponseError, C as COMMON_ERROR_STATUS_MAP } from './client.DcoDDrD4.mjs';
 
 function isInferableError(error) {
   return error instanceof ORPCError && error.inferable;
@@ -27,20 +27,42 @@ function createORPCErrorFromJson(json, options = {}) {
   error.inferable = json.inferable;
   return error;
 }
+function createORPCErrorFromMalformedResponse(options) {
+  const error = new ORPCError("MALFORMED_ORPC_RESPONSE", {
+    message: options.message ?? inferMalformedResponseMessage(options.response),
+    data: options.response
+  });
+  error.cause = new MalformedResponseError({ ...options, message: error.message });
+  return error;
+}
+const INFERRED_MESSAGE_MIN_LENGTH = 1;
+const INFERRED_MESSAGE_MAX_LENGTH = 256;
+function isInferableMessage(text) {
+  return text.length >= INFERRED_MESSAGE_MIN_LENGTH && text.length <= INFERRED_MESSAGE_MAX_LENGTH;
+}
+function inferMalformedResponseMessage(response) {
+  if (typeof response.body === "string" && isInferableMessage(response.body)) {
+    return response.body;
+  }
+  if (isPlainObject(response.body) && typeof response.body.message === "string" && isInferableMessage(response.body.message)) {
+    return response.body.message;
+  }
+  const commonCode = Object.entries(COMMON_ERROR_STATUS_MAP).find(([, status]) => status === response.status)?.[0];
+  return commonCode?.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
 function cloneORPCError(error) {
   const cloned = new ORPCError(error.code, {
-    ...error,
     message: error.message,
     data: error.data,
     cause: error.cause
   });
+  Object.setPrototypeOf(cloned, Object.getPrototypeOf(error));
+  Object.defineProperties(cloned, Object.getOwnPropertyDescriptors(error));
   cloned.stack = error.stack;
-  cloned.defined = error.defined;
-  cloned.inferable = error.inferable;
   return cloned;
 }
 
-function wrapEventIteratorPreservingMeta(iterator, { mapResult, mapError, ...rest }) {
+function wrapAsyncIteratorPreservingEventMeta(iterator, { mapResult, mapError, ...rest }) {
   return wrapAsyncIterator(iterator, {
     ...rest,
     mapResult: mapResult && (async (result) => {
@@ -66,7 +88,7 @@ function wrapEventIteratorPreservingMeta(iterator, { mapResult, mapError, ...res
   });
 }
 
-const REGEX_STRING_PATTERN = /^\/(.*)\/([a-z]*)$/;
+const REGEX_STRING_PATTERN = /^\/([\s\S]*)\/([a-z]*)$/;
 const DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
   undefined: {
     condition(data) {
@@ -169,49 +191,140 @@ const DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
 };
 class RPCJsonSerializer {
   handlers;
+  inlineBuiltInHandlers;
+  handlerEntries;
   omitUndefinedProperties;
   constructor(options = {}) {
-    this.handlers = {
-      ...DEFAULT_RPC_JSON_SERIALIZER_HANDLERS,
-      ...options.handlers
-    };
     this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
+    this.handlers = Object.assign(new NullProtoObj(), DEFAULT_RPC_JSON_SERIALIZER_HANDLERS);
+    const customHandlers = options.handlers;
+    if (customHandlers === void 0) {
+      this.inlineBuiltInHandlers = true;
+      return;
+    }
+    let inlineBuiltInHandlers = true;
+    let handlerEntries = [];
+    for (const key in customHandlers) {
+      const handler = customHandlers[key];
+      this.handlers[key] = handler;
+      if (inlineBuiltInHandlers && key in DEFAULT_RPC_JSON_SERIALIZER_HANDLERS) {
+        inlineBuiltInHandlers = false;
+      }
+      if (inlineBuiltInHandlers && handler !== void 0) {
+        handlerEntries.push([key, handler]);
+      }
+    }
+    if (!inlineBuiltInHandlers) {
+      handlerEntries = [];
+      for (const key in this.handlers) {
+        const handler = this.handlers[key];
+        if (handler !== void 0) {
+          handlerEntries.push([key, handler]);
+        }
+      }
+    }
+    this.inlineBuiltInHandlers = inlineBuiltInHandlers;
+    this.handlerEntries = handlerEntries;
   }
   serialize(data) {
-    const [json, meta_, maps, blobs] = this.serializeValue(data, [], [], [], []);
-    const meta = meta_.length === 0 ? void 0 : meta_;
+    let meta = [];
+    const maps = [];
+    const blobs = [];
+    const json = this.serializeValue(data, [], meta, maps, blobs);
+    meta = meta.length === 0 ? void 0 : meta;
     if (maps.length === 0) {
       return { json, meta };
     }
     return { json, meta, maps, blobs };
   }
+  /**
+   * `segments` is a shared mutable stack (push/pop while walking),
+   * so it must be copied before being stored in `meta` or `maps`.
+   */
   serializeValue(data, segments, meta, maps, blobs) {
-    for (const key in this.handlers) {
-      const handler = this.handlers[key];
-      if (handler && handler.condition(data)) {
-        const serialized = handler.serialize(data);
-        if (handler.isTerminal) {
-          meta.push([key, ...segments]);
-          return [serialized, meta, maps, blobs];
+    if (this.inlineBuiltInHandlers) {
+      switch (typeof data) {
+        case "string":
+        case "boolean":
+          return data;
+        case "number":
+          if (Number.isNaN(data)) {
+            meta.push(["nan", ...segments]);
+            return null;
+          }
+          return data;
+        case "undefined":
+          meta.push(["undefined", ...segments]);
+          return null;
+        case "bigint":
+          meta.push(["bigint", ...segments]);
+          return data.toString();
+        case "object": {
+          if (data === null) {
+            return data;
+          }
+          if (data instanceof Date) {
+            meta.push(["date", ...segments]);
+            return Number.isNaN(data.getTime()) ? null : data.toISOString();
+          }
+          if (data instanceof URL) {
+            meta.push(["url", ...segments]);
+            return data.toString();
+          }
+          if (data instanceof RegExp) {
+            meta.push(["regexp", ...segments]);
+            return data.toString();
+          }
+          if (data instanceof Set) {
+            const result = this.serializeValue(Array.from(data), segments, meta, maps, blobs);
+            meta.push(["set", ...segments]);
+            return result;
+          }
+          if (data instanceof Map) {
+            const result = this.serializeValue(Array.from(data.entries()), segments, meta, maps, blobs);
+            meta.push(["map", ...segments]);
+            return result;
+          }
+        }
+      }
+    }
+    const handlerEntries = this.handlerEntries;
+    if (handlerEntries) {
+      for (let i = 0; i < handlerEntries.length; i++) {
+        const entry = handlerEntries[i];
+        const handler = entry[1];
+        if (handler.condition(data)) {
+          const serialized = handler.serialize(data);
+          if (handler.isTerminal) {
+            meta.push([entry[0], ...segments]);
+            if (serialized instanceof Blob) {
+              maps.push(segments.slice());
+              blobs.push(serialized);
+            }
+            return serialized;
+          }
+          const result = this.serializeValue(serialized, segments, meta, maps, blobs);
+          meta.push([entry[0], ...segments]);
+          return result;
         }
-        const result = this.serializeValue(serialized, segments, meta, maps, blobs);
-        meta.push([key, ...segments]);
-        return result;
       }
     }
     if (data instanceof Blob) {
-      maps.push(segments);
+      maps.push(segments.slice());
       blobs.push(data);
-      return [data, meta, maps, blobs];
+      return data;
     }
     if (Array.isArray(data)) {
-      const json = data.map((v, i) => {
-        return this.serializeValue(v, [...segments, i], meta, maps, blobs)[0];
-      });
-      return [json, meta, maps, blobs];
+      const json = [];
+      for (let i = 0; i < data.length; i++) {
+        segments.push(i);
+        json.push(this.serializeValue(data[i], segments, meta, maps, blobs));
+        segments.pop();
+      }
+      return json;
     }
     if (isPlainObject(data)) {
-      const json = {};
+      const json = new NullProtoObj();
       for (const k in data) {
         const v = data[k];
         if (k === "toJSON" && typeof v === "function") {
@@ -220,41 +333,46 @@ class RPCJsonSerializer {
         if (v === void 0 && this.omitUndefinedProperties) {
           continue;
         }
-        json[k] = this.serializeValue(v, [...segments, k], meta, maps, blobs)[0];
+        segments.push(k);
+        json[k] = this.serializeValue(v, segments, meta, maps, blobs);
+        segments.pop();
       }
-      return [json, meta, maps, blobs];
+      return json;
     }
-    return [data, meta, maps, blobs];
+    return data;
   }
   deserialize(serialized) {
     const ref = { data: serialized.json };
     if (serialized.blobs?.length) {
-      serialized.maps.forEach((segments, i) => {
+      for (let i = 0; i < serialized.maps.length; i++) {
+        const segments = serialized.maps[i];
         let currentRef = ref;
         let preSegment = "data";
-        segments.forEach((segment) => {
+        for (let j = 0; j < segments.length; j++) {
           currentRef = currentRef[preSegment];
-          preSegment = segment;
+          preSegment = segments[j];
           if (!Object.hasOwn(currentRef, preSegment)) {
             throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
           }
-        });
+        }
         currentRef[preSegment] = serialized.blobs[i];
-      });
+      }
     }
-    serialized.meta?.forEach((item) => {
-      const type = item[0];
-      let currentRef = ref;
-      let preSegment = "data";
-      for (let i = 1; i < item.length; i++) {
-        currentRef = currentRef[preSegment];
-        preSegment = item[i];
-        if (!Object.hasOwn(currentRef, preSegment)) {
-          throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
+    if (serialized.meta) {
+      for (const item of serialized.meta) {
+        const type = item[0];
+        let currentRef = ref;
+        let preSegment = "data";
+        for (let i = 1; i < item.length; i++) {
+          currentRef = currentRef[preSegment];
+          preSegment = item[i];
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
+          }
         }
+        currentRef[preSegment] = this.handlers[type].deserialize(currentRef[preSegment]);
       }
-      currentRef[preSegment] = this.handlers[type].deserialize(currentRef[preSegment]);
-    });
+    }
     return ref.data;
   }
 }
@@ -271,23 +389,23 @@ class RPCSerializer {
       return data;
     }
     if (isAsyncIteratorObject(data)) {
-      return wrapEventIteratorPreservingMeta(data, {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
         mapResult: (result) => {
           if (result.value === void 0) {
             return result;
           }
-          return { done: result.done, value: this.serializeValue(result.value, options) };
+          return { done: result.done, value: this.serializeValue(result.value, false) };
         },
         mapError: (e) => new ErrorEvent(
-          this.serializeValue(toORPCError(e).toJSON(), { ...options, useFormDataForBlobFields: false }),
+          this.serializeValue(toORPCError(e).toJSON(), false),
           { cause: e }
         )
       });
     }
-    return this.serializeValue(data, options);
-  }
-  serializeValue(data, options) {
     const useFormDataForBlobs = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
+    return this.serializeValue(data, useFormDataForBlobs);
+  }
+  serializeValue(data, useFormDataForBlobs) {
     const { json, meta, maps, blobs } = this.jsonSerializer.serialize(data);
     if (!useFormDataForBlobs || !blobs?.length) {
       return { json, meta };
@@ -304,7 +422,7 @@ class RPCSerializer {
       return data;
     }
     if (isAsyncIteratorObject(data)) {
-      return wrapEventIteratorPreservingMeta(data, {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
         mapResult: (result) => {
           if (result.value === void 0) {
             return result;
@@ -331,7 +449,7 @@ class RPCSerializer {
     }
     const serialized = JSON.parse(data.get("data"));
     const blobs = [];
-    for (const [key, value] of data.entries()) {
+    for (const [key, value] of data) {
       if (value instanceof Blob) {
         blobs[Number(key)] = value;
       }
@@ -340,4 +458,4 @@ class RPCSerializer {
   }
 }
 
-export { RPCSerializer as R, isInferableError as a, RPCJsonSerializer as b, createORPCErrorFromJson as c, cloneORPCError as d, isORPCErrorJson as i, toORPCError as t, wrapEventIteratorPreservingMeta as w };
+export { RPCSerializer as R, createORPCErrorFromJson as a, isInferableError as b, createORPCErrorFromMalformedResponse as c, RPCJsonSerializer as d, cloneORPCError as e, isORPCErrorJson as i, toORPCError as t, wrapAsyncIteratorPreservingEventMeta as w };

package/dist/shared/{client.8ug8I-zu.d.mts → client.CFVTHyN6.d.mts}

@@ -1,4 +1,5 @@
 import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse } from '@standardserver/core';
 
 interface ClientContext {
     [key: PropertyKey]: any;
@@ -21,6 +22,11 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type AnyNestedClient = NestedClient<any>;
+/**
+ * Infers the **client context type** required by a client.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-context | Client-Side Clients - Infer Client Context}
+ */
 type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
@@ -29,6 +35,8 @@ interface ClientLink<TClientContext extends ClientContext> {
  * Recursively infers the **input types** from a client.
  *
  * Produces a nested map where each endpoint's input type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-inputs | Client-Side Clients - Infer Client Inputs}
  */
 type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
@@ -38,6 +46,8 @@ type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer
  *
  * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body input types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-inputs | Client-Side Clients - Infer Client Body Inputs}
  */
 type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
     body: infer UBody;
@@ -48,6 +58,8 @@ type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, in
  * Recursively infers the **output types** from a client.
  *
  * Produces a nested map where each endpoint's output type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-outputs | Client-Side Clients - Infer Client Outputs}
  */
 type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
@@ -57,6 +69,8 @@ type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any,
  *
  * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body output types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-outputs | Client-Side Clients - Infer Client Body Outputs}
  */
 type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
     body: infer UBody;
@@ -64,22 +78,33 @@ type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, a
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
 };
 /**
- * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Produces a nested map where each endpoint's error type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-errors | Client-Side Clients - Infer Client Errors}
  */
 type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
 };
 /**
- * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Useful when you want to handle all possible errors from any endpoint at once.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-error | Client-Side Clients - Infer Client Error}
  */
 type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
 }[keyof T];
 
+/**
+ * Default mapping between common oRPC error codes and HTTP status codes.
+ * Handlers use it to determine response status codes; spread it to build a custom `errorStatusMap`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#custom-error-response | RPC Handler - Custom Error Response}
+ * @see {@link https://orpc.dev/docs/openapi/handler#custom-error-response | OpenAPI Handler - Custom Error Response}
+ */
 declare const COMMON_ERROR_STATUS_MAP: {
     BAD_REQUEST: number;
     UNAUTHORIZED: number;
@@ -114,10 +139,16 @@ type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
+/**
+ * Typed error carrying a `code`, a `message`, and optional `data`.
+ * Throw it from handlers or middleware to produce typed error responses on the client.
+ *
+ * @see {@link https://orpc.dev/docs/error-handling#orpcerror-class | Error Handling - ORPCError Class}
+ */
 declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     /**
-     * @info
-     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * @remarks
+     * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
      * an `ORPCError` instance from plain objects with a similar structure.
      */
     readonly name: "ORPCError" & {
@@ -162,6 +193,23 @@ interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCod
 }
 type AnyORPCError = ORPCError<any, any>;
 type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+interface MalformedResponseErrorOptions extends ErrorOptions {
+    message?: string;
+    response: StandardResponse;
+}
+/**
+ * Error indicating a response does not follow the expected oRPC format, carrying
+ * the resolved response. Found as the `cause` of a `MALFORMED_ORPC_RESPONSE`
+ * `ORPCError`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare class MalformedResponseError extends Error {
+    readonly name = "MalformedResponseError";
+    response: StandardResponse;
+    constructor(options: MalformedResponseErrorOptions);
+}
 
-export { ORPCError as c, COMMON_ERROR_STATUS_MAP as j };
-export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, ORPCErrorJSON as d, AnyNestedClient as e, InferClientError as f, Client as g, ClientRest as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };
+export { ORPCError as h, COMMON_ERROR_STATUS_MAP as j, MalformedResponseError as p };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, MalformedResponseErrorOptions as M, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as g, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as q };

package/dist/shared/{client.8ug8I-zu.d.ts → client.CFVTHyN6.d.ts}

@@ -1,4 +1,5 @@
 import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse } from '@standardserver/core';
 
 interface ClientContext {
     [key: PropertyKey]: any;
@@ -21,6 +22,11 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type AnyNestedClient = NestedClient<any>;
+/**
+ * Infers the **client context type** required by a client.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-context | Client-Side Clients - Infer Client Context}
+ */
 type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
@@ -29,6 +35,8 @@ interface ClientLink<TClientContext extends ClientContext> {
  * Recursively infers the **input types** from a client.
  *
  * Produces a nested map where each endpoint's input type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-inputs | Client-Side Clients - Infer Client Inputs}
  */
 type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
@@ -38,6 +46,8 @@ type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer
  *
  * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body input types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-inputs | Client-Side Clients - Infer Client Body Inputs}
  */
 type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
     body: infer UBody;
@@ -48,6 +58,8 @@ type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, in
  * Recursively infers the **output types** from a client.
  *
  * Produces a nested map where each endpoint's output type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-outputs | Client-Side Clients - Infer Client Outputs}
  */
 type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
@@ -57,6 +69,8 @@ type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any,
  *
  * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body output types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-outputs | Client-Side Clients - Infer Client Body Outputs}
  */
 type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
     body: infer UBody;
@@ -64,22 +78,33 @@ type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, a
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
 };
 /**
- * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Produces a nested map where each endpoint's error type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-errors | Client-Side Clients - Infer Client Errors}
  */
 type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
 };
 /**
- * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Useful when you want to handle all possible errors from any endpoint at once.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-error | Client-Side Clients - Infer Client Error}
  */
 type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
 }[keyof T];
 
+/**
+ * Default mapping between common oRPC error codes and HTTP status codes.
+ * Handlers use it to determine response status codes; spread it to build a custom `errorStatusMap`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#custom-error-response | RPC Handler - Custom Error Response}
+ * @see {@link https://orpc.dev/docs/openapi/handler#custom-error-response | OpenAPI Handler - Custom Error Response}
+ */
 declare const COMMON_ERROR_STATUS_MAP: {
     BAD_REQUEST: number;
     UNAUTHORIZED: number;
@@ -114,10 +139,16 @@ type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
+/**
+ * Typed error carrying a `code`, a `message`, and optional `data`.
+ * Throw it from handlers or middleware to produce typed error responses on the client.
+ *
+ * @see {@link https://orpc.dev/docs/error-handling#orpcerror-class | Error Handling - ORPCError Class}
+ */
 declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     /**
-     * @info
-     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * @remarks
+     * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
      * an `ORPCError` instance from plain objects with a similar structure.
      */
     readonly name: "ORPCError" & {
@@ -162,6 +193,23 @@ interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCod
 }
 type AnyORPCError = ORPCError<any, any>;
 type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+interface MalformedResponseErrorOptions extends ErrorOptions {
+    message?: string;
+    response: StandardResponse;
+}
+/**
+ * Error indicating a response does not follow the expected oRPC format, carrying
+ * the resolved response. Found as the `cause` of a `MALFORMED_ORPC_RESPONSE`
+ * `ORPCError`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare class MalformedResponseError extends Error {
+    readonly name = "MalformedResponseError";
+    response: StandardResponse;
+    constructor(options: MalformedResponseErrorOptions);
+}
 
-export { ORPCError as c, COMMON_ERROR_STATUS_MAP as j };
-export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, ORPCErrorJSON as d, AnyNestedClient as e, InferClientError as f, Client as g, ClientRest as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };
+export { ORPCError as h, COMMON_ERROR_STATUS_MAP as j, MalformedResponseError as p };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, MalformedResponseErrorOptions as M, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as g, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as q };

package/dist/shared/{client.Dnfj8jnT.mjs → client.DcoDDrD4.mjs}

@@ -1,4 +1,4 @@
-import { resolveMaybeOptionalOptions, getConstructor } from '@orpc/shared';
+import { resolveMaybeOptionalOptions, getConstructors } from '@orpc/shared';
 
 const COMMON_ERROR_STATUS_MAP = {
   BAD_REQUEST: 400,
@@ -33,8 +33,8 @@ class ORPCError extends Error {
     ORPCErrorConstructors.add(ORPCError);
   }
   /**
-   * @info
-   * The `__branch` property is used for type branding, helping TypeScript distinguish
+   * @remarks
+   * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
    * an `ORPCError` instance from plain objects with a similar structure.
    */
   name = "ORPCError";
@@ -81,12 +81,21 @@ class ORPCError extends Error {
     if (!ORPCErrorConstructors.has(this)) {
       return super[Symbol.hasInstance](instance);
     }
-    const constructor = getConstructor(instance);
-    if (constructor && ORPCErrorConstructors.has(constructor)) {
-      return true;
+    for (const constructor of getConstructors(instance)) {
+      if (ORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
     }
-    return super[Symbol.hasInstance](instance);
+    return false;
+  }
+}
+class MalformedResponseError extends Error {
+  name = "MalformedResponseError";
+  response;
+  constructor(options) {
+    super(options.message, options);
+    this.response = options.response;
   }
 }
 
-export { COMMON_ERROR_STATUS_MAP as C, ORPCError as O };
+export { COMMON_ERROR_STATUS_MAP as C, MalformedResponseError as M, ORPCError as O };