zodbridge 0.2.0

package/dist/async/index.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { R as Rule } from '../rules-msHkZDR8.js';
+import { R as ResolverContext } from '../context-B0f9mQWu.js';
+
+/**
+ * `forwardAsync` — the async mapping path. Consumes a resolver graph (Phase 4)
+ * for `fromResolver` fields, honors a dynamic `select` set so only requested
+ * fields (and their resolver deps) do I/O, and validates with Zod
+ * `safeParseAsync` (so async `.refine` runs).
+ *
+ * Zod 4 constraint: `.pick()`/`.partial()` THROW on object schemas containing
+ * refinements, which is exactly the async-refined shape this targets. So a
+ * partial `select` is validated against a sub-schema built from the RAW
+ * `.shape` (`z.object(pickedShape)`), never by calling `.pick()` on the refined
+ * wrapper. Field-level refines on selected fields still run; object-level
+ * cross-field refines run only on a full select (documented limitation).
+ */
+
+/** Thrown when `select` names a key absent from the dest schema. */
+declare class UnknownSelectKeyError extends Error {
+    readonly keys: string[];
+    constructor(keys: string[]);
+}
+type AnyZodObject = z.ZodObject<any>;
+interface ForwardAsyncMap<S extends AnyZodObject> {
+    readonly schema: S;
+    readonly rules: Record<string, Rule | undefined>;
+    readonly shape: Record<string, z.ZodType>;
+}
+interface ForwardAsyncOptions<Fields, TAdapter> {
+    resolver: ResolverContext<Fields, TAdapter>;
+    /** Only these dest keys are computed; unselected resolvers never fire. */
+    select?: string[];
+    /** Opaque extra passed to sync function rules via the source (unused hook). */
+    context?: unknown;
+}
+/**
+ * Validate and de-duplicate a `select` list against the dest shape.
+ * Unknown keys -> typed {@link UnknownSelectKeyError} (never a raw Zod trace).
+ */
+declare function normalizeSelect(select: string[] | undefined, shape: Record<string, z.ZodType>): string[] | undefined;
+/**
+ * Build a validated DTO asynchronously. `fromResolver` fields pull from the
+ * resolver; a resolver throw rejects the whole promise (fail-fast). Returns the
+ * full DTO, or a `Partial<Dto>` when `select` is given.
+ */
+declare function forwardAsync<S extends AnyZodObject, Fields, TAdapter>(map: ForwardAsyncMap<S>, source: Record<string, unknown>, options: ForwardAsyncOptions<Fields, TAdapter>): Promise<Partial<z.infer<S>>>;
+
+export { type ForwardAsyncOptions, UnknownSelectKeyError, forwardAsync, normalizeSelect };

package/dist/async/index.js

@@ -0,0 +1,65 @@
+import { applyForwardRule } from '../chunk-3HB2CM5G.js';
+import { isFromResolverRule, setPath } from '../chunk-7DUCUUPF.js';
+import { z } from 'zod';
+
+var UnknownSelectKeyError = class extends Error {
+  keys;
+  constructor(keys) {
+    super(
+      `forwardAsync select contains key(s) not in the dest schema: ${keys.join(", ")}`
+    );
+    this.name = "UnknownSelectKeyError";
+    this.keys = keys;
+  }
+};
+function normalizeSelect(select, shape) {
+  if (select === void 0) return void 0;
+  const deduped = Array.from(new Set(select));
+  const unknown = deduped.filter(
+    (k) => !Object.prototype.hasOwnProperty.call(shape, k)
+  );
+  if (unknown.length > 0) throw new UnknownSelectKeyError(unknown);
+  return deduped;
+}
+async function stripField(value, fieldSchema) {
+  const result = await fieldSchema.safeParseAsync(value);
+  if (!result.success) return value;
+  return result.data;
+}
+async function forwardAsync(map, source, options) {
+  const { resolver, select } = options;
+  const { schema, rules, shape } = map;
+  const selected = normalizeSelect(select, shape);
+  const targetKeys = selected ?? Object.keys(shape);
+  const assembled = {};
+  for (const key of targetKeys) {
+    const rule = rules[key];
+    if (isFromResolverRule(rule)) {
+      const field = rule.field;
+      const raw = await resolver.resolve(field);
+      if (raw !== void 0) {
+        const value2 = await stripField(raw, shape[key]);
+        setPath(assembled, key, value2);
+      }
+      continue;
+    }
+    const produced = applyForwardRule(rule, key, source);
+    const value = produced instanceof Promise ? await produced : produced;
+    if (value !== void 0) setPath(assembled, key, value);
+  }
+  const validator = selected === void 0 ? schema : buildSubSchema(shape, selected);
+  const result = await validator.safeParseAsync(assembled);
+  if (!result.success) throw result.error;
+  return result.data;
+}
+function buildSubSchema(shape, selected) {
+  const picked = {};
+  for (const key of selected) {
+    picked[key] = shape[key];
+  }
+  return z.object(picked);
+}
+
+export { UnknownSelectKeyError, forwardAsync, normalizeSelect };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/async/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/async/forwardAsync.ts"],"names":["value"],"mappings":";;;;AAwBO,IAAM,qBAAA,GAAN,cAAoC,KAAA,CAAM;AAAA,EACtC,IAAA;AAAA,EACT,YAAY,IAAA,EAAgB;AAC1B,IAAA,KAAA;AAAA,MACE,CAAA,4DAAA,EAA+D,IAAA,CAAK,IAAA,CAAK,IAAI,CAAC,CAAA;AAAA,KAChF;AACA,IAAA,IAAA,CAAK,IAAA,GAAO,uBAAA;AACZ,IAAA,IAAA,CAAK,IAAA,GAAO,IAAA;AAAA,EACd;AACF;AAsBO,SAAS,eAAA,CACd,QACA,KAAA,EACsB;AACtB,EAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,EAAA,MAAM,UAAU,KAAA,CAAM,IAAA,CAAK,IAAI,GAAA,CAAI,MAAM,CAAC,CAAA;AAC1C,EAAA,MAAM,UAAU,OAAA,CAAQ,MAAA;AAAA,IACtB,CAAC,MAAM,CAAC,MAAA,CAAO,UAAU,cAAA,CAAe,IAAA,CAAK,OAAO,CAAC;AAAA,GACvD;AACA,EAAA,IAAI,QAAQ,MAAA,GAAS,CAAA,EAAG,MAAM,IAAI,sBAAsB,OAAO,CAAA;AAC/D,EAAA,OAAO,OAAA;AACT;AAQA,eAAe,UAAA,CAAW,OAAgB,WAAA,EAA0C;AAClF,EAAA,MAAM,MAAA,GAAS,MAAM,WAAA,CAAY,cAAA,CAAe,KAAK,CAAA;AACrD,EAAA,IAAI,CAAC,MAAA,CAAO,OAAA,EAAS,OAAO,KAAA;AAC5B,EAAA,OAAO,MAAA,CAAO,IAAA;AAChB;AAOA,eAAsB,YAAA,CACpB,GAAA,EACA,MAAA,EACA,OAAA,EAC8B;AAC9B,EAAA,MAAM,EAAE,QAAA,EAAU,MAAA,EAAO,GAAI,OAAA;AAC7B,EAAA,MAAM,EAAE,MAAA,EAAQ,KAAA,EAAO,KAAA,EAAM,GAAI,GAAA;AAEjC,EAAA,MAAM,QAAA,GAAW,eAAA,CAAgB,MAAA,EAAQ,KAAK,CAAA;AAC9C,EAAA,MAAM,UAAA,GAAa,QAAA,IAAY,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA;AAKhD,EAAA,MAAM,YAAqC,EAAC;AAC5C,EAAA,KAAA,MAAW,OAAO,UAAA,EAAY;AAC5B,IAAA,MAAM,IAAA,GAAO,MAAM,GAAG,CAAA;AACtB,IAAA,IAAI,kBAAA,CAAmB,IAAY,CAAA,EAAG;AACpC,MAAA,MAAM,QAAS,IAAA,CAAsB,KAAA;AAErC,MAAA,MAAM,GAAA,GAAM,MAAM,QAAA,CAAS,OAAA,CAAQ,KAAqB,CAAA;AACxD,MAAA,IAAI,QAAQ,MAAA,EAAW;AAGrB,QAAA,MAAMA,SAAQ,MAAM,UAAA,CAAW,GAAA,EAAK,KAAA,CAAM,GAAG,CAAc,CAAA;AAC3D,QAAA,OAAA,CAAQ,SAAA,EAAW,KAAKA,MAAK,CAAA;AAAA,MAC/B;AACA,MAAA;AAAA,IACF;AAGA,IAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,IAAA,EAAM,GAAA,EAAK,MAAM,CAAA;AACnD,IAAA,MAAM,KAAA,GAAQ,QAAA,YAAoB,OAAA,GAAU,MAAM,QAAA,GAAW,QAAA;AAC7D,IAAA,IAAI,KAAA,KAAU,MAAA,EAAW,OAAA,CAAQ,SAAA,EAAW,KAAK,KAAK,CAAA;AAAA,EACxD;AAIA,EAAA,MAAM,YACJ,QAAA,KAAa,MAAA,GAAY,MAAA,GAAS,cAAA,CAAe,OAAO,QAAQ,CAAA;AAClE,EAAA,MAAM,MAAA,GAAS,MAAM,SAAA,CAAU,cAAA,CAAe,SAAS,CAAA;AACvD,EAAA,IAAI,CAAC,MAAA,CAAO,OAAA,EAAS,MAAM,MAAA,CAAO,KAAA;AAClC,EAAA,OAAO,MAAA,CAAO,IAAA;AAChB;AAQA,SAAS,cAAA,CACP,OACA,QAAA,EACW;AACX,EAAA,MAAM,SAAoC,EAAC;AAC3C,EAAA,KAAA,MAAW,OAAO,QAAA,EAAU;AAG1B,IAAA,MAAA,CAAO,GAAG,CAAA,GAAI,KAAA,CAAM,GAAG,CAAA;AAAA,EACzB;AACA,EAAA,OAAO,CAAA,CAAE,OAAO,MAAM,CAAA;AACxB","file":"index.js","sourcesContent":["/**\n * `forwardAsync` — the async mapping path. Consumes a resolver graph (Phase 4)\n * for `fromResolver` fields, honors a dynamic `select` set so only requested\n * fields (and their resolver deps) do I/O, and validates with Zod\n * `safeParseAsync` (so async `.refine` runs).\n *\n * Zod 4 constraint: `.pick()`/`.partial()` THROW on object schemas containing\n * refinements, which is exactly the async-refined shape this targets. So a\n * partial `select` is validated against a sub-schema built from the RAW\n * `.shape` (`z.object(pickedShape)`), never by calling `.pick()` on the refined\n * wrapper. Field-level refines on selected fields still run; object-level\n * cross-field refines run only on a full select (documented limitation).\n */\nimport { z } from \"zod\";\nimport { applyForwardRule } from \"../map/createMap.js\";\nimport {\n  type FromResolver,\n  type Rule,\n  isFromResolverRule,\n  setPath,\n} from \"../map/rules.js\";\nimport type { ResolverContext } from \"../resolver/context.js\";\n\n/** Thrown when `select` names a key absent from the dest schema. */\nexport class UnknownSelectKeyError extends Error {\n  readonly keys: string[];\n  constructor(keys: string[]) {\n    super(\n      `forwardAsync select contains key(s) not in the dest schema: ${keys.join(\", \")}`,\n    );\n    this.name = \"UnknownSelectKeyError\";\n    this.keys = keys;\n  }\n}\n\ntype AnyZodObject = z.ZodObject<any>;\n\ninterface ForwardAsyncMap<S extends AnyZodObject> {\n  readonly schema: S;\n  readonly rules: Record<string, Rule | undefined>;\n  readonly shape: Record<string, z.ZodType>;\n}\n\nexport interface ForwardAsyncOptions<Fields, TAdapter> {\n  resolver: ResolverContext<Fields, TAdapter>;\n  /** Only these dest keys are computed; unselected resolvers never fire. */\n  select?: string[];\n  /** Opaque extra passed to sync function rules via the source (unused hook). */\n  context?: unknown;\n}\n\n/**\n * Validate and de-duplicate a `select` list against the dest shape.\n * Unknown keys -> typed {@link UnknownSelectKeyError} (never a raw Zod trace).\n */\nexport function normalizeSelect(\n  select: string[] | undefined,\n  shape: Record<string, z.ZodType>,\n): string[] | undefined {\n  if (select === undefined) return undefined;\n  const deduped = Array.from(new Set(select));\n  const unknown = deduped.filter(\n    (k) => !Object.prototype.hasOwnProperty.call(shape, k),\n  );\n  if (unknown.length > 0) throw new UnknownSelectKeyError(unknown);\n  return deduped;\n}\n\n/**\n * Strip a resolver-produced value through its own dest field sub-schema so\n * unknown adapter-row keys (e.g. `passwordHash`) are dropped. NOTE: a field\n * typed `z.any()`/`.passthrough()`/`z.record()` disables this — those leak the\n * value verbatim by design (documented in the README security section).\n */\nasync function stripField(value: unknown, fieldSchema: z.ZodType): Promise<unknown> {\n  const result = await fieldSchema.safeParseAsync(value);\n  if (!result.success) return value; // let the full validation surface the error\n  return result.data;\n}\n\n/**\n * Build a validated DTO asynchronously. `fromResolver` fields pull from the\n * resolver; a resolver throw rejects the whole promise (fail-fast). Returns the\n * full DTO, or a `Partial<Dto>` when `select` is given.\n */\nexport async function forwardAsync<S extends AnyZodObject, Fields, TAdapter>(\n  map: ForwardAsyncMap<S>,\n  source: Record<string, unknown>,\n  options: ForwardAsyncOptions<Fields, TAdapter>,\n): Promise<Partial<z.infer<S>>> {\n  const { resolver, select } = options;\n  const { schema, rules, shape } = map;\n\n  const selected = normalizeSelect(select, shape);\n  const targetKeys = selected ?? Object.keys(shape);\n\n  // Fields resolve sequentially (await per key). The resolver's promise-cache\n  // (Phase 4) makes Promise.all safe too, but sequential keeps resolver\n  // invocations non-overlapping and is the documented default.\n  const assembled: Record<string, unknown> = {};\n  for (const key of targetKeys) {\n    const rule = rules[key];\n    if (isFromResolverRule(rule as Rule)) {\n      const field = (rule as FromResolver).field;\n      // A resolver throw propagates out of forwardAsync (fail-fast).\n      const raw = await resolver.resolve(field as keyof Fields);\n      if (raw !== undefined) {\n        // `key` is always a key of `shape` (it came from shape keys or a\n        // select list validated against shape), so its field schema exists.\n        const value = await stripField(raw, shape[key] as z.ZodType);\n        setPath(assembled, key, value);\n      }\n      continue;\n    }\n    // Sync/computed rules reuse the Phase 3 primitive; an async function rule\n    // returns a promise, which we await.\n    const produced = applyForwardRule(rule, key, source);\n    const value = produced instanceof Promise ? await produced : produced;\n    if (value !== undefined) setPath(assembled, key, value);\n  }\n\n  // Validate. Full select -> the original schema (all refines run). Partial\n  // select -> a sub-schema built from raw .shape (avoids .pick on refined).\n  const validator =\n    selected === undefined ? schema : buildSubSchema(shape, selected);\n  const result = await validator.safeParseAsync(assembled);\n  if (!result.success) throw result.error;\n  return result.data as Partial<z.infer<S>>;\n}\n\n/**\n * Construct a partial-select validator from the dest schema's raw `.shape`,\n * via `z.object(pickedShape)`. Refined wrappers are never `.pick()`-ed (which\n * throws in Zod 4); object-level cross-field refines are intentionally omitted\n * here and run only on a full select.\n */\nfunction buildSubSchema(\n  shape: Record<string, z.ZodType>,\n  selected: string[],\n): z.ZodType {\n  const picked: Record<string, z.ZodType> = {};\n  for (const key of selected) {\n    // `selected` was validated against `shape` by normalizeSelect, so each\n    // key is present.\n    picked[key] = shape[key] as z.ZodType;\n  }\n  return z.object(picked);\n}\n"]}

package/dist/chunk-3HB2CM5G.js

@@ -0,0 +1,213 @@
+import { getPath, isStringRule, isPairRule, isDefaultRule, isFnRule, isFromResolverRule, setPath, createResolver } from './chunk-7DUCUUPF.js';
+
+// src/map/case-convert.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function splitWords(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Za-z])(\d)/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter((w) => w.length > 0).map((w) => w.toLowerCase());
+}
+function toSnakeKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.join("_");
+}
+function toCamelKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function convert(value, keyFn) {
+  if (Array.isArray(value)) {
+    return value.map((item) => convert(item, keyFn));
+  }
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const key of Object.keys(value)) {
+      const converted = keyFn(key);
+      if (FORBIDDEN_KEYS.has(converted)) continue;
+      out[converted] = convert(value[key], keyFn);
+    }
+    return out;
+  }
+  return value;
+}
+function toSnakeCase(value) {
+  return convert(value, toSnakeKey);
+}
+function toCamelCase(value) {
+  return convert(value, toCamelKey);
+}
+var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+function toKebabKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.join("-");
+}
+function toPascalKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.map(capitalize).join("");
+}
+function toConstantKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.join("_").toUpperCase();
+}
+function toKebabCase(value) {
+  return convert(value, toKebabKey);
+}
+function toPascalCase(value) {
+  return convert(value, toPascalKey);
+}
+function toConstantCase(value) {
+  return convert(value, toConstantKey);
+}
+
+// src/map/map-ops.ts
+function forwardMany(map, sources) {
+  return sources.map((s) => map.forward(s));
+}
+function reverseMany(map, dtos) {
+  return dtos.map((d) => map.reverse(d));
+}
+function safeForward(map, source) {
+  try {
+    return { success: true, data: map.forward(source) };
+  } catch (err) {
+    if (isZodError(err)) return { success: false, error: err };
+    throw err;
+  }
+}
+function isZodError(err) {
+  return typeof err === "object" && err !== null && err.name === "ZodError" && Array.isArray(err.issues);
+}
+
+// src/map/createMap.ts
+var OneWayRuleError = class extends Error {
+  key;
+  constructor(key) {
+    super(
+      `Cannot reverse dest key "${key}": it is mapped by a one-way function rule. Use a { to, from } pair rule to make it reversible.`
+    );
+    this.name = "OneWayRuleError";
+    this.key = key;
+  }
+};
+var MapHasNoResolversError = class extends Error {
+  constructor() {
+    super(
+      "createMap.toResolver requires a resolver graph: pass `createMap(schema, rules, { resolvers })`."
+    );
+    this.name = "MapHasNoResolversError";
+  }
+};
+var ReverseKeyCollisionError = class extends Error {
+  constructor(sourceKey, a, b) {
+    super(
+      `Reverse-key collision: dest keys "${a}" and "${b}" both map back to source key "${sourceKey}". Disambiguate one of them.`
+    );
+    this.name = "ReverseKeyCollisionError";
+  }
+};
+function applyForwardRule(rule, destKey, source) {
+  if (rule === void 0) {
+    return getPath(source, destKey);
+  }
+  if (isStringRule(rule)) {
+    return getPath(source, rule);
+  }
+  if (isPairRule(rule)) {
+    return rule.to(source);
+  }
+  if (isDefaultRule(rule)) {
+    const read = getPath(source, rule.source ?? destKey);
+    return read === void 0 ? rule.value : read;
+  }
+  if (isFnRule(rule)) {
+    return rule(source);
+  }
+  return void 0;
+}
+function createMap(schema, rules = {}, options = {}) {
+  const shape = schema.shape;
+  const destKeys = Object.keys(shape);
+  const mapResolvers = options.resolvers;
+  const reverseTargets = /* @__PURE__ */ new Map();
+  for (const destKey of Object.keys(rules)) {
+    const rule = rules[destKey];
+    if (rule !== void 0 && isStringRule(rule)) {
+      const existing = reverseTargets.get(rule);
+      if (existing) throw new ReverseKeyCollisionError(rule, existing, destKey);
+      reverseTargets.set(rule, destKey);
+    }
+  }
+  function forward(source) {
+    const out = {};
+    for (const destKey of destKeys) {
+      const rule = rules[destKey];
+      if (isFromResolverRule(rule)) continue;
+      const value = applyForwardRule(rule, destKey, source);
+      if (value !== void 0) setPath(out, destKey, value);
+    }
+    return schema.parse(out);
+  }
+  function reverse(dto) {
+    const out = {};
+    const dtoObj = dto;
+    for (const destKey of Object.keys(rules)) {
+      const rule = rules[destKey];
+      if (rule === void 0) continue;
+      const destValue = getPath(dtoObj, destKey);
+      if (isStringRule(rule)) {
+        setPath(out, rule, destValue);
+      } else if (isPairRule(rule)) {
+        setPath(out, destKey, rule.from(destValue));
+      } else if (isDefaultRule(rule)) {
+        setPath(out, rule.source ?? destKey, destValue);
+      } else if (isFromResolverRule(rule)) {
+        continue;
+      } else {
+        throw new OneWayRuleError(destKey);
+      }
+    }
+    return out;
+  }
+  function toResolver(adapter, seed) {
+    if (!mapResolvers) {
+      throw new MapHasNoResolversError();
+    }
+    const schemas = {};
+    for (const key of Object.keys(shape)) {
+      schemas[key] = shape[key];
+    }
+    return createResolver({
+      adapter,
+      seed,
+      resolvers: mapResolvers,
+      schemas
+    });
+  }
+  const mapper = {
+    forward,
+    reverse,
+    forwardMany: (sources) => forwardMany(mapper, sources),
+    reverseMany: (dtos) => reverseMany(mapper, dtos),
+    safeForward: (source) => safeForward(mapper, source),
+    toSnakeCase,
+    toCamelCase,
+    toResolver,
+    schema,
+    rules: Object.freeze({ ...rules }),
+    shape,
+    resolvers: mapResolvers
+  };
+  return mapper;
+}
+
+export { MapHasNoResolversError, OneWayRuleError, ReverseKeyCollisionError, applyForwardRule, createMap, forwardMany, reverseMany, safeForward, splitWords, toCamelCase, toCamelKey, toConstantCase, toConstantKey, toKebabCase, toKebabKey, toPascalCase, toPascalKey, toSnakeCase, toSnakeKey };
+//# sourceMappingURL=chunk-3HB2CM5G.js.map
+//# sourceMappingURL=chunk-3HB2CM5G.js.map

package/dist/chunk-3HB2CM5G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/map/case-convert.ts","../src/map/map-ops.ts","../src/map/createMap.ts"],"names":[],"mappings":"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","file":"chunk-3HB2CM5G.js","sourcesContent":["/**\n * Recursive object-key case conversion. `toSnakeCase`/`toCamelCase` re-case ALL\n * property keys of a value to the target case regardless of the input keys'\n * original casing (snake, camel, Pascal, kebab, SCREAMING_SNAKE all normalize).\n *\n * Only KEYS change. Values pass through untouched; recursion descends plain\n * objects and arrays only — Dates, Maps, Sets, class instances, and primitives\n * are returned as-is so their internal data is never reshaped.\n */\n\n/** Keys that would poison `Object.prototype` — never emitted as output keys. */\nconst FORBIDDEN_KEYS = new Set([\"__proto__\", \"prototype\", \"constructor\"]);\n\n/**\n * Split an identifier into lowercase word tokens, the casing-neutral form every\n * target case is rebuilt from. Handles delimiters (`_`, `-`, space), camel/Pascal\n * humps, acronym runs (`HTTPServer` -> `http`,`server`), and digit groups.\n */\nexport function splitWords(key: string): string[] {\n  return (\n    key\n      // acronym followed by a word: \"HTTPServer\" -> \"HTTP Server\"\n      .replace(/([A-Z]+)([A-Z][a-z])/g, \"$1 $2\")\n      // lower/digit followed by upper: \"fooBar\"/\"foo2Bar\" -> \"foo Bar\"\n      .replace(/([a-z\\d])([A-Z])/g, \"$1 $2\")\n      // letter followed by digit group: \"v2\" -> \"v 2\"\n      .replace(/([A-Za-z])(\\d)/g, \"$1 $2\")\n      // any non-alphanumeric run is a delimiter\n      .split(/[^A-Za-z0-9]+/)\n      .filter((w) => w.length > 0)\n      .map((w) => w.toLowerCase())\n  );\n}\n\n/** Convert a single key to `snake_case`; leave unconvertible keys untouched. */\nexport function toSnakeKey(key: string): string {\n  const words = splitWords(key);\n  // Nothing tokenizable (e.g. \"$$$\", \"_\") -> leave the key as-is rather than\n  // collapsing it to \"\" and losing the property.\n  if (words.length === 0) return key;\n  return words.join(\"_\");\n}\n\n/** Convert a single key to `camelCase`; leave unconvertible keys untouched. */\nexport function toCamelKey(key: string): string {\n  const words = splitWords(key);\n  if (words.length === 0) return key;\n  return words\n    .map((word, i) => (i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))\n    .join(\"\");\n}\n\n/** True only for plain objects (own data records), not Date/Map/Set/class instances. */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\nfunction convert(value: unknown, keyFn: (key: string) => string): unknown {\n  if (Array.isArray(value)) {\n    return value.map((item) => convert(item, keyFn));\n  }\n  if (isPlainObject(value)) {\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(value)) {\n      const converted = keyFn(key);\n      if (FORBIDDEN_KEYS.has(converted)) continue;\n      out[converted] = convert(value[key], keyFn);\n    }\n    return out;\n  }\n  // Primitives, Date, Map, Set, class instances: returned unchanged.\n  return value;\n}\n\n// --- type-level key re-casing ---\n//\n// These mapped types model the COMMON case — camelCase/PascalCase <-> snake_case\n// on plain identifier keys (`firstName` <-> `first_name`). They intentionally do\n// NOT replicate the full runtime tokenizer: acronym grouping (`HTTPServer`),\n// digit boundaries, kebab/space delimiters, and multiple leading underscores\n// (`__id`) can yield a type that differs from the runtime key. For normal DTO\n// keys the type is exact; for these exotic cases the runtime is authoritative.\n// Values are preserved (only keys change), and Date/Map/Set/array/primitive are\n// passed through untouched.\n\n/** Insert `_` before each interior uppercase letter, then lowercase. */\ntype CamelToSnake<S extends string> = S extends `${infer Head}${infer Tail}`\n  ? Head extends Uppercase<Head>\n    ? Head extends Lowercase<Head>\n      ? `${Head}${CamelToSnake<Tail>}` // digit/symbol: no separator\n      : `_${Lowercase<Head>}${CamelToSnake<Tail>}`\n    : `${Head}${CamelToSnake<Tail>}`\n  : S;\n\n/** Drop a single leading `_` produced when the first letter was uppercase. */\ntype StripLeadingUnderscore<S extends string> = S extends `_${infer Rest}` ? Rest : S;\n\ntype SnakeKey<S extends string> = StripLeadingUnderscore<CamelToSnake<S>>;\n\n/** Collapse `_x` groups into `X` (snake/kebab -> camelCase). */\ntype SnakeToCamel<S extends string> = S extends `${infer Head}_${infer Tail}`\n  ? `${Head}${Capitalize<SnakeToCamel<Tail>>}`\n  : S extends `${infer Head}-${infer Tail}`\n    ? `${Head}${Capitalize<SnakeToCamel<Tail>>}`\n    : S;\n\n/** Public type of {@link toSnakeCase}: keys recursively snake_cased. */\nexport type SnakeCased<T> = T extends Array<infer E>\n  ? Array<SnakeCased<E>>\n  : T extends Date | Map<unknown, unknown> | Set<unknown>\n    ? T\n    : T extends object\n      ? { [K in keyof T as K extends string ? SnakeKey<K> : K]: SnakeCased<T[K]> }\n      : T;\n\n/** Public type of {@link toCamelCase}: keys recursively camelCased. */\nexport type CamelCased<T> = T extends Array<infer E>\n  ? Array<CamelCased<E>>\n  : T extends Date | Map<unknown, unknown> | Set<unknown>\n    ? T\n    : T extends object\n      ? { [K in keyof T as K extends string ? SnakeToCamel<K> : K]: CamelCased<T[K]> }\n      : T;\n\n/**\n * Recursively re-case all property keys of `value` to `snake_case`. The return\n * type maps keys for the common identifier case (see {@link SnakeCased}).\n */\nexport function toSnakeCase<T>(value: T): SnakeCased<T> {\n  return convert(value, toSnakeKey) as SnakeCased<T>;\n}\n\n/**\n * Recursively re-case all property keys of `value` to `camelCase`. The return\n * type maps keys for the common identifier case (see {@link CamelCased}).\n */\nexport function toCamelCase<T>(value: T): CamelCased<T> {\n  return convert(value, toCamelKey) as CamelCased<T>;\n}\n\nconst capitalize = (word: string): string =>\n  word.charAt(0).toUpperCase() + word.slice(1);\n\n/** Convert a single key to `kebab-case`; leave unconvertible keys untouched. */\nexport function toKebabKey(key: string): string {\n  const words = splitWords(key);\n  if (words.length === 0) return key;\n  return words.join(\"-\");\n}\n\n/** Convert a single key to `PascalCase`; leave unconvertible keys untouched. */\nexport function toPascalKey(key: string): string {\n  const words = splitWords(key);\n  if (words.length === 0) return key;\n  return words.map(capitalize).join(\"\");\n}\n\n/** Convert a single key to `CONSTANT_CASE`; leave unconvertible keys untouched. */\nexport function toConstantKey(key: string): string {\n  const words = splitWords(key);\n  if (words.length === 0) return key;\n  return words.join(\"_\").toUpperCase();\n}\n\n/** Recursively re-case all property keys of `value` to `kebab-case`. */\nexport function toKebabCase<T = unknown>(value: T): T {\n  return convert(value, toKebabKey) as T;\n}\n\n/** Recursively re-case all property keys of `value` to `PascalCase`. */\nexport function toPascalCase<T = unknown>(value: T): T {\n  return convert(value, toPascalKey) as T;\n}\n\n/** Recursively re-case all property keys of `value` to `CONSTANT_CASE`. */\nexport function toConstantCase<T = unknown>(value: T): T {\n  return convert(value, toConstantKey) as T;\n}\n","/**\n * Composable operations over a {@link TypeMapper}: batch mapping, safe (non-throwing)\n * forward, sub-DTO views (pick/omit), and map composition. Kept out of\n * `createMap.ts` to respect the per-file size budget; `createMap` attaches thin\n * instance wrappers so these are available as both methods and free functions.\n */\nimport type { z } from \"zod\";\n\n/** Minimal mapper shape these ops need (avoids importing the full createMap type cycle). */\nexport interface MappableForward {\n  forward(source: Record<string, unknown>): unknown;\n  reverse(dto: unknown): Partial<Record<string, unknown>>;\n  readonly schema: z.ZodObject<any>;\n}\n\n/** Result of {@link safeForward}: a discriminated success/failure union. */\nexport type SafeResult<T> =\n  | { success: true; data: T }\n  | { success: false; error: z.ZodError };\n\n/** Forward every item in `sources`, returning the validated DTO array. */\nexport function forwardMany<M extends MappableForward>(\n  map: M,\n  sources: Array<Record<string, unknown>>,\n): Array<ReturnType<M[\"forward\"]>> {\n  return sources.map((s) => map.forward(s)) as Array<ReturnType<M[\"forward\"]>>;\n}\n\n/** Reverse every DTO in `dtos`, returning the mapped-source array. */\nexport function reverseMany<M extends MappableForward>(\n  map: M,\n  dtos: unknown[],\n): Array<Partial<Record<string, unknown>>> {\n  return dtos.map((d) => map.reverse(d));\n}\n\n/**\n * Forward without throwing: returns `{ success: true, data }` or, on a Zod\n * validation failure, `{ success: false, error }`. Non-Zod errors still throw.\n */\nexport function safeForward<M extends MappableForward>(\n  map: M,\n  source: Record<string, unknown>,\n): SafeResult<ReturnType<M[\"forward\"]>> {\n  try {\n    return { success: true, data: map.forward(source) as ReturnType<M[\"forward\"]> };\n  } catch (err) {\n    if (isZodError(err)) return { success: false, error: err };\n    throw err;\n  }\n}\n\nfunction isZodError(err: unknown): err is z.ZodError {\n  return (\n    typeof err === \"object\" &&\n    err !== null &&\n    (err as { name?: string }).name === \"ZodError\" &&\n    Array.isArray((err as { issues?: unknown }).issues)\n  );\n}\n","/**\n * `createMap(destSchema, rules)` — synchronous, Zod-validated entity -> DTO\n * mapper. The dest Zod schema is the shape source of truth. Simple string\n * renames and `{ to, from }` pairs auto-reverse; computed function rules are\n * one-way unless paired.\n */\nimport type { z } from \"zod\";\nimport { createResolver } from \"../resolver/createResolver.js\";\nimport type { ResolverContext, ResolverRegistry } from \"../resolver/context.js\";\nimport {\n  type CamelCased,\n  type SnakeCased,\n  toCamelCase,\n  toSnakeCase,\n} from \"./case-convert.js\";\nimport {\n  type SafeResult,\n  forwardMany as forwardManyOp,\n  reverseMany as reverseManyOp,\n  safeForward as safeForwardOp,\n} from \"./map-ops.js\";\nimport {\n  type DefaultRule,\n  type FromResolver,\n  type Rule,\n  getPath,\n  isDefaultRule,\n  isFnRule,\n  isFromResolverRule,\n  isPairRule,\n  isStringRule,\n  setPath,\n} from \"./rules.js\";\n\n/**\n * Resolver graph declared on a map: each field of the dest DTO `Dest` may have\n * a resolver typed against `Dest` and the adapter `TAdapter`.\n */\nexport type MapResolvers<Dest = Record<string, unknown>, TAdapter = unknown> =\n  ResolverRegistry<Dest, TAdapter>;\n\n/** Options for {@link createMap}, parameterized by the dest DTO and adapter type. */\nexport interface CreateMapOptions<Dest = Record<string, unknown>, TAdapter = unknown> {\n  /**\n   * Resolver graph for this map's fields, against the map's own dest schema.\n   * Enables `map.toResolver(adapter)` and resolver-backed `forwardAsync` without\n   * a separate `createResolver` call. Each resolver's output is typed against the\n   * DTO field it produces. NOTE: `ctx.adapter` is typed as the concrete adapter\n   * only at the `toResolver(adapter)` call site — inside these declarations it is\n   * `unknown` (the adapter is not known at `createMap` time); cast it if needed.\n   */\n  resolvers?: MapResolvers<Dest, TAdapter>;\n}\n\n/** Thrown when `reverse` meets a one-way function rule that has no inverse. */\nexport class OneWayRuleError extends Error {\n  readonly key: string;\n  constructor(key: string) {\n    super(\n      `Cannot reverse dest key \"${key}\": it is mapped by a one-way function ` +\n        `rule. Use a { to, from } pair rule to make it reversible.`,\n    );\n    this.name = \"OneWayRuleError\";\n    this.key = key;\n  }\n}\n\n/** Thrown when `toResolver` is called on a map that declared no resolvers. */\nexport class MapHasNoResolversError extends Error {\n  constructor() {\n    super(\n      \"createMap.toResolver requires a resolver graph: pass \" +\n        \"`createMap(schema, rules, { resolvers })`.\",\n    );\n    this.name = \"MapHasNoResolversError\";\n  }\n}\n\n/** Thrown at build time when two rules reverse onto the same source key. */\nexport class ReverseKeyCollisionError extends Error {\n  constructor(sourceKey: string, a: string, b: string) {\n    super(\n      `Reverse-key collision: dest keys \"${a}\" and \"${b}\" both map back to ` +\n        `source key \"${sourceKey}\". Disambiguate one of them.`,\n    );\n    this.name = \"ReverseKeyCollisionError\";\n  }\n}\n\ntype AnyZodObject = z.ZodObject<any>;\n\n/** Rule map: each dest key may carry a rule; unmapped keys are copied by name. */\nexport type RuleMap<Dest> = Partial<Record<keyof Dest & string, Rule>>;\n\nexport interface TypeMapper<S extends AnyZodObject, R extends RuleMap<z.infer<S>>> {\n  /** Build a validated DTO from a source entity (sync path). */\n  forward(source: Record<string, unknown>): z.infer<S>;\n  /** Forward every item in a list, returning the validated DTO array. */\n  forwardMany(sources: Array<Record<string, unknown>>): Array<z.infer<S>>;\n  /** Forward without throwing: `{ success, data }` or `{ success: false, error }`. */\n  safeForward(source: Record<string, unknown>): SafeResult<z.infer<S>>;\n  /** Invert reversible rules; returns only mapped source fields. */\n  reverse(dto: z.infer<S>): Partial<Record<string, unknown>>;\n  /** Reverse every DTO in a list. */\n  reverseMany(dtos: Array<z.infer<S>>): Array<Partial<Record<string, unknown>>>;\n  /**\n   * Recursively re-case ALL property keys of `value` to `snake_case`,\n   * regardless of their original casing. Keys only; values pass through.\n   */\n  toSnakeCase<T>(value: T): SnakeCased<T>;\n  /**\n   * Recursively re-case ALL property keys of `value` to `camelCase`,\n   * regardless of their original casing. Keys only; values pass through.\n   */\n  toCamelCase<T>(value: T): CamelCased<T>;\n  /**\n   * Build a resolver graph from THIS map's schema fields plus the resolver\n   * graph declared in `createMap`'s options. The resolver validates each field's\n   * output against the matching dest sub-schema (over-exposure protection).\n   * Throws if no `resolvers` were declared on the map.\n   */\n  toResolver<TAdapter>(\n    adapter: TAdapter,\n    seed?: Partial<z.infer<S>>,\n  ): ResolverContext<z.infer<S>, TAdapter>;\n  /** The dest schema (shape source of truth). */\n  readonly schema: S;\n  /** Configured rules, frozen. */\n  readonly rules: R;\n  /** Raw `.shape` of the dest object — used by the async path (Phase 5). */\n  readonly shape: Record<string, z.ZodType>;\n  /** Resolver graph declared on this map (if any), for `toResolver`/forwardAsync. */\n  readonly resolvers?: MapResolvers<z.infer<S>>;\n}\n\n/** Apply a single forward rule for `destKey`, returning the mapped value. */\nexport function applyForwardRule(\n  rule: Rule | undefined,\n  destKey: string,\n  source: Record<string, unknown>,\n): unknown {\n  if (rule === undefined) {\n    // No rule: copy by matching dest key from source (dot-path aware).\n    return getPath(source, destKey);\n  }\n  if (isStringRule(rule)) {\n    return getPath(source, rule);\n  }\n  if (isPairRule(rule)) {\n    return rule.to(source);\n  }\n  if (isDefaultRule(rule)) {\n    const read = getPath(source, rule.source ?? destKey);\n    return read === undefined ? rule.value : read;\n  }\n  if (isFnRule(rule)) {\n    return rule(source);\n  }\n  // FromResolver markers are resolved only on the async path; sync forward\n  // treats them as absent (the field is filled by forwardAsync).\n  return undefined;\n}\n\n/**\n * Build a two-way mapper. The `const` type parameter on `R` preserves bare\n * object-literal rule values (string-literal renames) without the caller\n * writing `as const` (requires TypeScript >= 5.0).\n */\nexport function createMap<\n  S extends AnyZodObject,\n  const R extends RuleMap<z.infer<S>>,\n>(\n  schema: S,\n  rules: R = {} as R,\n  options: CreateMapOptions<z.infer<S>> = {},\n): TypeMapper<S, R> {\n  const shape = schema.shape as Record<string, z.ZodType>;\n  const destKeys = Object.keys(shape);\n  const mapResolvers = options.resolvers;\n\n  // Build-time reverse-collision detection: any two reversible rules whose\n  // inverse targets the same source key are a configuration error.\n  const reverseTargets = new Map<string, string>();\n  for (const destKey of Object.keys(rules) as Array<keyof R & string>) {\n    const rule = rules[destKey] as Rule | undefined;\n    if (rule !== undefined && isStringRule(rule)) {\n      const existing = reverseTargets.get(rule);\n      if (existing) throw new ReverseKeyCollisionError(rule, existing, destKey);\n      reverseTargets.set(rule, destKey);\n    }\n  }\n\n  function forward(source: Record<string, unknown>): z.infer<S> {\n    const out: Record<string, unknown> = {};\n    for (const destKey of destKeys) {\n      const rule = rules[destKey as keyof R & string] as Rule | undefined;\n      if (isFromResolverRule(rule as Rule)) continue; // async-only\n      const value = applyForwardRule(rule, destKey, source);\n      if (value !== undefined) setPath(out, destKey, value);\n    }\n    return schema.parse(out) as z.infer<S>;\n  }\n\n  function reverse(dto: z.infer<S>): Partial<Record<string, unknown>> {\n    const out: Record<string, unknown> = {};\n    const dtoObj = dto as Record<string, unknown>;\n    for (const destKey of Object.keys(rules) as Array<keyof R & string>) {\n      const rule = rules[destKey] as Rule | undefined;\n      if (rule === undefined) continue;\n      const destValue = getPath(dtoObj, destKey);\n      if (isStringRule(rule)) {\n        setPath(out, rule, destValue);\n      } else if (isPairRule(rule)) {\n        setPath(out, destKey, rule.from(destValue));\n      } else if (isDefaultRule(rule)) {\n        // Round-trip the read key; the default itself is forward-only.\n        setPath(out, (rule as DefaultRule).source ?? destKey, destValue);\n      } else if (isFromResolverRule(rule as Rule)) {\n        // Resolver-backed fields have no source inverse; skip.\n        continue;\n      } else {\n        // One-way function rule, no inverse.\n        throw new OneWayRuleError(destKey);\n      }\n    }\n    return out;\n  }\n\n  type Dest = z.infer<S>;\n\n  function toResolver<TAdapter>(\n    adapter: TAdapter,\n    seed?: Partial<Dest>,\n  ): ResolverContext<Dest, TAdapter> {\n    if (!mapResolvers) {\n      throw new MapHasNoResolversError();\n    }\n    // Per-field schemas from this map's own shape (over-exposure protection).\n    const schemas: Record<string, z.ZodType> = {};\n    for (const key of Object.keys(shape)) {\n      schemas[key] = shape[key] as z.ZodType;\n    }\n    return createResolver<Dest, TAdapter>({\n      adapter,\n      seed,\n      resolvers: mapResolvers as ResolverRegistry<Dest, TAdapter>,\n      schemas: schemas as Record<keyof Dest, z.ZodType>,\n    });\n  }\n\n  const mapper: TypeMapper<S, R> = {\n    forward,\n    reverse,\n    forwardMany: (sources) => forwardManyOp(mapper, sources) as Array<Dest>,\n    reverseMany: (dtos) => reverseManyOp(mapper, dtos),\n    safeForward: (source) => safeForwardOp(mapper, source) as SafeResult<Dest>,\n    toSnakeCase,\n    toCamelCase,\n    toResolver,\n    schema,\n    rules: Object.freeze({ ...rules }) as R,\n    shape,\n    resolvers: mapResolvers,\n  };\n  return mapper;\n}\n\nexport type { FromResolver };\n"]}