@orpc/client 0.41.2 → 0.43.0

package/dist/chunk-4HZVK3GJ.js

@@ -0,0 +1,212 @@
+import {
+  ORPCError,
+  mapEventIterator,
+  toORPCError
+} from "./chunk-X34KXUAJ.js";
+
+// src/rpc/json-serializer.ts
+import { isObject } from "@orpc/shared";
+var RPCJsonSerializer = class {
+  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    if (typeof data === "bigint") {
+      meta.push([0, segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Date) {
+      meta.push([1, segments]);
+      if (Number.isNaN(data.getTime())) {
+        return [null, meta, maps, blobs];
+      }
+      return [data.toISOString(), meta, maps, blobs];
+    }
+    if (Number.isNaN(data)) {
+      meta.push([2, segments]);
+      return [null, meta, maps, blobs];
+    }
+    if (data instanceof URL) {
+      meta.push([4, segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof RegExp) {
+      meta.push([5, segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Set) {
+      const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
+      meta.push([6, segments]);
+      return result;
+    }
+    if (data instanceof Map) {
+      const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
+      meta.push([7, segments]);
+      return result;
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v, i) => {
+        if (v === void 0) {
+          meta.push([3, [...segments, i]]);
+          return v;
+        }
+        return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
+      });
+      return [json, meta, maps, blobs];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(json, meta, maps, getBlob) {
+    const ref = { data: json };
+    if (maps && getBlob) {
+      maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+        });
+        currentRef[preSegment] = getBlob(i);
+      });
+    }
+    for (const [type, segments] of meta) {
+      let currentRef = ref;
+      let preSegment = "data";
+      segments.forEach((segment) => {
+        currentRef = currentRef[preSegment];
+        preSegment = segment;
+      });
+      switch (type) {
+        case 0:
+          currentRef[preSegment] = BigInt(currentRef[preSegment]);
+          break;
+        case 1:
+          currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
+          break;
+        case 2:
+          currentRef[preSegment] = Number.NaN;
+          break;
+        case 3:
+          currentRef[preSegment] = void 0;
+          break;
+        case 4:
+          currentRef[preSegment] = new URL(currentRef[preSegment]);
+          break;
+        case 5: {
+          const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
+          currentRef[preSegment] = new RegExp(pattern, flags);
+          break;
+        }
+        case 6:
+          currentRef[preSegment] = new Set(currentRef[preSegment]);
+          break;
+        case 7:
+          currentRef[preSegment] = new Map(currentRef[preSegment]);
+          break;
+        /* v8 ignore next 3 */
+        default: {
+          const _expected = type;
+        }
+      }
+    }
+    return ref.data;
+  }
+};
+
+// src/rpc/serializer.ts
+import { ErrorEvent, isAsyncIteratorObject } from "@orpc/standard-server";
+var RPCSerializer = class {
+  constructor(jsonSerializer = new RPCJsonSerializer()) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, false),
+        error: async (e) => {
+          if (e instanceof ErrorEvent) {
+            return new ErrorEvent({
+              data: this.#serialize(e.data, false),
+              cause: e
+            });
+          }
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    if (data === void 0 || data instanceof Blob) {
+      return data;
+    }
+    const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
+    const meta = meta_.length === 0 ? void 0 : meta_;
+    if (!enableFormData || blobs.length === 0) {
+      return {
+        json,
+        meta
+      };
+    }
+    const form = new FormData();
+    form.set("data", JSON.stringify({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#deserialize(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.#deserialize(e.data);
+          if (ORPCError.isValidJSON(deserialized)) {
+            return ORPCError.fromJSON(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#deserialize(data);
+  }
+  #deserialize(data) {
+    if (data === void 0 || data instanceof Blob) {
+      return data;
+    }
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    return this.jsonSerializer.deserialize(
+      serialized.json,
+      serialized.meta ?? [],
+      serialized.maps,
+      (i) => data.get(i.toString())
+    );
+  }
+};
+
+export {
+  RPCJsonSerializer,
+  RPCSerializer
+};
+//# sourceMappingURL=chunk-4HZVK3GJ.js.map

package/dist/{chunk-2UPNYYFF.js → chunk-X34KXUAJ.js}

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/error.ts
 import { isObject } from "@orpc/shared";
 var COMMON_ORPC_ERROR_DEFS = {
@@ -171,8 +165,8 @@ function onEventIteratorStatusChange(iterator, callback, notifyImmediately = tru
 }
 
 // src/event-iterator.ts
-import { getEventMeta, isEventMetaContainer, withEventMeta } from "@orpc/server-standard";
 import { retry } from "@orpc/shared";
+import { getEventMeta, isEventMetaContainer, withEventMeta } from "@orpc/standard-server";
 function mapEventIterator(iterator, maps) {
   return async function* () {
     try {
@@ -272,7 +266,6 @@ function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
 }
 
 export {
-  __export,
   COMMON_ORPC_ERROR_DEFS,
   fallbackORPCErrorStatus,
   fallbackORPCErrorMessage,
@@ -285,4 +278,4 @@ export {
   mapEventIterator,
   createAutoRetryEventIterator
 };
-//# sourceMappingURL=chunk-2UPNYYFF.js.map
+//# sourceMappingURL=chunk-X34KXUAJ.js.map

package/dist/fetch.js

@@ -1,15 +1,15 @@
 import {
   RPCSerializer
-} from "./chunk-TPEMQB7D.js";
+} from "./chunk-4HZVK3GJ.js";
 import {
   ORPCError,
   createAutoRetryEventIterator
-} from "./chunk-2UPNYYFF.js";
+} from "./chunk-X34KXUAJ.js";
 
 // src/adapters/fetch/rpc-link.ts
-import { isAsyncIteratorObject } from "@orpc/server-standard";
-import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
 import { trim, value } from "@orpc/shared";
+import { isAsyncIteratorObject } from "@orpc/standard-server";
+import { toFetchBody, toStandardBody } from "@orpc/standard-server-fetch";
 var InvalidEventSourceRetryResponse = class extends Error {
 };
 var RPCLink = class {
@@ -101,9 +101,9 @@ var RPCLink = class {
     const headers = new Headers(await value(this.headers, options, path, input));
     const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
     const serialized = this.rpcSerializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
       const getUrl = new URL(url);
-      getUrl.searchParams.append("data", JSON.stringify(serialized));
+      getUrl.searchParams.append("data", JSON.stringify(serialized) ?? "");
       if (getUrl.toString().length <= this.maxUrlLength) {
         return {
           body: void 0,

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   registerEventIteratorState,
   toORPCError,
   updateEventIteratorStatus
-} from "./chunk-2UPNYYFF.js";
+} from "./chunk-X34KXUAJ.js";
 
 // src/client.ts
 function createORPCClient(link, options) {
@@ -53,13 +53,22 @@ var DynamicLink = class {
 async function safe(promise) {
   try {
     const output = await promise;
-    return [output, void 0, false];
+    return Object.assign(
+      [null, output, false],
+      { error: null, data: output, isDefined: false }
+    );
   } catch (e) {
     const error = e;
     if (isDefinedError(error)) {
-      return [void 0, error, true];
+      return Object.assign(
+        [error, void 0, true],
+        { error, data: void 0, isDefined: true }
+      );
     }
-    return [void 0, error, false];
+    return Object.assign(
+      [error, void 0, false],
+      { error, data: void 0, isDefined: false }
+    );
   }
 }
 export {

package/dist/openapi.js

@@ -1,314 +1,216 @@
 import {
   ORPCError,
-  __export,
   mapEventIterator,
   toORPCError
-} from "./chunk-2UPNYYFF.js";
+} from "./chunk-X34KXUAJ.js";
 
 // src/openapi/bracket-notation.ts
-var bracket_notation_exports = {};
-__export(bracket_notation_exports, {
-  deserialize: () => deserialize,
-  escapeSegment: () => escapeSegment,
-  parsePath: () => parsePath,
-  serialize: () => serialize,
-  stringifyPath: () => stringifyPath
-});
 import { isObject } from "@orpc/shared";
-function serialize(payload, parentKey = "") {
-  if (!Array.isArray(payload) && !isObject(payload))
-    return [["", payload]];
-  const result = [];
-  function helper(value, path) {
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        helper(item, [...path, String(index)]);
+var BracketNotationSerializer = class {
+  serialize(data, segments = [], result = []) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        this.serialize(item, [...segments, i], result);
       });
-    } else if (isObject(value)) {
-      for (const [key, val] of Object.entries(value)) {
-        helper(val, [...path, key]);
+    } else if (isObject(data)) {
+      for (const key in data) {
+        this.serialize(data[key], [...segments, key], result);
       }
     } else {
-      result.push([stringifyPath(path), value]);
+      result.push([this.stringifyPath(segments), data]);
     }
+    return result;
   }
-  helper(payload, parentKey ? [parentKey] : []);
-  return result;
-}
-function deserialize(entities) {
-  if (entities.length === 0) {
-    return void 0;
-  }
-  const isRootArray = entities.every(([path]) => path === "");
-  const result = isRootArray ? [] : {};
-  const arrayPushPaths = /* @__PURE__ */ new Set();
-  for (const [path, _] of entities) {
-    const segments = parsePath(path);
-    const base = segments.slice(0, -1).join(".");
-    const last = segments[segments.length - 1];
-    if (last === "") {
-      arrayPushPaths.add(base);
-    } else {
-      arrayPushPaths.delete(base);
-    }
-  }
-  function setValue(obj, segments, value, fullPath) {
-    const [first, ...rest_] = segments;
-    if (Array.isArray(obj) && first === "") {
-      ;
-      obj.push(value);
-      return;
-    }
-    const objAsRecord = obj;
-    if (rest_.length === 0) {
-      objAsRecord[first] = value;
-      return;
-    }
-    const rest = rest_;
-    if (rest[0] === "") {
-      const pathToCheck = segments.slice(0, -1).join(".");
-      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
-        if (!(first in objAsRecord)) {
-          objAsRecord[first] = [];
-        }
-        if (Array.isArray(objAsRecord[first])) {
-          ;
-          objAsRecord[first].push(value);
-          return;
+  deserialize(serialized) {
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const ref = { value: [] };
+    for (const [path, value] of serialized) {
+      const segments = this.parsePath(path);
+      let currentRef = ref;
+      let nextSegment = "value";
+      segments.forEach((segment, i) => {
+        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+          currentRef[nextSegment] = [];
         }
-      }
-      if (!(first in objAsRecord)) {
-        objAsRecord[first] = {};
-      }
-      const target = objAsRecord[first];
-      target[""] = value;
-      return;
-    }
-    if (!(first in objAsRecord)) {
-      objAsRecord[first] = {};
-    }
-    setValue(
-      objAsRecord[first],
-      rest,
-      value,
-      fullPath
-    );
-  }
-  for (const [path, value] of entities) {
-    const segments = parsePath(path);
-    setValue(result, segments, value, path);
-  }
-  return result;
-}
-function escapeSegment(segment) {
-  return segment.replace(/[\\[\]]/g, (match) => {
-    switch (match) {
-      case "\\":
-        return "\\\\";
-      case "[":
-        return "\\[";
-      case "]":
-        return "\\]";
-      default:
-        return match;
-    }
-  });
-}
-function stringifyPath(path) {
-  const [first, ...rest] = path;
-  const firstSegment = escapeSegment(first);
-  const base = first === "" ? "" : firstSegment;
-  return rest.reduce(
-    (result, segment) => `${result}[${escapeSegment(segment)}]`,
-    base
-  );
-}
-function parsePath(path) {
-  if (path === "")
-    return [""];
-  const result = [];
-  let currentSegment = "";
-  let inBracket = false;
-  let bracketContent = "";
-  let backslashCount = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    if (char === "\\") {
-      backslashCount++;
-      continue;
-    }
-    if (backslashCount > 0) {
-      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
-      if (char === "[" || char === "]") {
-        if (backslashCount % 2 === 1) {
-          if (inBracket) {
-            bracketContent += literalBackslashes + char;
-          } else {
-            currentSegment += literalBackslashes + char;
+        if (i !== segments.length - 1) {
+          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
+            currentRef[nextSegment] = { ...currentRef[nextSegment] };
           }
         } else {
-          if (inBracket) {
-            bracketContent += literalBackslashes;
-          } else {
-            currentSegment += literalBackslashes;
-          }
-          if (char === "[" && !inBracket) {
-            if (currentSegment !== "" || result.length === 0) {
-              result.push(currentSegment);
-            }
-            inBracket = true;
-            bracketContent = "";
-            currentSegment = "";
-          } else if (char === "]" && inBracket) {
-            result.push(bracketContent);
-            inBracket = false;
-            bracketContent = "";
-          } else {
-            if (inBracket) {
-              bracketContent += char;
+          if (Array.isArray(currentRef[nextSegment])) {
+            if (segment === "") {
+              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
             } else {
-              currentSegment += char;
+              if (arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
+              } else if (!isValidArrayIndex(segment)) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
             }
           }
         }
-      } else {
-        const allBackslashes = "\\".repeat(backslashCount);
-        if (inBracket) {
-          bracketContent += allBackslashes + char;
+        currentRef = currentRef[nextSegment];
+        nextSegment = segment;
+      });
+      if (Array.isArray(currentRef)) {
+        if (nextSegment === "") {
+          arrayPushStyles.add(currentRef);
+          currentRef.push(value);
         } else {
-          currentSegment += allBackslashes + char;
+          currentRef[Number(nextSegment)] = value;
         }
+      } else {
+        currentRef[nextSegment] = value;
       }
-      backslashCount = 0;
-      continue;
-    }
-    if (char === "[" && !inBracket) {
-      if (currentSegment !== "" || result.length === 0) {
-        result.push(currentSegment);
-      }
-      inBracket = true;
-      bracketContent = "";
-      currentSegment = "";
-      continue;
-    }
-    if (char === "]" && inBracket) {
-      result.push(bracketContent);
-      inBracket = false;
-      bracketContent = "";
-      continue;
-    }
-    if (inBracket) {
-      bracketContent += char;
-    } else {
-      currentSegment += char;
     }
+    return ref.value;
   }
-  if (backslashCount > 0) {
-    const remainingBackslashes = "\\".repeat(backslashCount);
-    if (inBracket) {
-      bracketContent += remainingBackslashes;
-    } else {
-      currentSegment += remainingBackslashes;
-    }
+  stringifyPath(segments) {
+    return segments.map((segment) => {
+      return segment.toString().replace(/[\\[\]]/g, (match) => {
+        switch (match) {
+          case "\\":
+            return "\\\\";
+          case "[":
+            return "\\[";
+          case "]":
+            return "\\]";
+          /* v8 ignore next 2 */
+          default:
+            return match;
+        }
+      });
+    }).reduce((result, segment, i) => {
+      if (i === 0) {
+        return segment;
+      }
+      return `${result}[${segment}]`;
+    }, "");
   }
-  if (inBracket) {
-    if (currentSegment !== "" || result.length === 0) {
-      result.push(currentSegment);
+  parsePath(path) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    let backslashCount = 0;
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      const nextChar = path[i + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i++;
+      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else if (char === "\\") {
+        backslashCount++;
+      } else {
+        currentSegment += "\\".repeat(backslashCount / 2) + char;
+        backslashCount = 0;
+      }
     }
-    result.push(`[${bracketContent}`);
-  } else if (currentSegment !== "" || result.length === 0) {
-    result.push(currentSegment);
+    return inBrackets || segments.length === 0 ? [path] : segments;
   }
-  return result;
+};
+function isValidArrayIndex(value) {
+  return /^0$|^[1-9]\d*$/.test(value);
 }
 
 // src/openapi/json-serializer.ts
 import { isObject as isObject2 } from "@orpc/shared";
 var OpenAPIJsonSerializer = class {
-  serialize(payload) {
-    if (payload instanceof Set)
-      return this.serialize([...payload]);
-    if (payload instanceof Map)
-      return this.serialize([...payload.entries()]);
-    if (Array.isArray(payload)) {
-      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
+  serialize(data, hasBlobRef = { value: false }) {
+    if (data instanceof Blob) {
+      hasBlobRef.value = true;
+      return [data, hasBlobRef.value];
+    }
+    if (data instanceof Set) {
+      return this.serialize(Array.from(data), hasBlobRef);
+    }
+    if (data instanceof Map) {
+      return this.serialize(Array.from(data.entries()), hasBlobRef);
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
+      return [json, hasBlobRef.value];
     }
-    if (Number.isNaN(payload))
-      return "NaN";
-    if (typeof payload === "bigint")
-      return payload.toString();
-    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
-      return "Invalid Date";
+    if (isObject2(data)) {
+      const json = {};
+      for (const k in data) {
+        json[k] = this.serialize(data[k], hasBlobRef)[0];
+      }
+      return [json, hasBlobRef.value];
+    }
+    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+      return [data.toString(), hasBlobRef.value];
+    }
+    if (data instanceof Date) {
+      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+    }
+    if (Number.isNaN(data)) {
+      return [null, hasBlobRef.value];
     }
-    if (payload instanceof RegExp)
-      return payload.toString();
-    if (payload instanceof URL)
-      return payload.toString();
-    if (!isObject2(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
+    return [data, hasBlobRef.value];
   }
 };
 
 // src/openapi/serializer.ts
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches } from "@orpc/shared";
+import { ErrorEvent, isAsyncIteratorObject } from "@orpc/standard-server";
 var OpenAPISerializer = class {
-  jsonSerializer;
-  constructor(options) {
-    this.jsonSerializer = options?.jsonSerializer ?? new OpenAPIJsonSerializer();
+  constructor(jsonSerializer = new OpenAPIJsonSerializer(), bracketNotation = new BracketNotationSerializer()) {
+    this.jsonSerializer = jsonSerializer;
+    this.bracketNotation = bracketNotation;
   }
   serialize(data) {
-    if (data instanceof Blob || data === void 0) {
-      return data;
-    }
     if (isAsyncIteratorObject(data)) {
       return mapEventIterator(data, {
-        value: async (value) => this.jsonSerializer.serialize(value),
+        value: async (value) => this.#serialize(value, false),
         error: async (e) => {
           if (e instanceof ErrorEvent) {
             return new ErrorEvent({
-              data: this.jsonSerializer.serialize(e.data),
+              data: this.#serialize(e.data, false),
               cause: e
             });
           }
           return new ErrorEvent({
-            data: this.jsonSerializer.serialize(toORPCError(e).toJSON()),
+            data: this.#serialize(toORPCError(e).toJSON(), false),
             cause: e
           });
         }
       });
     }
-    const serializedJSON = this.jsonSerializer.serialize(data);
-    const { values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON);
-    if (blobs.length === 0) {
-      return serializedJSON;
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    if (data instanceof Blob || data === void 0) {
+      return data;
+    }
+    const [json, hasBlob] = this.jsonSerializer.serialize(data);
+    if (!enableFormData || !hasBlob) {
+      return json;
     }
     const form = new FormData();
-    for (const [path, value] of serialize(serializedJSON)) {
+    for (const [path, value] of this.bracketNotation.serialize(json)) {
       if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
         form.append(path, value.toString());
-      } else if (value instanceof Date) {
-        form.append(path, value.toISOString());
       } else if (value instanceof Blob) {
         form.append(path, value);
       }
     }
     return form;
   }
-  deserialize(serialized) {
-    if (serialized instanceof URLSearchParams || serialized instanceof FormData) {
-      return deserialize([...serialized.entries()]);
+  deserialize(data) {
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      return this.bracketNotation.deserialize(Array.from(data.entries()));
     }
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
         value: async (value) => value,
         error: async (e) => {
           if (e instanceof ErrorEvent && ORPCError.isValidJSON(e.data)) {
@@ -318,11 +220,11 @@ var OpenAPISerializer = class {
         }
       });
     }
-    return serialized;
+    return data;
   }
 };
 export {
-  bracket_notation_exports as BracketNotation,
+  BracketNotationSerializer,
   OpenAPIJsonSerializer,
   OpenAPISerializer
 };

package/dist/rpc.js

@@ -1,10 +1,10 @@
 import {
-  RPCSerializer,
-  serializeRPCJson
-} from "./chunk-TPEMQB7D.js";
-import "./chunk-2UPNYYFF.js";
+  RPCJsonSerializer,
+  RPCSerializer
+} from "./chunk-4HZVK3GJ.js";
+import "./chunk-X34KXUAJ.js";
 export {
-  RPCSerializer,
-  serializeRPCJson
+  RPCJsonSerializer,
+  RPCSerializer
 };
 //# sourceMappingURL=rpc.js.map

package/dist/src/openapi/bracket-notation.d.ts

@@ -1,84 +1,9 @@
-/**
- * Serialize an object or array into a list of [key, value] pairs.
- * The key will express by using bracket-notation.
- *
- * Notice: This way cannot express the empty object or array.
- *
- * @example
- * ```ts
- * const payload = {
- *  name: 'John Doe',
- *  pets: ['dog', 'cat'],
- * }
- *
- * const entities = serialize(payload)
- *
- * expect(entities).toEqual([
- *  ['name', 'John Doe'],
- *  ['name[pets][0]', 'dog'],
- *  ['name[pets][1]', 'cat'],
- * ])
- * ```
- */
-export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
-/**
- * Deserialize a list of [key, value] pairs into an object or array.
- * The key is expressed by using bracket-notation.
- *
- * @example
- * ```ts
- * const entities = [
- *  ['name', 'John Doe'],
- *  ['name[pets][0]', 'dog'],
- *  ['name[pets][1]', 'cat'],
- *  ['name[dogs][]', 'hello'],
- *  ['name[dogs][]', 'kitty'],
- * ]
- *
- * const payload = deserialize(entities)
- *
- * expect(payload).toEqual({
- *  name: 'John Doe',
- *  pets: { 0: 'dog', 1: 'cat' },
- *  dogs: ['hello', 'kitty'],
- * })
- * ```
- */
-export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
-/**
- * Escape the `[`, `]`, and `\` chars in a path segment.
- *
- * @example
- * ```ts
- * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
- * ```
- */
-export declare function escapeSegment(segment: string): string;
-/**
- * Convert an array of path segments into a path string using bracket-notation.
- *
- * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
- *
- * @example
- * ```ts
- * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
- * ```
- */
-export declare function stringifyPath(path: readonly [string, ...string[]]): string;
-/**
- * Convert a path string using bracket-notation into an array of path segments.
- *
- * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
- * It only treats a pair `[${string}]` as a path segment.
- * If missing or escape it will bypass and treat as normal string.
- *
- * @example
- * ```ts
- * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
- * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
- * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
- * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
- * ```
- */
-export declare function parsePath(path: string): [string, ...string[]];
+import { type Segment } from '@orpc/shared';
+export type BracketNotationSerialized = [string, unknown][];
+export declare class BracketNotationSerializer {
+    serialize(data: unknown, segments?: Segment[], result?: BracketNotationSerialized): BracketNotationSerialized;
+    deserialize(serialized: BracketNotationSerialized): unknown;
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
 //# sourceMappingURL=bracket-notation.d.ts.map

package/dist/src/openapi/index.d.ts

@@ -1,4 +1,4 @@
-export * as BracketNotation from './bracket-notation';
+export * from './bracket-notation';
 export * from './json-serializer';
 export * from './serializer';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/openapi/json-serializer.d.ts

@@ -1,5 +1,7 @@
+export type OpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
 export declare class OpenAPIJsonSerializer {
-    serialize(payload: unknown): unknown;
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): OpenAPIJsonSerialized;
 }
-export type PublicOpenAPIJsonSerializer = Pick<OpenAPIJsonSerializer, keyof OpenAPIJsonSerializer>;
 //# sourceMappingURL=json-serializer.d.ts.map

package/dist/src/openapi/serializer.d.ts

@@ -1,11 +1,11 @@
-import type { PublicOpenAPIJsonSerializer } from './json-serializer';
-export interface OpenAPISerializerOptions {
-    jsonSerializer?: PublicOpenAPIJsonSerializer;
-}
+import { BracketNotationSerializer } from './bracket-notation';
+import { OpenAPIJsonSerializer } from './json-serializer';
 export declare class OpenAPISerializer {
+    #private;
     private readonly jsonSerializer;
-    constructor(options?: OpenAPISerializerOptions);
+    private readonly bracketNotation;
+    constructor(jsonSerializer?: OpenAPIJsonSerializer, bracketNotation?: BracketNotationSerializer);
     serialize(data: unknown): unknown;
-    deserialize(serialized: unknown): unknown;
+    deserialize(data: unknown): unknown;
 }
 //# sourceMappingURL=serializer.d.ts.map

package/dist/src/rpc/index.d.ts

@@ -1,2 +1,3 @@
+export * from './json-serializer';
 export * from './serializer';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/rpc/json-serializer.d.ts

@@ -0,0 +1,12 @@
+import { type Segment } from '@orpc/shared';
+export type RPCJsonSerializedMeta = [
+    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
+    Segment[]
+][];
+export type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
+export declare class RPCJsonSerializer {
+    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
+    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+//# sourceMappingURL=json-serializer.d.ts.map

package/dist/src/rpc/serializer.d.ts

@@ -1,22 +1,9 @@
-import type { Segment } from '@orpc/shared';
-export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
-export type RPCSerialized = {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-} | FormData | AsyncIteratorObject<{
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-}, {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-}, void>;
-export type RPCSerializedFormDataMaps = Segment[][];
+import { RPCJsonSerializer } from './json-serializer';
 export declare class RPCSerializer {
-    serialize(data: unknown): RPCSerialized;
-    deserialize(serialized: RPCSerialized): unknown;
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer?: RPCJsonSerializer);
+    serialize(data: unknown): unknown;
+    deserialize(data: unknown): unknown;
 }
-export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-};
 //# sourceMappingURL=serializer.d.ts.map

package/dist/src/utils.d.ts

@@ -1,5 +1,17 @@
 import type { ORPCError } from './error';
 import type { ClientPromiseResult } from './types';
-export type SafeResult<TOutput, TError extends Error> = [output: TOutput, error: undefined, isDefinedError: false] | [output: undefined, error: TError, isDefinedError: false] | [output: undefined, error: Extract<TError, ORPCError<any, any>>, isDefinedError: true];
+export type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+    error: null;
+    data: TOutput;
+    isDefined: false;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    error: Extract<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: true;
+};
 export declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.41.2",
+  "version": "0.43.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -44,9 +44,9 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/shared": "0.41.2"
+    "@orpc/shared": "0.43.0",
+    "@orpc/standard-server-fetch": "0.43.0",
+    "@orpc/standard-server": "0.43.0"
   },
   "devDependencies": {
     "zod": "^3.24.1"

package/dist/chunk-TPEMQB7D.js

@@ -1,178 +0,0 @@
-import {
-  ORPCError,
-  mapEventIterator,
-  toORPCError
-} from "./chunk-2UPNYYFF.js";
-
-// src/rpc/serializer.ts
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches, isObject, set } from "@orpc/shared";
-var RPCSerializer = class {
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => serializeRPCJson(value),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: serializeRPCJson(e.data),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: serializeRPCJson(toORPCError(e).toJSON()),
-            cause: e
-          });
-        }
-      });
-    }
-    const serializedJSON = serializeRPCJson(data);
-    const { maps, values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON.json);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    form.set("data", JSON.stringify(serializedJSON));
-    form.set("maps", JSON.stringify(maps));
-    for (const i in blobs) {
-      form.set(i, blobs[i]);
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
-        value: async (value) => deserializeRPCJson(value),
-        error: async (e) => {
-          if (!(e instanceof ErrorEvent)) {
-            return e;
-          }
-          const deserialized = deserializeRPCJson(e.data);
-          if (ORPCError.isValidJSON(deserialized)) {
-            return ORPCError.fromJSON(deserialized, { cause: e });
-          }
-          return new ErrorEvent({
-            data: deserialized,
-            cause: e
-          });
-        }
-      });
-    }
-    if (!(serialized instanceof FormData)) {
-      return deserializeRPCJson(serialized);
-    }
-    const data = JSON.parse(serialized.get("data"));
-    const maps = JSON.parse(serialized.get("maps"));
-    for (const i in maps) {
-      data.json = set(data.json, maps[i], serialized.get(i));
-    }
-    return deserializeRPCJson(data);
-  }
-};
-function serializeRPCJson(value, segments = [], meta = []) {
-  if (typeof value === "bigint") {
-    meta.push(["bigint", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof Date) {
-    meta.push(["date", segments]);
-    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-    return { json: data, meta };
-  }
-  if (Number.isNaN(value)) {
-    meta.push(["nan", segments]);
-    return { json: "NaN", meta };
-  }
-  if (value instanceof RegExp) {
-    meta.push(["regexp", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof URL) {
-    meta.push(["url", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (isObject(value)) {
-    const json = {};
-    for (const k in value) {
-      json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
-    }
-    return { json, meta };
-  }
-  if (Array.isArray(value)) {
-    const json = value.map((v, i) => {
-      if (v === void 0) {
-        meta.push(["undefined", [...segments, i]]);
-        return null;
-      }
-      return serializeRPCJson(v, [...segments, i], meta).json;
-    });
-    return { json, meta };
-  }
-  if (value instanceof Set) {
-    const result = serializeRPCJson(Array.from(value), segments, meta);
-    meta.push(["set", segments]);
-    return result;
-  }
-  if (value instanceof Map) {
-    const result = serializeRPCJson(Array.from(value.entries()), segments, meta);
-    meta.push(["map", segments]);
-    return result;
-  }
-  return { json: value, meta };
-}
-function deserializeRPCJson({
-  json,
-  meta
-}) {
-  if (meta.length === 0) {
-    return json;
-  }
-  const ref = { data: json };
-  for (const [type, segments] of meta) {
-    let currentRef = ref;
-    let preSegment = "data";
-    for (let i = 0; i < segments.length; i++) {
-      currentRef = currentRef[preSegment];
-      preSegment = segments[i];
-    }
-    switch (type) {
-      case "nan":
-        currentRef[preSegment] = Number.NaN;
-        break;
-      case "bigint":
-        currentRef[preSegment] = BigInt(currentRef[preSegment]);
-        break;
-      case "date":
-        currentRef[preSegment] = new Date(currentRef[preSegment]);
-        break;
-      case "regexp": {
-        const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
-        currentRef[preSegment] = new RegExp(pattern, flags);
-        break;
-      }
-      case "url":
-        currentRef[preSegment] = new URL(currentRef[preSegment]);
-        break;
-      case "undefined":
-        currentRef[preSegment] = void 0;
-        break;
-      case "map":
-        currentRef[preSegment] = new Map(currentRef[preSegment]);
-        break;
-      case "set":
-        currentRef[preSegment] = new Set(currentRef[preSegment]);
-        break;
-      /* v8 ignore next 3 */
-      default: {
-        const _expected = type;
-      }
-    }
-  }
-  return ref.data;
-}
-
-export {
-  RPCSerializer,
-  serializeRPCJson
-};
-//# sourceMappingURL=chunk-TPEMQB7D.js.map