@orpc/client 1.14.6 → 2.0.0-beta.1

package/dist/shared/client.Cby_-GGh.d.mts

@@ -0,0 +1,96 @@
+import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.8ug8I-zu.mjs';
+
+type StandardLinkCodecDecodedResponse = {
+    kind: 'output';
+    output: unknown;
+} | {
+    kind: 'error';
+    error: AnyORPCError;
+};
+interface StandardLinkCodec<T extends ClientContext> {
+    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promisable<StandardRequest>;
+    decodeResponse(response: StandardLazyResponse, path: string[], options: ClientOptions<T>): Promisable<StandardLinkCodecDecodedResponse>;
+}
+
+interface StandardLinkPlugin<T extends ClientContext> extends OrderablePlugin {
+    /**
+     * Initializes the plugin and returns new link options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform link options
+     * such as interceptors, or configuration.
+     *
+     * @param options - The current link options from previous plugins or base configuration
+     * @returns Transformed link options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * init(options) {
+     *   return {
+     *     ...options,
+     *     interceptors: [...(options.interceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    init?(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+declare class CompositeStandardLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    name: string;
+    protected readonly plugins: StandardLinkPlugin<T>[];
+    constructor(plugins?: StandardLinkPlugin<T>[]);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+
+/**
+ * Handles the transport layer for sending requests and receiving responses.
+ *
+ * Implementations are responsible for the actual network communication,
+ * such as HTTP fetch, WebSocket, or other transport mechanisms.
+ */
+interface StandardLinkTransport<T extends ClientContext> {
+    /**
+     * @throws Transport-level errors (network failures, timeouts, etc.)
+     */
+    send(request: StandardRequest, path: string[], options: ClientOptions<T>): Promise<StandardLazyResponse>;
+}
+
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: string[];
+    input: unknown;
+}
+type StandardLinkInterceptor<T extends ClientContext> = Interceptor<StandardLinkInterceptorOptions<T>, Promise<unknown>>;
+interface StandardLinkTransportInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: string[];
+    request: StandardRequest;
+}
+type StandardLinkTransportInterceptor<T extends ClientContext> = Interceptor<StandardLinkTransportInterceptorOptions<T>, Promise<StandardLazyResponse>>;
+interface StandardLinkOptions<T extends ClientContext> {
+    /**
+     * Interceptors that execute around the entire call, including transport and codec.
+     * Useful for error handling, logging, metrics, ...
+     */
+    interceptors?: StandardLinkInterceptor<T>[];
+    /**
+     * Interceptors that execute around the transport layer, after encoding and before decoding.
+     * Useful for modifying the request or response, adding transport-level logging, ...
+     */
+    transportInterceptors?: StandardLinkTransportInterceptor<T>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    private readonly codec;
+    private readonly transport;
+    private readonly interceptors;
+    private readonly transportInterceptors;
+    constructor(codec: StandardLinkCodec<T>, transport: StandardLinkTransport<T>, options?: StandardLinkOptions<T>);
+    /**
+     * @throws ORPCError, transport-level errors (network failures, timeouts, etc.)
+     */
+    call(path: string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+export { CompositeStandardLinkPlugin as C, StandardLink as a };
+export type { StandardLinkTransport as S, StandardLinkOptions as b, StandardLinkPlugin as c, StandardLinkTransportInterceptorOptions as d, StandardLinkInterceptorOptions as e, StandardLinkCodec as f, StandardLinkCodecDecodedResponse as g, StandardLinkInterceptor as h, StandardLinkTransportInterceptor as i };

package/dist/shared/client.DMXKFDyV.mjs

@@ -0,0 +1,343 @@
+import { isPlainObject, wrapAsyncIterator, isTypescriptObject, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { getEventMeta, withEventMeta, ErrorEvent } from '@standardserver/core';
+import { O as ORPCError } from './client.Dnfj8jnT.mjs';
+
+function isInferableError(error) {
+  return error instanceof ORPCError && error.inferable;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", { cause: error });
+}
+function isORPCErrorJson(json) {
+  if (!isPlainObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "inferable", "code", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "inferable" in json && typeof json.inferable === "boolean" && "code" in json && typeof json.code === "string" && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  const error = new ORPCError(json.code, {
+    ...json,
+    ...options
+  });
+  error.defined = json.defined;
+  error.inferable = json.inferable;
+  return error;
+}
+function cloneORPCError(error) {
+  const cloned = new ORPCError(error.code, {
+    ...error,
+    message: error.message,
+    data: error.data,
+    cause: error.cause
+  });
+  cloned.stack = error.stack;
+  cloned.defined = error.defined;
+  cloned.inferable = error.inferable;
+  return cloned;
+}
+
+function wrapEventIteratorPreservingMeta(iterator, { mapResult, mapError, ...rest }) {
+  return wrapAsyncIterator(iterator, {
+    ...rest,
+    mapResult: mapResult && (async (result) => {
+      const mapped = await mapResult(result);
+      if (mapped.value !== result.value) {
+        const meta = getEventMeta(result.value);
+        if (meta && isTypescriptObject(mapped.value)) {
+          return { done: mapped.done, value: withEventMeta(mapped.value, meta) };
+        }
+      }
+      return mapped;
+    }),
+    mapError: mapError && (async (error) => {
+      const mapped = await mapError(error);
+      if (mapped !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isTypescriptObject(mapped)) {
+          return withEventMeta(mapped, meta);
+        }
+      }
+      return mapped;
+    })
+  });
+}
+
+const REGEX_STRING_PATTERN = /^\/(.*)\/([a-z]*)$/;
+const DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
+  undefined: {
+    condition(data) {
+      return data === void 0;
+    },
+    serialize() {
+      return null;
+    },
+    deserialize() {
+      return void 0;
+    },
+    isTerminal: true
+  },
+  bigint: {
+    condition(data) {
+      return typeof data === "bigint";
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      return BigInt(serialized);
+    },
+    isTerminal: true
+  },
+  date: {
+    condition(data) {
+      return data instanceof Date;
+    },
+    serialize(data) {
+      if (Number.isNaN(data.getTime())) {
+        return null;
+      }
+      return data.toISOString();
+    },
+    deserialize(serialized) {
+      return new Date(serialized ?? "Invalid Date");
+    },
+    isTerminal: true
+  },
+  nan: {
+    condition(data) {
+      return typeof data === "number" && Number.isNaN(data);
+    },
+    serialize() {
+      return null;
+    },
+    deserialize() {
+      return Number.NaN;
+    },
+    isTerminal: true
+  },
+  url: {
+    condition(data) {
+      return data instanceof URL;
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      return new URL(serialized);
+    },
+    isTerminal: true
+  },
+  regexp: {
+    condition(data) {
+      return data instanceof RegExp;
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      const [, pattern, flags] = serialized.match(REGEX_STRING_PATTERN);
+      return new RegExp(pattern, flags);
+    },
+    isTerminal: true
+  },
+  set: {
+    condition(data) {
+      return data instanceof Set;
+    },
+    serialize(data) {
+      return Array.from(data);
+    },
+    deserialize(serialized) {
+      return new Set(serialized);
+    }
+  },
+  map: {
+    condition(data) {
+      return data instanceof Map;
+    },
+    serialize(data) {
+      return Array.from(data.entries());
+    },
+    deserialize(serialized) {
+      return new Map(serialized);
+    }
+  }
+};
+class RPCJsonSerializer {
+  handlers;
+  omitUndefinedProperties;
+  constructor(options = {}) {
+    this.handlers = {
+      ...DEFAULT_RPC_JSON_SERIALIZER_HANDLERS,
+      ...options.handlers
+    };
+    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
+  }
+  serialize(data) {
+    const [json, meta_, maps, blobs] = this.serializeValue(data, [], [], [], []);
+    const meta = meta_.length === 0 ? void 0 : meta_;
+    if (maps.length === 0) {
+      return { json, meta };
+    }
+    return { json, meta, maps, blobs };
+  }
+  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];
+        }
+        const result = this.serializeValue(serialized, segments, meta, maps, blobs);
+        meta.push([key, ...segments]);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    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];
+    }
+    if (isPlainObject(data)) {
+      const json = {};
+      for (const k in data) {
+        const v = data[k];
+        if (k === "toJSON" && typeof v === "function") {
+          continue;
+        }
+        if (v === void 0 && this.omitUndefinedProperties) {
+          continue;
+        }
+        json[k] = this.serializeValue(v, [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(serialized) {
+    const ref = { data: serialized.json };
+    if (serialized.blobs?.length) {
+      serialized.maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+          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.`);
+        }
+      }
+      currentRef[preSegment] = this.handlers[type].deserialize(currentRef[preSegment]);
+    });
+    return ref.data;
+  }
+}
+
+class RPCSerializer {
+  jsonSerializer;
+  defaultSerializeOptions;
+  constructor(options = {}) {
+    this.jsonSerializer = new RPCJsonSerializer(options);
+    this.defaultSerializeOptions = options.serialize;
+  }
+  serialize(data, options = {}) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapEventIteratorPreservingMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.serializeValue(result.value, options) };
+        },
+        mapError: (e) => new ErrorEvent(
+          this.serializeValue(toORPCError(e).toJSON(), { ...options, useFormDataForBlobFields: false }),
+          { cause: e }
+        )
+      });
+    }
+    return this.serializeValue(data, options);
+  }
+  serializeValue(data, options) {
+    const useFormDataForBlobs = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
+    const { json, meta, maps, blobs } = this.jsonSerializer.serialize(data);
+    if (!useFormDataForBlobs || !blobs?.length) {
+      return { json, meta };
+    }
+    const form = new FormData();
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapEventIteratorPreservingMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.deserializeValue(result.value) };
+        },
+        mapError: (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.deserializeValue(e.data);
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
+          }
+          return new ErrorEvent(deserialized, { cause: e });
+        }
+      });
+    }
+    return this.deserializeValue(data);
+  }
+  deserializeValue(data) {
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    const blobs = [];
+    for (const [key, value] of data.entries()) {
+      if (value instanceof Blob) {
+        blobs[Number(key)] = value;
+      }
+    }
+    return this.jsonSerializer.deserialize({ ...serialized, blobs });
+  }
+}
+
+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 };

package/dist/shared/client.DXhchJ84.mjs

@@ -0,0 +1,174 @@
+import { sortPlugins, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, intercept, getOpenTelemetryConfig, value, pathToHttpPath, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, parseStandardUrl } from '@standardserver/core';
+import { toStandardHeaders } from '@standardserver/fetch';
+import { O as ORPCError } from './client.Dnfj8jnT.mjs';
+import { R as RPCSerializer, i as isORPCErrorJson, c as createORPCErrorFromJson } from './client.DMXKFDyV.mjs';
+
+class CompositeStandardLinkPlugin {
+  name = "~composite";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        options = plugin.init(options);
+      }
+    }
+    return options;
+  }
+}
+
+class StandardLink {
+  constructor(codec, transport, options = {}) {
+    this.codec = codec;
+    this.transport = transport;
+    options = new CompositeStandardLinkPlugin(options.plugins).init(options);
+    this.interceptors = options.interceptors;
+    this.transportInterceptors = options.transportInterceptors;
+  }
+  interceptors;
+  transportInterceptors;
+  /**
+   * @throws ORPCError, transport-level errors (network failures, timeouts, etc.)
+   */
+  call(path, input, options) {
+    return runWithSpan(`${ORPC_NAME}.${path.join("/")}`, (span) => {
+      span?.setAttribute("rpc.system", ORPC_NAME);
+      span?.setAttribute("rpc.method", path.join("."));
+      if (isAsyncIteratorObject(input)) {
+        input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+      }
+      return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+        const otel = getOpenTelemetryConfig();
+        let activeContext;
+        const activeSpan = otel?.trace.getActiveSpan() ?? span;
+        if (activeSpan && otel) {
+          activeContext = otel.trace.setSpan(otel.context.active(), activeSpan);
+        }
+        let request = await runWithSpan(
+          { name: "encode_input", context: activeContext },
+          () => this.codec.encodeInput(input2, path2, options2)
+        );
+        if (activeContext && otel?.propagation) {
+          const headers = { ...request.headers };
+          otel.propagation.inject(activeContext, headers);
+          request = { ...request, headers };
+        }
+        const response = await intercept(
+          this.transportInterceptors,
+          { ...options2, path: path2, request },
+          ({ path: path3, request: request2, ...options3 }) => {
+            let activeTransportContext;
+            const activeTransportSpan = otel?.trace.getActiveSpan() ?? activeSpan;
+            if (activeTransportSpan && otel) {
+              activeTransportContext = otel.trace.setSpan(otel.context.active(), activeTransportSpan);
+            }
+            return runWithSpan(
+              { name: "send_request", context: activeTransportContext },
+              () => this.transport.send(request2, path3, options3)
+            );
+          }
+        );
+        const decodedResult = await runWithSpan(
+          { name: "decode_response", context: activeContext },
+          () => this.codec.decodeResponse(response, path2, options2)
+        );
+        if (decodedResult.kind === "error") {
+          throw decodedResult.error;
+        }
+        const output = decodedResult.output;
+        if (isAsyncIteratorObject(output)) {
+          return override(output, traceAsyncIterator("consume_event_iterator_output", output));
+        }
+        return output;
+      });
+    });
+  }
+}
+
+const END_SLASH_REGEX = /\/$/;
+class RPCLinkCodec {
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  serializer;
+  constructor(options) {
+    this.baseUrl = options.url ?? "/";
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+    this.serializer = options.serializer ?? new RPCSerializer();
+  }
+  async encodeInput(input, path, options) {
+    let headers = toResolvedStandardHeaders(await value(this.headers, options, path, input));
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const [pathname, search, hash] = parseStandardUrl(baseUrl);
+    const newPathname = `${pathname.replace(END_SLASH_REGEX, "")}${pathToHttpPath(path)}`;
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof Blob) && !(serialized instanceof ReadableStream) && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const mergedSearch = new URLSearchParams(search);
+      mergedSearch.append("data", stringifyJSON(serialized) ?? "");
+      const url2 = `${newPathname}?${mergedSearch}${hash ?? ""}`;
+      if (url2.length <= maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: url2,
+          signal: options.signal
+        };
+      }
+    }
+    const url = `${newPathname}${search ?? ""}${hash ?? ""}`;
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decodeResponse(response) {
+    const isOk = response.status >= 200 && response.status < 400;
+    const body = await response.resolveBody();
+    const deserialized = await (async () => {
+      try {
+        return this.serializer.deserialize(body);
+      } catch (cause) {
+        throw new Error("Invalid RPC response format.", {
+          cause
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        return { kind: "error", error: createORPCErrorFromJson(deserialized) };
+      }
+      return {
+        kind: "error",
+        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
+          data: { headers: response.headers, status: response.status, body: deserialized }
+        })
+      };
+    }
+    return { kind: "output", output: deserialized };
+  }
+}
+function toResolvedStandardHeaders(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders(headers);
+  }
+  return headers;
+}
+
+export { CompositeStandardLinkPlugin as C, RPCLinkCodec as R, StandardLink as S };

package/dist/shared/client.Dnfj8jnT.mjs

@@ -0,0 +1,92 @@
+import { resolveMaybeOptionalOptions, getConstructor } from '@orpc/shared';
+
+const COMMON_ERROR_STATUS_MAP = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_SUPPORTED: 405,
+  NOT_ACCEPTABLE: 406,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_CONTENT: 422,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  CLIENT_CLOSED_REQUEST: 499,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+let ORPCErrorConstructors;
+class ORPCError extends Error {
+  static {
+    const ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for("ORPC_ERROR_CONSTRUCTORS");
+    void (globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
+    ORPCErrorConstructors = globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+    ORPCErrorConstructors.add(ORPCError);
+  }
+  /**
+   * @info
+   * The `__branch` property is used for type branding, helping TypeScript distinguish
+   * an `ORPCError` instance from plain objects with a similar structure.
+   */
+  name = "ORPCError";
+  /**
+   * Indicates whether the error matches a definition in the procedure's `.errors` map.
+   */
+  defined = false;
+  /**
+   * Indicates whether the error's type is inferable at the TypeScript level.
+   * This is typically true when the error is explicitly defined or returned within a handler.
+   */
+  inferable = false;
+  code;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    const message = options.message ?? code.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+    super(message, options);
+    this.code = code;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      inferable: this.inferable,
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+  /**
+   * Workaround for Next.js where different contexts use separate
+   * dependency graphs, causing multiple ORPCError constructors existing and breaking
+   * `instanceof` checks across contexts.
+   *
+   * This is particularly problematic with "Optimized SSR", where orpc-client
+   * executes in one context but is invoked from another. When an error is thrown
+   * in the execution context, `instanceof ORPCError` checks fail in the
+   * invocation context due to separate class constructors.
+   *
+   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (!ORPCErrorConstructors.has(this)) {
+      return super[Symbol.hasInstance](instance);
+    }
+    const constructor = getConstructor(instance);
+    if (constructor && ORPCErrorConstructors.has(constructor)) {
+      return true;
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+
+export { COMMON_ERROR_STATUS_MAP as C, ORPCError as O };