@orpc/client 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/shared/{client.BdItY5DT.d.mts → client.BPa_Mmuh.d.mts}

@@ -1,4 +1,4 @@
-import { StandardBody } from '@standardserver/core';
+import { StandardBody } from '@standard-server/core';
 import { Segment } from '@orpc/shared';
 
 type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
@@ -16,7 +16,10 @@ type RPCJsonSerialization = {
 interface RPCJsonSerializerHandler {
     condition(value: unknown): boolean;
     serialize(value: any): unknown;
-    deserialize(serialized: any): unknown;
+    /**
+     * `serialized` comes from the wire, so validate its type and throw on mismatch.
+     */
+    deserialize(serialized: unknown): unknown;
     /**
      * If false, the result of this serializer will not be further processed by other serializers,
      * even if it matches their conditions and treat it as final serialized value.
@@ -60,10 +63,10 @@ interface RPCJsonSerializerOptions {
      *
      * **Disabling:** Set a key to `undefined` to remove a built-in handler:
      * ```ts
-     * handlers: { regexp: undefined }
+     * handlers: { url: undefined }
      * ```
      *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `infinity`, `url`, `set`, `map`.
      */
     handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
     /**
@@ -73,11 +76,23 @@ interface RPCJsonSerializerOptions {
      */
     omitUndefinedProperties?: boolean | undefined;
 }
+/**
+ * Serializes and deserializes native types like Date, BigInt, Set, and Map
+ * into a JSON value plus separate metadata describing how to restore them.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer#rpc-json-serializer | RPC Serializer - RPC JSON Serializer}
+ */
 declare class RPCJsonSerializer {
     private readonly handlers;
+    private readonly inlineBuiltInHandlers;
+    private readonly handlerEntries;
     private readonly omitUndefinedProperties;
     constructor(options?: RPCJsonSerializerOptions);
     serialize(data: unknown): RPCJsonSerialization;
+    /**
+     * `segments` is a shared mutable stack (push/pop while walking),
+     * so it must be copied before being stored in `meta` or `maps`.
+     */
     private serializeValue;
     deserialize(serialized: RPCJsonSerialization): unknown;
 }
@@ -97,6 +112,12 @@ interface RPCSerializerOptions extends RPCJsonSerializerOptions {
      */
     serialize?: RPCSerializerSerializeOptions | undefined;
 }
+/**
+ * Serializes and deserializes data for the RPC protocol,
+ * preserving native types like Date, BigInt, Set, and Map that plain JSON cannot represent.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer | RPC Serializer}
+ */
 declare class RPCSerializer {
     private readonly jsonSerializer;
     private readonly defaultSerializeOptions;

package/dist/shared/{client.BdItY5DT.d.ts → client.BPa_Mmuh.d.ts}

@@ -1,4 +1,4 @@
-import { StandardBody } from '@standardserver/core';
+import { StandardBody } from '@standard-server/core';
 import { Segment } from '@orpc/shared';
 
 type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
@@ -16,7 +16,10 @@ type RPCJsonSerialization = {
 interface RPCJsonSerializerHandler {
     condition(value: unknown): boolean;
     serialize(value: any): unknown;
-    deserialize(serialized: any): unknown;
+    /**
+     * `serialized` comes from the wire, so validate its type and throw on mismatch.
+     */
+    deserialize(serialized: unknown): unknown;
     /**
      * If false, the result of this serializer will not be further processed by other serializers,
      * even if it matches their conditions and treat it as final serialized value.
@@ -60,10 +63,10 @@ interface RPCJsonSerializerOptions {
      *
      * **Disabling:** Set a key to `undefined` to remove a built-in handler:
      * ```ts
-     * handlers: { regexp: undefined }
+     * handlers: { url: undefined }
      * ```
      *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `infinity`, `url`, `set`, `map`.
      */
     handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
     /**
@@ -73,11 +76,23 @@ interface RPCJsonSerializerOptions {
      */
     omitUndefinedProperties?: boolean | undefined;
 }
+/**
+ * Serializes and deserializes native types like Date, BigInt, Set, and Map
+ * into a JSON value plus separate metadata describing how to restore them.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer#rpc-json-serializer | RPC Serializer - RPC JSON Serializer}
+ */
 declare class RPCJsonSerializer {
     private readonly handlers;
+    private readonly inlineBuiltInHandlers;
+    private readonly handlerEntries;
     private readonly omitUndefinedProperties;
     constructor(options?: RPCJsonSerializerOptions);
     serialize(data: unknown): RPCJsonSerialization;
+    /**
+     * `segments` is a shared mutable stack (push/pop while walking),
+     * so it must be copied before being stored in `meta` or `maps`.
+     */
     private serializeValue;
     deserialize(serialized: RPCJsonSerialization): unknown;
 }
@@ -97,6 +112,12 @@ interface RPCSerializerOptions extends RPCJsonSerializerOptions {
      */
     serialize?: RPCSerializerSerializeOptions | undefined;
 }
+/**
+ * Serializes and deserializes data for the RPC protocol,
+ * preserving native types like Date, BigInt, Set, and Map that plain JSON cannot represent.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer | RPC Serializer}
+ */
 declare class RPCSerializer {
     private readonly jsonSerializer;
     private readonly defaultSerializeOptions;

package/dist/shared/{client.Cby_-GGh.d.mts → client.BjbdW5Rj.d.mts}

@@ -1,6 +1,6 @@
 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';
+import { StandardRequest, StandardLazyResponse } from '@standard-server/core';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.Dw9_40WO.mjs';
 
 type StandardLinkCodecDecodedResponse = {
     kind: 'output';

package/dist/shared/{client.DXhchJ84.mjs → client.Bstqyaro.mjs}

@@ -1,8 +1,7 @@
-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';
+import { sortPlugins, runWithSpan, ORPC_NAME, getTracer, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, intercept, value, pathToHttpPath, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, parseStandardUrl } from '@standard-server/core';
+import { toStandardHeaders } from '@standard-server/fetch';
+import { R as RPCSerializer, c as createORPCErrorFromMalformedResponse, i as isORPCErrorJson, a as createORPCErrorFromJson } from './client.DpkGsZt-.mjs';
 
 class CompositeStandardLinkPlugin {
   name = "~composite";
@@ -37,50 +36,46 @@ class StandardLink {
     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));
+      if (getTracer() && isAsyncIteratorObject(input)) {
+        input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+      } else if (getTracer() && input instanceof ReadableStream) {
+        input = override(input, traceReadableStream("consume_octet_stream_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);
-        }
+        const tracer = getTracer();
+        const activeSpan = tracer?.getActiveSpan() ?? span;
         let request = await runWithSpan(
-          { name: "encode_input", context: activeContext },
+          { name: "encode_input", parent: activeSpan },
           () => this.codec.encodeInput(input2, path2, options2)
         );
-        if (activeContext && otel?.propagation) {
+        if (activeSpan && tracer?.inject) {
           const headers = { ...request.headers };
-          otel.propagation.inject(activeContext, headers);
+          tracer.inject(activeSpan, 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);
-            }
+            const activeTransportSpan = tracer?.getActiveSpan() ?? activeSpan;
             return runWithSpan(
-              { name: "send_request", context: activeTransportContext },
+              { name: "send_request", parent: activeTransportSpan },
               () => this.transport.send(request2, path3, options3)
             );
           }
         );
         const decodedResult = await runWithSpan(
-          { name: "decode_response", context: activeContext },
+          { name: "decode_response", parent: activeSpan },
           () => 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));
+        if (getTracer() && isAsyncIteratorObject(output)) {
+          return override(output, traceAsyncIterator("consume_async_iterator_object_output", output));
+        } else if (getTracer() && output instanceof ReadableStream) {
+          return override(output, traceReadableStream("consume_octet_stream_output", output));
         }
         return output;
       });
@@ -139,13 +134,15 @@ class RPCLinkCodec {
     };
   }
   async decodeResponse(response) {
-    const isOk = response.status >= 200 && response.status < 400;
+    const isOk = 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.", {
+        throw createORPCErrorFromMalformedResponse({
+          message: "Invalid RPC response format.",
+          response: { status: response.status, headers: response.headers, body },
           cause
         });
       }
@@ -156,9 +153,7 @@ class RPCLinkCodec {
       }
       return {
         kind: "error",
-        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
-          data: { headers: response.headers, status: response.status, body: deserialized }
-        })
+        error: createORPCErrorFromMalformedResponse({ response: { headers: response.headers, status: response.status, body } })
       };
     }
     return { kind: "output", output: deserialized };

package/dist/shared/{client.Dnfj8jnT.mjs → client.DD2eNne_.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,
@@ -11,6 +11,7 @@ const COMMON_ERROR_STATUS_MAP = {
   TIMEOUT: 408,
   CONFLICT: 409,
   GONE: 410,
+  LENGTH_REQUIRED: 411,
   PRECONDITION_FAILED: 412,
   PAYLOAD_TOO_LARGE: 413,
   UNSUPPORTED_MEDIA_TYPE: 415,
@@ -33,20 +34,16 @@ 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";
   /**
-   * Indicates whether the error matches a definition in the procedure's `.errors` map.
+   * Indicates whether the error matches a definition in the procedure's `.errors` map,
+   * which makes its type inferable on the client.
    */
   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) {
@@ -59,7 +56,6 @@ class ORPCError extends Error {
   toJSON() {
     return {
       defined: this.defined,
-      inferable: this.inferable,
       code: this.code,
       message: this.message,
       data: this.data
@@ -81,12 +77,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 };

package/dist/shared/{client.CPF3hX6O.d.ts → client.DiHfJmHK.d.ts}

@@ -1,6 +1,6 @@
 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.js';
+import { StandardRequest, StandardLazyResponse } from '@standard-server/core';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.Dw9_40WO.js';
 
 type StandardLinkCodecDecodedResponse = {
     kind: 'output';