zodbridge 0.2.0

package/dist/rules-msHkZDR8.d.cts

@@ -0,0 +1,59 @@
+/**
+ * Rule kinds for {@link createMap} and the dot-path get/set helpers they use.
+ *
+ * Rule kinds (by JS type):
+ * - `string`            — rename: copy `source[ruleValue]` to the dest key. Auto-reversible.
+ * - `(source) => value` — computed function, one-way (no reverse unless paired).
+ * - `{ to, from }`      — explicit both-directions, reversible.
+ * - `FromResolver`      — value pulled from a resolver graph (async path, Phase 5).
+ */
+/** A function rule: derive a dest value from the whole source object. */
+type FnRule<S, V> = (source: S) => V;
+/** A reversible rule with explicit forward (`to`) and inverse (`from`) maps. */
+interface PairRule<S, V> {
+    to: (source: S) => V;
+    from: (value: V) => unknown;
+}
+/** Marker for a dest field resolved from a resolver graph (consumed by Phase 5). */
+interface FromResolver {
+    readonly __kind: "fromResolver";
+    readonly field: string;
+}
+/**
+ * Default-value rule: read `source` (a source key, defaults to the dest key)
+ * and fall back to `value` when the source is `undefined`. Reverse-safe: the
+ * default is dropped on reverse and only the read key round-trips.
+ */
+interface DefaultRule<V = unknown> {
+    readonly __kind: "default";
+    readonly value: V;
+    readonly source?: string;
+}
+/** Any rule a dest key may be configured with. */
+type Rule<S = any, V = any> = string | FnRule<S, V> | PairRule<S, V> | FromResolver | DefaultRule<V>;
+/** Build a {@link FromResolver} marker for `field` in the resolver graph. */
+declare function fromResolver(field: string): FromResolver;
+/**
+ * Build a {@link DefaultRule}: use `source` (or the dest key) from the entity,
+ * falling back to `value` when absent.
+ */
+declare function withDefault<V>(value: V, source?: string): DefaultRule<V>;
+declare function isStringRule(rule: Rule): rule is string;
+declare function isFromResolverRule(rule: Rule): rule is FromResolver;
+declare function isPairRule(rule: Rule): rule is PairRule<any, any>;
+declare function isDefaultRule(rule: Rule): rule is DefaultRule;
+declare function isFnRule(rule: Rule): rule is FnRule<any, any>;
+/**
+ * Read a nested value by dot-path. Returns `undefined` if any segment is
+ * missing or if a segment is a forbidden prototype key (read is skipped, not
+ * served from the prototype chain).
+ */
+declare function getPath(source: unknown, path: string): unknown;
+/**
+ * Write a nested value by dot-path, auto-vivifying intermediate objects.
+ * Forbidden prototype keys at any segment are skipped entirely, so a hostile
+ * `__proto__.isAdmin` path can never mutate `Object.prototype`.
+ */
+declare function setPath(target: Record<string, unknown>, path: string, value: unknown): void;
+
+export { type DefaultRule as D, type FnRule as F, type PairRule as P, type Rule as R, type FromResolver as a, isFnRule as b, isFromResolverRule as c, isPairRule as d, isStringRule as e, fromResolver as f, getPath as g, isDefaultRule as i, setPath as s, withDefault as w };

package/dist/rules-msHkZDR8.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Rule kinds for {@link createMap} and the dot-path get/set helpers they use.
+ *
+ * Rule kinds (by JS type):
+ * - `string`            — rename: copy `source[ruleValue]` to the dest key. Auto-reversible.
+ * - `(source) => value` — computed function, one-way (no reverse unless paired).
+ * - `{ to, from }`      — explicit both-directions, reversible.
+ * - `FromResolver`      — value pulled from a resolver graph (async path, Phase 5).
+ */
+/** A function rule: derive a dest value from the whole source object. */
+type FnRule<S, V> = (source: S) => V;
+/** A reversible rule with explicit forward (`to`) and inverse (`from`) maps. */
+interface PairRule<S, V> {
+    to: (source: S) => V;
+    from: (value: V) => unknown;
+}
+/** Marker for a dest field resolved from a resolver graph (consumed by Phase 5). */
+interface FromResolver {
+    readonly __kind: "fromResolver";
+    readonly field: string;
+}
+/**
+ * Default-value rule: read `source` (a source key, defaults to the dest key)
+ * and fall back to `value` when the source is `undefined`. Reverse-safe: the
+ * default is dropped on reverse and only the read key round-trips.
+ */
+interface DefaultRule<V = unknown> {
+    readonly __kind: "default";
+    readonly value: V;
+    readonly source?: string;
+}
+/** Any rule a dest key may be configured with. */
+type Rule<S = any, V = any> = string | FnRule<S, V> | PairRule<S, V> | FromResolver | DefaultRule<V>;
+/** Build a {@link FromResolver} marker for `field` in the resolver graph. */
+declare function fromResolver(field: string): FromResolver;
+/**
+ * Build a {@link DefaultRule}: use `source` (or the dest key) from the entity,
+ * falling back to `value` when absent.
+ */
+declare function withDefault<V>(value: V, source?: string): DefaultRule<V>;
+declare function isStringRule(rule: Rule): rule is string;
+declare function isFromResolverRule(rule: Rule): rule is FromResolver;
+declare function isPairRule(rule: Rule): rule is PairRule<any, any>;
+declare function isDefaultRule(rule: Rule): rule is DefaultRule;
+declare function isFnRule(rule: Rule): rule is FnRule<any, any>;
+/**
+ * Read a nested value by dot-path. Returns `undefined` if any segment is
+ * missing or if a segment is a forbidden prototype key (read is skipped, not
+ * served from the prototype chain).
+ */
+declare function getPath(source: unknown, path: string): unknown;
+/**
+ * Write a nested value by dot-path, auto-vivifying intermediate objects.
+ * Forbidden prototype keys at any segment are skipped entirely, so a hostile
+ * `__proto__.isAdmin` path can never mutate `Object.prototype`.
+ */
+declare function setPath(target: Record<string, unknown>, path: string, value: unknown): void;
+
+export { type DefaultRule as D, type FnRule as F, type PairRule as P, type Rule as R, type FromResolver as a, isFnRule as b, isFromResolverRule as c, isPairRule as d, isStringRule as e, fromResolver as f, getPath as g, isDefaultRule as i, setPath as s, withDefault as w };

package/dist/serialize/index.cjs

@@ -0,0 +1,258 @@
+'use strict';
+
+// src/serialize/json-types.ts
+var CodecError = class extends Error {
+  /** Path to the offending value, e.g. `user.createdAt`. */
+  path;
+  constructor(message, path = []) {
+    const where = path.length ? ` (at ${path.join(".")})` : "";
+    super(`${message}${where}`);
+    this.name = "CodecError";
+    this.path = path;
+  }
+};
+var AsyncSchemaError = class extends Error {
+  constructor() {
+    super(
+      "deserialize is sync-only; this schema has async refinements. Remove async .refine()/.superRefine() or validate separately with parseAsync."
+    );
+    this.name = "AsyncSchemaError";
+  }
+};
+var LIMITS = {
+  /** Max characters in a BigInt wire string (sign + digits). */
+  bigintStringLength: 4096,
+  /** Max entries when rebuilding a Map from a wire array. */
+  mapEntries: 1e5
+};
+function dateToIso(value, path) {
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    throw new CodecError("expected a valid Date", path);
+  }
+  return value.toISOString();
+}
+function isoToDate(value, path) {
+  if (typeof value !== "string") {
+    throw new CodecError("expected an ISO date string", path);
+  }
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new CodecError("invalid ISO date string", path);
+  }
+  return new Date(ms);
+}
+function bigintToString(value, path) {
+  if (typeof value !== "bigint") {
+    throw new CodecError("expected a bigint", path);
+  }
+  return value.toString();
+}
+function stringToBigint(value, path) {
+  if (typeof value !== "string") {
+    throw new CodecError("expected a bigint string", path);
+  }
+  if (value.length > LIMITS.bigintStringLength) {
+    throw new CodecError(
+      `bigint string exceeds ${LIMITS.bigintStringLength} chars`,
+      path
+    );
+  }
+  if (!/^-?\d+$/.test(value)) {
+    throw new CodecError("malformed bigint string", path);
+  }
+  return BigInt(value);
+}
+function mapToEntries(value, path) {
+  if (!(value instanceof Map)) {
+    throw new CodecError("expected a Map", path);
+  }
+  return Array.from(value.entries());
+}
+function entriesToArray(value, path) {
+  if (!Array.isArray(value)) {
+    throw new CodecError("expected a Map entries array", path);
+  }
+  if (value.length > LIMITS.mapEntries) {
+    throw new CodecError(`Map entries exceed ${LIMITS.mapEntries}`, path);
+  }
+  for (const entry of value) {
+    if (!Array.isArray(entry) || entry.length !== 2) {
+      throw new CodecError("malformed Map entry (expected [key, value])", path);
+    }
+  }
+  return value;
+}
+function setToArray(value, path) {
+  if (!(value instanceof Set)) {
+    throw new CodecError("expected a Set", path);
+  }
+  return Array.from(value.values());
+}
+function arrayToSetItems(value, path) {
+  if (!Array.isArray(value)) {
+    throw new CodecError("expected a Set values array", path);
+  }
+  if (value.length > LIMITS.mapEntries) {
+    throw new CodecError(`Set values exceed ${LIMITS.mapEntries}`, path);
+  }
+  return value;
+}
+
+// src/serialize/codec.ts
+function defOf(schema) {
+  return schema._zod.def;
+}
+function typeOf(schema) {
+  return defOf(schema).type;
+}
+function unwrap(schema) {
+  let current = schema;
+  for (; ; ) {
+    const def = defOf(current);
+    switch (def.type) {
+      case "optional":
+      case "nullable":
+      case "default":
+      case "nonoptional":
+      case "readonly":
+      case "catch":
+        current = def.innerType;
+        break;
+      case "pipe":
+        current = def.in;
+        break;
+      case "lazy":
+        current = def.getter();
+        break;
+      default:
+        return current;
+    }
+  }
+}
+function walk(schema, value, dir, path) {
+  if (value === null || value === void 0) return value;
+  const node = unwrap(schema);
+  const def = defOf(node);
+  switch (def.type) {
+    case "object": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        throw new CodecError("expected an object", path);
+      }
+      const shape = def.shape;
+      const src = value;
+      const out = {};
+      for (const key of Object.keys(shape)) {
+        if (Object.prototype.hasOwnProperty.call(src, key)) {
+          out[key] = walk(shape[key], src[key], dir, [...path, key]);
+        }
+      }
+      return out;
+    }
+    case "array": {
+      if (!Array.isArray(value)) throw new CodecError("expected an array", path);
+      const element = def.element;
+      return value.map((item, i) => walk(element, item, dir, [...path, i]));
+    }
+    case "map": {
+      const keyType = def.keyType;
+      const valueType = def.valueType;
+      if (dir === "serialize") {
+        const entries2 = mapToEntries(value, path);
+        return entries2.map(([k, v], i) => [
+          walk(keyType, k, dir, [...path, i, "key"]),
+          walk(valueType, v, dir, [...path, i, "value"])
+        ]);
+      }
+      const entries = entriesToArray(value, path);
+      const out = /* @__PURE__ */ new Map();
+      entries.forEach(([k, v], i) => {
+        out.set(
+          walk(keyType, k, dir, [...path, i, "key"]),
+          walk(valueType, v, dir, [...path, i, "value"])
+        );
+      });
+      return out;
+    }
+    case "set": {
+      const valueType = def.valueType;
+      if (dir === "serialize") {
+        const items2 = setToArray(value, path);
+        return items2.map((item, i) => walk(valueType, item, dir, [...path, i]));
+      }
+      const items = arrayToSetItems(value, path);
+      return new Set(items.map((item, i) => walk(valueType, item, dir, [...path, i])));
+    }
+    case "union": {
+      const options = def.options;
+      let lastError = new CodecError("no union member matched", path);
+      for (const option of options) {
+        try {
+          return walk(option, value, dir, path);
+        } catch (err) {
+          if (!(err instanceof CodecError)) throw err;
+          lastError = err;
+        }
+      }
+      throw lastError;
+    }
+    case "date":
+      return dir === "serialize" ? dateToIso(value, path) : isoToDate(value, path);
+    case "bigint":
+      return dir === "serialize" ? bigintToString(value, path) : stringToBigint(value, path);
+    // Scalars and explicit escape hatches pass through untouched.
+    case "string":
+    case "number":
+    case "boolean":
+    case "nan":
+    case "null":
+    case "undefined":
+    case "literal":
+    case "enum":
+    case "any":
+    case "unknown":
+    case "void":
+    case "custom":
+      return value;
+    default:
+      throw new CodecError(`unsupported schema node "${def.type}"`, path);
+  }
+}
+function serialize(value, schema) {
+  return walk(schema, value, "serialize", []);
+}
+function isZodAsyncError(err) {
+  const name = err?.constructor?.name;
+  return name === "$ZodAsyncError";
+}
+function deserialize(json, schema) {
+  const rebuilt = walk(schema, json, "deserialize", []);
+  try {
+    return schema.parse(rebuilt);
+  } catch (err) {
+    if (isZodAsyncError(err)) throw new AsyncSchemaError();
+    throw err;
+  }
+}
+async function deserializeAsync(json, schema) {
+  const rebuilt = walk(schema, json, "deserialize", []);
+  return await schema.parseAsync(rebuilt);
+}
+
+exports.AsyncSchemaError = AsyncSchemaError;
+exports.CodecError = CodecError;
+exports.LIMITS = LIMITS;
+exports.arrayToSetItems = arrayToSetItems;
+exports.bigintToString = bigintToString;
+exports.dateToIso = dateToIso;
+exports.deserialize = deserialize;
+exports.deserializeAsync = deserializeAsync;
+exports.entriesToArray = entriesToArray;
+exports.isoToDate = isoToDate;
+exports.mapToEntries = mapToEntries;
+exports.serialize = serialize;
+exports.setToArray = setToArray;
+exports.stringToBigint = stringToBigint;
+exports.typeOf = typeOf;
+exports.unwrap = unwrap;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/serialize/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/serialize/json-types.ts","../../src/serialize/codec.ts"],"names":["entries","items"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Leaf transforms between rich JS values and their JSON-safe wire forms.\n * Each inverse (wire -> JS) transform validates its input and throws a\n * {@link CodecError} on malformed data, so a hostile wire payload surfaces a\n * typed error instead of a raw `TypeError`/`SyntaxError` or an unbounded stall.\n */\n\n/** Thrown for malformed wire input or unsupported schema nodes during codec walk. */\nexport class CodecError extends Error {\n  /** Path to the offending value, e.g. `user.createdAt`. */\n  readonly path: ReadonlyArray<string | number>;\n  constructor(message: string, path: ReadonlyArray<string | number> = []) {\n    const where = path.length ? ` (at ${path.join(\".\")})` : \"\";\n    super(`${message}${where}`);\n    this.name = \"CodecError\";\n    this.path = path;\n  }\n}\n\n/** Thrown when `deserialize` is given a schema containing async refinements. */\nexport class AsyncSchemaError extends Error {\n  constructor() {\n    super(\n      \"deserialize is sync-only; this schema has async refinements. \" +\n        \"Remove async .refine()/.superRefine() or validate separately with parseAsync.\",\n    );\n    this.name = \"AsyncSchemaError\";\n  }\n}\n\n/**\n * DoS guards on attacker-controlled wire input. A BigInt parsed from a very\n * long numeric string, or a Map rebuilt from a huge entries array, can stall\n * the event loop; these caps reject such input up front.\n */\nexport const LIMITS = {\n  /** Max characters in a BigInt wire string (sign + digits). */\n  bigintStringLength: 4096,\n  /** Max entries when rebuilding a Map from a wire array. */\n  mapEntries: 100_000,\n} as const;\n\n// --- Date <-> ISO string ---\n\nexport function dateToIso(value: Date, path: ReadonlyArray<string | number>): string {\n  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {\n    throw new CodecError(\"expected a valid Date\", path);\n  }\n  return value.toISOString();\n}\n\nexport function isoToDate(value: unknown, path: ReadonlyArray<string | number>): Date {\n  if (typeof value !== \"string\") {\n    throw new CodecError(\"expected an ISO date string\", path);\n  }\n  const ms = Date.parse(value);\n  if (Number.isNaN(ms)) {\n    throw new CodecError(\"invalid ISO date string\", path);\n  }\n  return new Date(ms);\n}\n\n// --- BigInt <-> string ---\n\nexport function bigintToString(value: bigint, path: ReadonlyArray<string | number>): string {\n  if (typeof value !== \"bigint\") {\n    throw new CodecError(\"expected a bigint\", path);\n  }\n  return value.toString();\n}\n\nexport function stringToBigint(value: unknown, path: ReadonlyArray<string | number>): bigint {\n  if (typeof value !== \"string\") {\n    throw new CodecError(\"expected a bigint string\", path);\n  }\n  if (value.length > LIMITS.bigintStringLength) {\n    throw new CodecError(\n      `bigint string exceeds ${LIMITS.bigintStringLength} chars`,\n      path,\n    );\n  }\n  if (!/^-?\\d+$/.test(value)) {\n    throw new CodecError(\"malformed bigint string\", path);\n  }\n  return BigInt(value);\n}\n\n// --- Map <-> entries array ---\n\nexport function mapToEntries(\n  value: Map<unknown, unknown>,\n  path: ReadonlyArray<string | number>,\n): Array<[unknown, unknown]> {\n  if (!(value instanceof Map)) {\n    throw new CodecError(\"expected a Map\", path);\n  }\n  return Array.from(value.entries());\n}\n\nexport function entriesToArray(\n  value: unknown,\n  path: ReadonlyArray<string | number>,\n): Array<[unknown, unknown]> {\n  if (!Array.isArray(value)) {\n    throw new CodecError(\"expected a Map entries array\", path);\n  }\n  if (value.length > LIMITS.mapEntries) {\n    throw new CodecError(`Map entries exceed ${LIMITS.mapEntries}`, path);\n  }\n  for (const entry of value) {\n    if (!Array.isArray(entry) || entry.length !== 2) {\n      throw new CodecError(\"malformed Map entry (expected [key, value])\", path);\n    }\n  }\n  return value as Array<[unknown, unknown]>;\n}\n\n// --- Set <-> array ---\n\nexport function setToArray(\n  value: Set<unknown>,\n  path: ReadonlyArray<string | number>,\n): unknown[] {\n  if (!(value instanceof Set)) {\n    throw new CodecError(\"expected a Set\", path);\n  }\n  return Array.from(value.values());\n}\n\nexport function arrayToSetItems(\n  value: unknown,\n  path: ReadonlyArray<string | number>,\n): unknown[] {\n  if (!Array.isArray(value)) {\n    throw new CodecError(\"expected a Set values array\", path);\n  }\n  if (value.length > LIMITS.mapEntries) {\n    throw new CodecError(`Set values exceed ${LIMITS.mapEntries}`, path);\n  }\n  return value;\n}\n","/**\n * Schema-driven JSON-safe codec for Zod 4 schemas.\n *\n * `serialize` walks a value alongside its Zod schema and replaces rich runtime\n * types (Date, BigInt, Map) with JSON-safe representations; `deserialize` walks\n * the wire form back into rich values and then validates with Zod.\n *\n * Zod-4 only: all schema-shape reads go through {@link typeOf}/{@link unwrap},\n * which dispatch on the Zod 4 internal `_zod.def.type` (lowercase strings).\n * Zod 3's `_def.typeName` is intentionally unsupported.\n */\nimport type { z } from \"zod\";\nimport {\n  AsyncSchemaError,\n  CodecError,\n  bigintToString,\n  arrayToSetItems,\n  dateToIso,\n  entriesToArray,\n  isoToDate,\n  mapToEntries,\n  setToArray,\n  stringToBigint,\n} from \"./json-types.js\";\n\ntype AnyZod = z.ZodType;\ntype Path = ReadonlyArray<string | number>;\ntype Direction = \"serialize\" | \"deserialize\";\n\n// Minimal structural view of the Zod 4 internal def. Centralizes the one place\n// the library couples to `_zod.def`, so a Zod minor bump touches only this file.\ninterface ZodDef {\n  type: string;\n  innerType?: AnyZod;\n  element?: AnyZod;\n  shape?: Record<string, AnyZod>;\n  keyType?: AnyZod;\n  valueType?: AnyZod;\n  options?: AnyZod[];\n  getter?: () => AnyZod;\n  in?: AnyZod;\n}\n\nfunction defOf(schema: AnyZod): ZodDef {\n  return (schema as unknown as { _zod: { def: ZodDef } })._zod.def;\n}\n\n/** The Zod 4 node kind, e.g. `\"object\"`, `\"array\"`, `\"date\"`. */\nexport function typeOf(schema: AnyZod): string {\n  return defOf(schema).type;\n}\n\n/**\n * Peel wrapper nodes that do not change the JSON-safe shape:\n * optional/nullable/default (innerType), pipe/transform (the `in` schema is the\n * wire-facing shape), and lazy (resolve the getter). Object `.refine()` in Zod\n * 4 stays a plain `object` node with its `shape` intact, so it needs no peeling.\n */\nexport function unwrap(schema: AnyZod): AnyZod {\n  let current = schema;\n  // Bounded by schema nesting depth; each step strictly descends.\n  for (;;) {\n    const def = defOf(current);\n    switch (def.type) {\n      case \"optional\":\n      case \"nullable\":\n      case \"default\":\n      case \"nonoptional\":\n      case \"readonly\":\n      case \"catch\":\n        current = def.innerType as AnyZod;\n        break;\n      case \"pipe\":\n        // `.transform()` and `.pipe()` both produce a pipe; the `in` side is the\n        // shape that wire data is validated against.\n        current = def.in as AnyZod;\n        break;\n      case \"lazy\":\n        current = (def.getter as () => AnyZod)();\n        break;\n      default:\n        return current;\n    }\n  }\n}\n\nfunction walk(schema: AnyZod, value: unknown, dir: Direction, path: Path): unknown {\n  if (value === null || value === undefined) return value;\n\n  const node = unwrap(schema);\n  const def = defOf(node);\n\n  switch (def.type) {\n    case \"object\": {\n      if (typeof value !== \"object\" || Array.isArray(value)) {\n        throw new CodecError(\"expected an object\", path);\n      }\n      const shape = def.shape as Record<string, AnyZod>;\n      const src = value as Record<string, unknown>;\n      const out: Record<string, unknown> = {};\n      for (const key of Object.keys(shape)) {\n        if (Object.prototype.hasOwnProperty.call(src, key)) {\n          out[key] = walk(shape[key] as AnyZod, src[key], dir, [...path, key]);\n        }\n      }\n      return out;\n    }\n\n    case \"array\": {\n      if (!Array.isArray(value)) throw new CodecError(\"expected an array\", path);\n      const element = def.element as AnyZod;\n      return value.map((item, i) => walk(element, item, dir, [...path, i]));\n    }\n\n    case \"map\": {\n      const keyType = def.keyType as AnyZod;\n      const valueType = def.valueType as AnyZod;\n      if (dir === \"serialize\") {\n        const entries = mapToEntries(value as Map<unknown, unknown>, path);\n        return entries.map(([k, v], i) => [\n          walk(keyType, k, dir, [...path, i, \"key\"]),\n          walk(valueType, v, dir, [...path, i, \"value\"]),\n        ]);\n      }\n      const entries = entriesToArray(value, path);\n      const out = new Map<unknown, unknown>();\n      entries.forEach(([k, v], i) => {\n        out.set(\n          walk(keyType, k, dir, [...path, i, \"key\"]),\n          walk(valueType, v, dir, [...path, i, \"value\"]),\n        );\n      });\n      return out;\n    }\n\n    case \"set\": {\n      const valueType = def.valueType as AnyZod;\n      if (dir === \"serialize\") {\n        const items = setToArray(value as Set<unknown>, path);\n        return items.map((item, i) => walk(valueType, item, dir, [...path, i]));\n      }\n      const items = arrayToSetItems(value, path);\n      return new Set(items.map((item, i) => walk(valueType, item, dir, [...path, i])));\n    }\n\n    case \"union\": {\n      // Try each member; first that walks without a CodecError wins. Mirrors\n      // Zod's own \"first match\" union semantics for the JSON-safe shape. A\n      // non-CodecError (e.g. a throwing z.lazy getter) is a real fault and\n      // propagates immediately rather than being treated as a failed match.\n      const options = def.options as AnyZod[];\n      let lastError: CodecError = new CodecError(\"no union member matched\", path);\n      for (const option of options) {\n        try {\n          return walk(option, value, dir, path);\n        } catch (err) {\n          if (!(err instanceof CodecError)) throw err;\n          lastError = err;\n        }\n      }\n      throw lastError;\n    }\n\n    case \"date\":\n      return dir === \"serialize\"\n        ? dateToIso(value as Date, path)\n        : isoToDate(value, path);\n\n    case \"bigint\":\n      return dir === \"serialize\"\n        ? bigintToString(value as bigint, path)\n        : stringToBigint(value, path);\n\n    // Scalars and explicit escape hatches pass through untouched.\n    case \"string\":\n    case \"number\":\n    case \"boolean\":\n    case \"nan\":\n    case \"null\":\n    case \"undefined\":\n    case \"literal\":\n    case \"enum\":\n    case \"any\":\n    case \"unknown\":\n    case \"void\":\n    case \"custom\":\n      return value;\n\n    default:\n      // Fail closed: an unhandled object-like node would otherwise silently\n      // skip its inner schema. Use z.custom() for genuinely opaque values.\n      throw new CodecError(`unsupported schema node \"${def.type}\"`, path);\n  }\n}\n\n/**\n * Convert a rich value into a JSON-safe plain value per its Zod schema.\n * Date -> ISO string, BigInt -> string, Map -> `[key, value][]`, recursing\n * through objects, arrays, maps and unions. The result survives\n * `JSON.parse(JSON.stringify(...))` with no loss for supported types.\n */\nexport function serialize<S extends AnyZod>(value: z.infer<S>, schema: S): unknown {\n  return walk(schema, value, \"serialize\", []);\n}\n\nfunction isZodAsyncError(err: unknown): boolean {\n  const name = (err as { constructor?: { name?: string } } | null)?.constructor?.name;\n  return name === \"$ZodAsyncError\";\n}\n\n/**\n * Rebuild rich values from their JSON-safe wire form per `schema`, then\n * validate with Zod. Leaf transforms validate their input and surface a typed\n * {@link CodecError} on malformed data, so untrusted JSON never escapes as a\n * raw throw or an unbounded stall. Sync-only: an async-refined schema throws\n * {@link AsyncSchemaError}.\n */\nexport function deserialize<S extends AnyZod>(json: unknown, schema: S): z.infer<S> {\n  const rebuilt = walk(schema, json, \"deserialize\", []);\n  try {\n    return schema.parse(rebuilt) as z.infer<S>;\n  } catch (err) {\n    if (isZodAsyncError(err)) throw new AsyncSchemaError();\n    throw err;\n  }\n}\n\n/**\n * Async variant of {@link deserialize}: rebuilds rich values then validates with\n * `parseAsync`, so schemas containing async `.refine`/`.superRefine` are\n * supported (no {@link AsyncSchemaError}). The same leaf-transform safety and\n * DoS bounds apply during the rebuild.\n */\nexport async function deserializeAsync<S extends AnyZod>(\n  json: unknown,\n  schema: S,\n): Promise<z.infer<S>> {\n  const rebuilt = walk(schema, json, \"deserialize\", []);\n  return (await schema.parseAsync(rebuilt)) as z.infer<S>;\n}\n"]}

package/dist/serialize/index.d.cts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+
+/**
+ * Schema-driven JSON-safe codec for Zod 4 schemas.
+ *
+ * `serialize` walks a value alongside its Zod schema and replaces rich runtime
+ * types (Date, BigInt, Map) with JSON-safe representations; `deserialize` walks
+ * the wire form back into rich values and then validates with Zod.
+ *
+ * Zod-4 only: all schema-shape reads go through {@link typeOf}/{@link unwrap},
+ * which dispatch on the Zod 4 internal `_zod.def.type` (lowercase strings).
+ * Zod 3's `_def.typeName` is intentionally unsupported.
+ */
+
+type AnyZod = z.ZodType;
+/** The Zod 4 node kind, e.g. `"object"`, `"array"`, `"date"`. */
+declare function typeOf(schema: AnyZod): string;
+/**
+ * Peel wrapper nodes that do not change the JSON-safe shape:
+ * optional/nullable/default (innerType), pipe/transform (the `in` schema is the
+ * wire-facing shape), and lazy (resolve the getter). Object `.refine()` in Zod
+ * 4 stays a plain `object` node with its `shape` intact, so it needs no peeling.
+ */
+declare function unwrap(schema: AnyZod): AnyZod;
+/**
+ * Convert a rich value into a JSON-safe plain value per its Zod schema.
+ * Date -> ISO string, BigInt -> string, Map -> `[key, value][]`, recursing
+ * through objects, arrays, maps and unions. The result survives
+ * `JSON.parse(JSON.stringify(...))` with no loss for supported types.
+ */
+declare function serialize<S extends AnyZod>(value: z.infer<S>, schema: S): unknown;
+/**
+ * Rebuild rich values from their JSON-safe wire form per `schema`, then
+ * validate with Zod. Leaf transforms validate their input and surface a typed
+ * {@link CodecError} on malformed data, so untrusted JSON never escapes as a
+ * raw throw or an unbounded stall. Sync-only: an async-refined schema throws
+ * {@link AsyncSchemaError}.
+ */
+declare function deserialize<S extends AnyZod>(json: unknown, schema: S): z.infer<S>;
+/**
+ * Async variant of {@link deserialize}: rebuilds rich values then validates with
+ * `parseAsync`, so schemas containing async `.refine`/`.superRefine` are
+ * supported (no {@link AsyncSchemaError}). The same leaf-transform safety and
+ * DoS bounds apply during the rebuild.
+ */
+declare function deserializeAsync<S extends AnyZod>(json: unknown, schema: S): Promise<z.infer<S>>;
+
+/**
+ * Leaf transforms between rich JS values and their JSON-safe wire forms.
+ * Each inverse (wire -> JS) transform validates its input and throws a
+ * {@link CodecError} on malformed data, so a hostile wire payload surfaces a
+ * typed error instead of a raw `TypeError`/`SyntaxError` or an unbounded stall.
+ */
+/** Thrown for malformed wire input or unsupported schema nodes during codec walk. */
+declare class CodecError extends Error {
+    /** Path to the offending value, e.g. `user.createdAt`. */
+    readonly path: ReadonlyArray<string | number>;
+    constructor(message: string, path?: ReadonlyArray<string | number>);
+}
+/** Thrown when `deserialize` is given a schema containing async refinements. */
+declare class AsyncSchemaError extends Error {
+    constructor();
+}
+/**
+ * DoS guards on attacker-controlled wire input. A BigInt parsed from a very
+ * long numeric string, or a Map rebuilt from a huge entries array, can stall
+ * the event loop; these caps reject such input up front.
+ */
+declare const LIMITS: {
+    /** Max characters in a BigInt wire string (sign + digits). */
+    readonly bigintStringLength: 4096;
+    /** Max entries when rebuilding a Map from a wire array. */
+    readonly mapEntries: 100000;
+};
+declare function dateToIso(value: Date, path: ReadonlyArray<string | number>): string;
+declare function isoToDate(value: unknown, path: ReadonlyArray<string | number>): Date;
+declare function bigintToString(value: bigint, path: ReadonlyArray<string | number>): string;
+declare function stringToBigint(value: unknown, path: ReadonlyArray<string | number>): bigint;
+declare function mapToEntries(value: Map<unknown, unknown>, path: ReadonlyArray<string | number>): Array<[unknown, unknown]>;
+declare function entriesToArray(value: unknown, path: ReadonlyArray<string | number>): Array<[unknown, unknown]>;
+declare function setToArray(value: Set<unknown>, path: ReadonlyArray<string | number>): unknown[];
+declare function arrayToSetItems(value: unknown, path: ReadonlyArray<string | number>): unknown[];
+
+export { AsyncSchemaError, CodecError, LIMITS, arrayToSetItems, bigintToString, dateToIso, deserialize, deserializeAsync, entriesToArray, isoToDate, mapToEntries, serialize, setToArray, stringToBigint, typeOf, unwrap };

package/dist/serialize/index.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+
+/**
+ * Schema-driven JSON-safe codec for Zod 4 schemas.
+ *
+ * `serialize` walks a value alongside its Zod schema and replaces rich runtime
+ * types (Date, BigInt, Map) with JSON-safe representations; `deserialize` walks
+ * the wire form back into rich values and then validates with Zod.
+ *
+ * Zod-4 only: all schema-shape reads go through {@link typeOf}/{@link unwrap},
+ * which dispatch on the Zod 4 internal `_zod.def.type` (lowercase strings).
+ * Zod 3's `_def.typeName` is intentionally unsupported.
+ */
+
+type AnyZod = z.ZodType;
+/** The Zod 4 node kind, e.g. `"object"`, `"array"`, `"date"`. */
+declare function typeOf(schema: AnyZod): string;
+/**
+ * Peel wrapper nodes that do not change the JSON-safe shape:
+ * optional/nullable/default (innerType), pipe/transform (the `in` schema is the
+ * wire-facing shape), and lazy (resolve the getter). Object `.refine()` in Zod
+ * 4 stays a plain `object` node with its `shape` intact, so it needs no peeling.
+ */
+declare function unwrap(schema: AnyZod): AnyZod;
+/**
+ * Convert a rich value into a JSON-safe plain value per its Zod schema.
+ * Date -> ISO string, BigInt -> string, Map -> `[key, value][]`, recursing
+ * through objects, arrays, maps and unions. The result survives
+ * `JSON.parse(JSON.stringify(...))` with no loss for supported types.
+ */
+declare function serialize<S extends AnyZod>(value: z.infer<S>, schema: S): unknown;
+/**
+ * Rebuild rich values from their JSON-safe wire form per `schema`, then
+ * validate with Zod. Leaf transforms validate their input and surface a typed
+ * {@link CodecError} on malformed data, so untrusted JSON never escapes as a
+ * raw throw or an unbounded stall. Sync-only: an async-refined schema throws
+ * {@link AsyncSchemaError}.
+ */
+declare function deserialize<S extends AnyZod>(json: unknown, schema: S): z.infer<S>;
+/**
+ * Async variant of {@link deserialize}: rebuilds rich values then validates with
+ * `parseAsync`, so schemas containing async `.refine`/`.superRefine` are
+ * supported (no {@link AsyncSchemaError}). The same leaf-transform safety and
+ * DoS bounds apply during the rebuild.
+ */
+declare function deserializeAsync<S extends AnyZod>(json: unknown, schema: S): Promise<z.infer<S>>;
+
+/**
+ * Leaf transforms between rich JS values and their JSON-safe wire forms.
+ * Each inverse (wire -> JS) transform validates its input and throws a
+ * {@link CodecError} on malformed data, so a hostile wire payload surfaces a
+ * typed error instead of a raw `TypeError`/`SyntaxError` or an unbounded stall.
+ */
+/** Thrown for malformed wire input or unsupported schema nodes during codec walk. */
+declare class CodecError extends Error {
+    /** Path to the offending value, e.g. `user.createdAt`. */
+    readonly path: ReadonlyArray<string | number>;
+    constructor(message: string, path?: ReadonlyArray<string | number>);
+}
+/** Thrown when `deserialize` is given a schema containing async refinements. */
+declare class AsyncSchemaError extends Error {
+    constructor();
+}
+/**
+ * DoS guards on attacker-controlled wire input. A BigInt parsed from a very
+ * long numeric string, or a Map rebuilt from a huge entries array, can stall
+ * the event loop; these caps reject such input up front.
+ */
+declare const LIMITS: {
+    /** Max characters in a BigInt wire string (sign + digits). */
+    readonly bigintStringLength: 4096;
+    /** Max entries when rebuilding a Map from a wire array. */
+    readonly mapEntries: 100000;
+};
+declare function dateToIso(value: Date, path: ReadonlyArray<string | number>): string;
+declare function isoToDate(value: unknown, path: ReadonlyArray<string | number>): Date;
+declare function bigintToString(value: bigint, path: ReadonlyArray<string | number>): string;
+declare function stringToBigint(value: unknown, path: ReadonlyArray<string | number>): bigint;
+declare function mapToEntries(value: Map<unknown, unknown>, path: ReadonlyArray<string | number>): Array<[unknown, unknown]>;
+declare function entriesToArray(value: unknown, path: ReadonlyArray<string | number>): Array<[unknown, unknown]>;
+declare function setToArray(value: Set<unknown>, path: ReadonlyArray<string | number>): unknown[];
+declare function arrayToSetItems(value: unknown, path: ReadonlyArray<string | number>): unknown[];
+
+export { AsyncSchemaError, CodecError, LIMITS, arrayToSetItems, bigintToString, dateToIso, deserialize, deserializeAsync, entriesToArray, isoToDate, mapToEntries, serialize, setToArray, stringToBigint, typeOf, unwrap };

package/dist/serialize/index.js

@@ -0,0 +1,3 @@
+export { AsyncSchemaError, CodecError, LIMITS, arrayToSetItems, bigintToString, dateToIso, deserialize, deserializeAsync, entriesToArray, isoToDate, mapToEntries, serialize, setToArray, stringToBigint, typeOf, unwrap } from '../chunk-U3W6PGFE.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/serialize/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}