attaform 0.26.0 → 0.27.0

package/dist/shared/{attaform.sHkHv_98.mjs → attaform.DhnPb6nK.mjs}

@@ -2,9 +2,12 @@ import { readFileSync } from 'node:fs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { join } from 'node:path';
 
-const ZOD_UNIFIED_SPECIFIER = "attaform/zod";
 const ZOD_V3_SPECIFIER = "attaform/zod-v3";
 const ZOD_V4_SPECIFIER = "attaform/zod-v4";
+const REWRITABLE_ZOD_SPECIFIER_FILTER = /^attaform(?:\/zod)?$/;
+function isRewritableZodSpecifier(source) {
+  return REWRITABLE_ZOD_SPECIFIER_FILTER.test(source);
+}
 function detectZodMajor(consumerRootDir) {
   const consumerURL = pathToFileURL(join(consumerRootDir, "package.json")).href;
   let resolved;
@@ -47,5 +50,5 @@ function resolveZodAliasTarget(consumerRootDir, tag, resolveZodAlias, warnState)
   return detection.major === 4 ? ZOD_V4_SPECIFIER : ZOD_V3_SPECIFIER;
 }
 
-export { ZOD_UNIFIED_SPECIFIER as Z, resolveZodAliasTarget as r };
-//# sourceMappingURL=attaform.sHkHv_98.mjs.map
+export { REWRITABLE_ZOD_SPECIFIER_FILTER as R, isRewritableZodSpecifier as i, resolveZodAliasTarget as r };
+//# sourceMappingURL=attaform.DhnPb6nK.mjs.map

package/dist/shared/attaform.DhnPb6nK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.DhnPb6nK.mjs","sources":["../../src/core/detect-zod-major.ts"],"sourcesContent":["/**\n * Shared build-time Zod-major detection and adapter-alias resolution for\n * the bundler plugins (`attaform/vite`, `attaform/rollup`,\n * `attaform/esbuild`, `attaform/webpack`, `attaform/rspack`).\n *\n * The unified `attaform/zod` entry — and the bare `attaform` barrel, which\n * re-exports the identical surface — runtime-dispatches between the v3 and\n * v4 adapters, so a bundler that does not rewrite the import ships BOTH.\n * Each plugin rewrites those two specifiers (see\n * {@link REWRITABLE_ZOD_SPECIFIER_FILTER}) to the single matching adapter\n * subpath (`attaform/zod-v3` or `attaform/zod-v4`) based on the Zod major\n * resolved from the consumer's project, so the consumer bundle carries\n * one adapter instead of two. This module holds the detection (pure Node,\n * no bundler API) plus the shared diagnostic copy so every plugin behaves\n * and reads identically.\n *\n * Build-time only: imported by the build-tool entries at `src/*.ts`,\n * never by runtime code, so it never reaches a consumer's browser bundle.\n */\nimport { readFileSync } from 'node:fs'\nimport { fileURLToPath, pathToFileURL } from 'node:url'\nimport { join } from 'node:path'\n\nexport const ZOD_UNIFIED_SPECIFIER = 'attaform/zod'\nexport const ZOD_V3_SPECIFIER = 'attaform/zod-v3'\nexport const ZOD_V4_SPECIFIER = 'attaform/zod-v4'\nexport const ZOD_BARREL_SPECIFIER = 'attaform'\n\n/**\n * The two specifiers a plugin collapses to a single adapter: the explicit\n * unified `attaform/zod` entry AND the bare `attaform` barrel. Both are\n * structurally identical (the barrel re-exports the same\n * `_shared-exports` + `_zod-binding` surface as `attaform/zod`), so both\n * carry the runtime-dispatching `useForm` that pulls in BOTH adapters —\n * and both rewrite to the same single adapter when one Zod major is\n * detected.\n *\n * The rewrite is value-safe: every runtime binding the barrel exports\n * (`useForm`, `fieldMeta`, `withMeta`, plus everything in\n * `_shared-exports`) is also exported by `attaform/zod-v3` and\n * `attaform/zod-v4`, so redirecting bare `attaform` to a pinned adapter\n * can never strand a runtime import. (Type-only exports are erased before\n * this resolve hook runs and are type-checked against the un-rewritten\n * `attaform` specifier, so their per-adapter asymmetry is irrelevant.)\n *\n * The pattern is anchored (`^...$`) so it matches ONLY those two\n * specifiers: the pinned adapters (`attaform/zod-v3`, `attaform/zod-v4`)\n * and every build-tool / other subpath (`attaform/nuxt`, `attaform/vite`,\n * `attaform/abstract`, `attaform/transforms`, ...) pass through untouched.\n * It serves double duty — as esbuild's `onResolve` `filter` (a Go RE2\n * regexp) and, via `.test()`, as the string-match predicate the other\n * plugins call — so the two representations can never diverge.\n */\nexport const REWRITABLE_ZOD_SPECIFIER_FILTER = /^attaform(?:\\/zod)?$/\n\n/**\n * True when `source` is a specifier the plugins rewrite to a single Zod\n * adapter: the bare `attaform` barrel or the explicit `attaform/zod`.\n * Backed by {@link REWRITABLE_ZOD_SPECIFIER_FILTER} so it stays in lockstep\n * with esbuild's filter.\n */\nexport function isRewritableZodSpecifier(source: string): boolean {\n  return REWRITABLE_ZOD_SPECIFIER_FILTER.test(source)\n}\n\nexport type ZodMajorDetection =\n  | { major: 3 }\n  | { major: 4 }\n  | { major: 'missing' }\n  | { major: 'unknown' }\n\n/**\n * Read the consumer's installed Zod major by resolving\n * `zod/package.json` from their project root. ESM resolution\n * (`import.meta.resolve`) is sync and stable on Node 20.6+, follows\n * pnpm symlinks, and works with attaform's ESM-only `exports` map.\n *\n * Returns:\n *  - `{ major: 3 | 4 }` when zod is resolvable AND its `version`\n *    field parses to a known major;\n *  - `{ major: 'missing' }` when zod can't be resolved at all;\n *  - `{ major: 'unknown' }` for any other failure (corrupted\n *    package.json, unexpected version string, monorepo edge case).\n */\nexport function detectZodMajor(consumerRootDir: string): ZodMajorDetection {\n  const consumerURL = pathToFileURL(join(consumerRootDir, 'package.json')).href\n  let resolved: string\n  try {\n    resolved = import.meta.resolve('zod/package.json', consumerURL)\n  } catch {\n    return { major: 'missing' }\n  }\n  try {\n    const pkg = JSON.parse(readFileSync(fileURLToPath(resolved), 'utf8')) as { version?: unknown }\n    const version = pkg.version\n    if (typeof version !== 'string') return { major: 'unknown' }\n    const major = Number.parseInt(version.split('.')[0] ?? '', 10)\n    if (major === 3) return { major: 3 }\n    if (major === 4) return { major: 4 }\n    return { major: 'unknown' }\n  } catch {\n    return { major: 'unknown' }\n  }\n}\n\n/**\n * One-shot latch so a plugin warns about an unclassifiable Zod version\n * only once, however many times its detection runs across a build.\n */\nexport interface ZodDetectionWarnState {\n  warned: boolean\n}\n\nfunction missingZodError(tag: string): string {\n  return (\n    `[${tag}] zod is not installed. attaform requires zod as a peer dependency. ` +\n    'Install `zod@^3` or `zod@^4`, OR pass `attaform({ resolveZodAlias: false })` ' +\n    'to keep the runtime-dispatch unified entry (and silence this check).'\n  )\n}\n\nfunction unclassifiableZodWarning(tag: string): string {\n  return (\n    `[${tag}] Could not classify the installed Zod major (corrupted package.json, ` +\n    'monorepo edge case, or an unexpected version string). Falling through to runtime ' +\n    'dispatch — both Zod adapters will ship in the bundle. ' +\n    'Pass `attaform({ resolveZodAlias: false })` to silence this warning.'\n  )\n}\n\n/**\n * Resolve the rewrite target for the unified `attaform/zod` specifier,\n * shared by every bundler plugin so they diagnose identically:\n *   - returns `attaform/zod-v3` / `attaform/zod-v4` when the consumer's\n *     Zod major is detected;\n *   - returns `null` to leave `attaform/zod` on its runtime-dispatch\n *     entry, either because `resolveZodAlias` is off or because the\n *     version could not be classified (warned once via `warnState`);\n *   - throws when zod is not installed at all, a fatal misconfiguration\n *     the consumer must fix.\n *\n * `tag` brands the diagnostics (`attaform/vite`, `attaform/rollup`, etc).\n * `resolveZodAlias` and `warnState` are supplied by the calling plugin:\n * its consumer-facing default and its per-instance warn latch live at the\n * plugin surface, not here.\n */\nexport function resolveZodAliasTarget(\n  consumerRootDir: string,\n  tag: string,\n  resolveZodAlias: boolean,\n  warnState: ZodDetectionWarnState\n): string | null {\n  if (!resolveZodAlias) return null\n  const detection = detectZodMajor(consumerRootDir)\n  if (detection.major === 'missing') {\n    throw new Error(missingZodError(tag))\n  }\n  if (detection.major === 'unknown') {\n    if (!warnState.warned) {\n      warnState.warned = true\n      console.warn(unclassifiableZodWarning(tag))\n    }\n    return null\n  }\n  return detection.major === 4 ? ZOD_V4_SPECIFIER : ZOD_V3_SPECIFIER\n}\n"],"names":[],"mappings":";;;;AAwBO,MAAM,gBAAA,GAAmB,iBAAA;AACzB,MAAM,gBAAA,GAAmB,iBAAA;AA4BzB,MAAM,+BAAA,GAAkC;AAQxC,SAAS,yBAAyB,MAAA,EAAyB;AAChE,EAAA,OAAO,+BAAA,CAAgC,KAAK,MAAM,CAAA;AACpD;AAqBO,SAAS,eAAe,eAAA,EAA4C;AACzE,EAAA,MAAM,cAAc,aAAA,CAAc,IAAA,CAAK,eAAA,EAAiB,cAAc,CAAC,CAAA,CAAE,IAAA;AACzE,EAAA,IAAI,QAAA;AACJ,EAAA,IAAI;AACF,IAAA,QAAA,GAAW,MAAA,CAAA,IAAA,CAAY,OAAA,CAAQ,kBAAA,EAAoB,WAAW,CAAA;AAAA,EAChE,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,EAAE,OAAO,SAAA,EAAU;AAAA,EAC5B;AACA,EAAA,IAAI;AACF,IAAA,MAAM,GAAA,GAAM,KAAK,KAAA,CAAM,YAAA,CAAa,cAAc,QAAQ,CAAA,EAAG,MAAM,CAAC,CAAA;AACpE,IAAA,MAAM,UAAU,GAAA,CAAI,OAAA;AACpB,IAAA,IAAI,OAAO,OAAA,KAAY,QAAA,EAAU,OAAO,EAAE,OAAO,SAAA,EAAU;AAC3D,IAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,QAAA,CAAS,OAAA,CAAQ,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,IAAK,EAAA,EAAI,EAAE,CAAA;AAC7D,IAAA,IAAI,KAAA,KAAU,CAAA,EAAG,OAAO,EAAE,OAAO,CAAA,EAAE;AACnC,IAAA,IAAI,KAAA,KAAU,CAAA,EAAG,OAAO,EAAE,OAAO,CAAA,EAAE;AACnC,IAAA,OAAO,EAAE,OAAO,SAAA,EAAU;AAAA,EAC5B,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,EAAE,OAAO,SAAA,EAAU;AAAA,EAC5B;AACF;AAUA,SAAS,gBAAgB,GAAA,EAAqB;AAC5C,EAAA,OACE,IAAI,GAAG,CAAA,2NAAA,CAAA;AAIX;AAEA,SAAS,yBAAyB,GAAA,EAAqB;AACrD,EAAA,OACE,IAAI,GAAG,CAAA,wRAAA,CAAA;AAKX;AAkBO,SAAS,qBAAA,CACd,eAAA,EACA,GAAA,EACA,eAAA,EACA,SAAA,EACe;AACf,EAAA,IAAI,CAAC,iBAAiB,OAAO,IAAA;AAC7B,EAAA,MAAM,SAAA,GAAY,eAAe,eAAe,CAAA;AAChD,EAAA,IAAI,SAAA,CAAU,UAAU,SAAA,EAAW;AACjC,IAAA,MAAM,IAAI,KAAA,CAAM,eAAA,CAAgB,GAAG,CAAC,CAAA;AAAA,EACtC;AACA,EAAA,IAAI,SAAA,CAAU,UAAU,SAAA,EAAW;AACjC,IAAA,IAAI,CAAC,UAAU,MAAA,EAAQ;AACrB,MAAA,SAAA,CAAU,MAAA,GAAS,IAAA;AACnB,MAAA,OAAA,CAAQ,IAAA,CAAK,wBAAA,CAAyB,GAAG,CAAC,CAAA;AAAA,IAC5C;AACA,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,OAAO,SAAA,CAAU,KAAA,KAAU,CAAA,GAAI,gBAAA,GAAmB,gBAAA;AACpD;;;;"}

package/dist/shared/attaform.DkD0DR7R.mjs

@@ -0,0 +1,42 @@
+import { a as InvalidUseFormConfigError } from './attaform.Da8EdI2t.mjs';
+import { u as useForm$2 } from './attaform.DlSu08F5.mjs';
+import { u as useForm$1 } from './attaform.BceJrhQ7.mjs';
+import { f as fieldMetaStore, g as getFieldMetaForSchema } from './attaform.DDAmSFnl.mjs';
+
+function isZodV4SchemaShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const def = value.def;
+  if (typeof def !== "object" || def === null) return false;
+  return typeof def.type === "string";
+}
+
+function useForm(configuration) {
+  if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
+    throw new InvalidUseFormConfigError();
+  }
+  const { schema } = configuration;
+  if (isZodV4SchemaShape(schema)) {
+    return useForm$1(configuration);
+  }
+  return useForm$2(configuration);
+}
+
+const fieldMeta = fieldMetaStore;
+function withMeta(schema, payload) {
+  const target = schema;
+  const existing = getFieldMetaForSchema(target) ?? {};
+  const cloned = cloneSchema(schema);
+  fieldMetaStore.add(cloned, { ...existing, ...payload });
+  return cloned;
+}
+function cloneSchema(schema) {
+  const candidate = schema;
+  if (typeof candidate.clone === "function") {
+    return candidate.clone();
+  }
+  const Ctor = candidate.constructor;
+  return new Ctor(candidate._def);
+}
+
+export { fieldMeta as f, useForm as u, withMeta as w };
+//# sourceMappingURL=attaform.DkD0DR7R.mjs.map

package/dist/shared/attaform.DkD0DR7R.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.DkD0DR7R.mjs","sources":["../../src/runtime/core/zod-shape.ts","../../src/runtime/adapters/unified/use-form.ts","../../src/runtime/adapters/unified/field-meta.ts"],"sourcesContent":["/**\n * Shape detectors for Zod schemas. Used by the unified `attaform/zod`\n * entry's runtime dispatch (`runtime/adapters/unified/use-form.ts`)\n * to route to the v3 or v4 adapter based on the schema's runtime\n * shape. Mirrors the discrimination already used by the v4\n * introspection helper (`adapters/zod-v4/introspect.ts`'s\n * `assertZodVersion`, which reads `def.type`) and the v3 wrapper's\n * legitimate-input branch (`composables/use-form.ts`'s `isZodType`,\n * which reads `_def`).\n *\n * Why this discriminator and not `_zod` / `_def`:\n * - Zod v4 retained `_def` for backward compat — reading `_def` alone\n *   misclassifies v4 schemas as v3.\n * - Zod v4's stable shape is `def.type: string` (lowercase tag like\n *   `'object'`); Zod v3's is `_def.typeName: string` (capitalised tag\n *   like `'ZodObject'`). Both are checked structurally so consumers\n *   who alias one Zod major to a non-standard import path still work.\n */\n\ninterface ZodV4Shape {\n  def: { type: unknown }\n}\n\ninterface ZodV3Shape {\n  _def: { typeName: unknown }\n}\n\n/**\n * Returns true when `value` looks like a Zod schema of either major\n * version. Convenience wrapper around the v3 / v4 detectors.\n */\nexport function isZodSchemaShape(value: unknown): boolean {\n  return isZodV4SchemaShape(value) || isZodV3SchemaShape(value)\n}\n\n/**\n * Returns true when `value` looks like a Zod v4 schema (has\n * `def.type: string`). Used by the unified entry's runtime-dispatch\n * to route to the v4 adapter.\n */\nexport function isZodV4SchemaShape(value: unknown): value is ZodV4Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { def?: unknown }).def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { type?: unknown }).type === 'string'\n}\n\n/**\n * Returns true when `value` looks like a Zod v3 schema (has\n * `_def.typeName: string`). Kept distinct from `isZodV4SchemaShape`\n * because some v4 schemas also expose `_def` for backward compat —\n * the v4 detector wins first in `isZodSchemaShape`.\n */\nexport function isZodV3SchemaShape(value: unknown): value is ZodV3Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { _def?: unknown })._def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { typeName?: unknown }).typeName === 'string'\n}\n","/**\n * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches\n * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the\n * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes\n * to the v3 wrapper, which already accepts both Zod v3 input and\n * `AbstractSchema` directly via its built-in shape branch.\n *\n * Type-level dispatch happens via TWO typed overloads — v4 first, v3\n * second — plus an untyped impl. Each overload mirrors the matching\n * direct adapter's signature exactly, so a v4-schema call site pays\n * the same per-call depth cost as importing from `attaform/zod-v4`\n * directly. Overload resolution at concrete call sites commits to one\n * overload immediately on argument shape — no type-level dispatch tax.\n *\n * Tests and other call sites that need the equivalent of\n * `typeof useForm<X>` should reach for the `UseFormReturn<X>` /\n * `UseFormConfig<X>` helpers in `types-api.ts` — instantiation\n * expressions on overloaded functions follow brittle resolution rules,\n * and the helper types give a deterministic projection.\n *\n * This module is the FALLBACK path. Vite consumers see the\n * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`\n * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build\n * time — in that case this dispatch never runs and the consumer\n * bundle ships only the matching adapter. Other bundlers (and\n * non-bundled ESM consumption) hit this dispatch instead, paying a\n * modest size cost for the convenience of a single hello-world import.\n *\n * Power users who want a guaranteed lean bundle on non-Vite tooling\n * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —\n * those subpaths are never rewritten and never load the other\n * adapter.\n */\nimport { InvalidUseFormConfigError } from '../../core/errors'\nimport { isZodV4SchemaShape } from '../../core/zod-shape'\nimport type { ZodV4Internals } from './types-zod-major'\nimport { useForm as useFormV3 } from '../../composables/use-form'\nimport { useForm as useFormV4 } from '../zod-v4'\nimport type {\n  AbstractSchema,\n  FormKey,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { AcceptableDefaults } from '../../types/types-core'\nimport type { SupportedRootSchema as SupportedRootSchemaV4 } from '../zod-v4/types-root'\nimport type { SupportedRootSchema as SupportedRootSchemaV3 } from '../zod-v3/types-root'\nimport type {\n  V3FormOf,\n  V3OutOf,\n  V3ReadOf,\n  V3SchemaInput,\n  V4FormOf,\n  V4OutOf,\n  V4ReadOf,\n  V4SchemaInput,\n} from './types-projections'\n\n/**\n * Create a form bound to a Zod v4 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * The constraint intersects `ZodV4Internals` (the v4-only `_zod`\n * brand) so a v3 schema can't bind this overload even when `z`\n * resolves to v3 in a single-major consumer install; v3 schemas fall\n * through to the v3 overload below. See `types-zod-major.ts`.\n */\nexport function useForm<\n  Schema extends SupportedRootSchemaV4 & ZodV4Internals,\n  K extends FormKey = FormKey,\n>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V4FormOf<Schema>,\n      V4OutOf<Schema>,\n      AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>,\n      // `defaultValues` is Omitted below and re-supplied via the\n      // `AcceptableDefaults` intersection, so this `DefaultValues` slot is\n      // inert. `never` keeps it from re-instantiating the deep\n      // `DefaultValuesInput` cascade here — that redundant instantiation,\n      // across both overloads at a concrete call site, tips the bundled\n      // `.d.ts` into TS2589.\n      never,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'\n  > & {\n    schema: Schema\n    // #422: the `AcceptableDefaults` slot adds the schema's own input\n    // (`V4SchemaInput<Schema>`) as a reflexive escape arm so a generic form\n    // wrapper forwarding `defaultValues` does not trip TS2589 / TS2769.\n    // The arm is redundant at concrete call sites (a schema's input is a\n    // subset of its `DefaultValuesInput`), so concrete checking is\n    // unchanged. The return type never references the slot, so field\n    // inference is preserved through the wrapper. See `AcceptableDefaults`.\n    defaultValues?: AcceptableDefaults<V4FormOf<Schema>, V4SchemaInput<Schema>>\n  } & ValidateOnConfig\n): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>\n/**\n * Create a form bound to a Zod v3 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod-v3'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v3 schemas match this overload; v4 schemas hit the v4 overload\n * above first and never reach here.\n */\nexport function useForm<Schema extends SupportedRootSchemaV3, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V3FormOf<Schema>,\n      V3OutOf<Schema>,\n      AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>,\n      // Inert `DefaultValues` slot — see the v4 overload above.\n      never,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'\n  > & {\n    schema: Schema\n    // #422 — see the v4 overload above for the escape-arm rationale.\n    defaultValues?: AcceptableDefaults<V3FormOf<Schema>, V3SchemaInput<Schema>>\n  } & ValidateOnConfig\n): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForm(configuration: any): any {\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4>[0])\n  }\n  return useFormV3(configuration as Parameters<typeof useFormV3>[0])\n}\n","/**\n * Field-metadata write/read API for the unified `attaform/zod` entry.\n *\n * Storage is shared with both adapters via `field-meta-store` — a\n * payload written here is visible to whichever adapter the unified\n * `useForm` dispatches to at runtime, regardless of Zod major. No\n * `zod` runtime import; the type-only `import type` is erased at\n * build, so `attaform/zod` carries no `z.registry` reference even\n * when consumed by a Zod 3 project without the Vite plugin alias.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` continues\n * to work — Zod 4's `.register()` only calls `.add(this, payload)`\n * structurally, satisfied by the shared store.\n */\nimport type { z } from 'zod'\nimport type { FieldMetaPayload } from '../../core/field-meta'\nimport { fieldMetaStore, getFieldMetaForSchema } from '../../core/field-meta-store'\n\n// Zod v4's `$ZodRegistry` class isn't surfaced under the `z` namespace\n// of the classic external entry, but `z.registry()` returns one — so\n// `ReturnType<typeof z.registry<T>>` resolves to the registry type\n// without needing a direct import. The `import type` keeps the\n// reference type-only; nothing about `z.registry` lands in the bundle.\ntype ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of major. Same instance the v3\n * and v4 adapter entries expose — write in one place, read from\n * any.\n *\n * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native\n * `schema.register(fieldMeta, payload)` chain type-checks for v4\n * users; the runtime call only needs `.add` structurally, which the\n * shared store provides.\n */\nexport const fieldMeta = fieldMetaStore as unknown as ZodFieldMetaRegistry\n\n/**\n * Attach `payload` to `schema` in the shared registry and return a\n * clone of `schema` so each call gets its own identity (the registry\n * keys on schema reference, so cloning prevents last-write-wins\n * collisions for sub-schemas reused at multiple paths).\n *\n * Works on both Zod 3 and Zod 4 schemas — branches on the runtime\n * shape of the schema:\n * - Zod 4 schemas expose a public `.clone()` method; we call it.\n * - Zod 3 schemas don't, so we reconstruct via\n *   `new schema.constructor(schema._def)`.\n *\n * Both forms produce a fresh schema with the same effective\n * structure, so the registry slot is unique to this call site.\n */\nexport function withMeta<S>(schema: S, payload: FieldMetaPayload): S {\n  const target = schema as object\n  const existing = getFieldMetaForSchema(target) ?? {}\n  const cloned = cloneSchema(schema)\n  fieldMetaStore.add(cloned as object, { ...existing, ...payload })\n  return cloned\n}\n\nfunction cloneSchema<S>(schema: S): S {\n  const candidate = schema as { clone?: unknown; constructor: unknown; _def: unknown }\n  if (typeof candidate.clone === 'function') {\n    return (candidate.clone as () => S)()\n  }\n  // Zod 3 path: reconstruct via constructor + _def (no public\n  // `.clone()` on v3).\n  const Ctor = candidate.constructor as new (def: unknown) => S\n  return new Ctor(candidate._def)\n}\n"],"names":["useFormV4","useFormV3"],"mappings":";;;;;AAwCO,SAAS,mBAAmB,KAAA,EAAqC;AACtE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,MAAO,KAAA,CAA4B,GAAA;AACzC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,OAAO,OAAQ,IAA2B,IAAA,KAAS,QAAA;AACrD;;ACqGO,SAAS,QAAQ,aAAA,EAAyB;AAC/C,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAI,yBAAA,EAA0B;AAAA,EACtC;AACA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOA,UAAU,aAAgD,CAAA;AAAA,EACnE;AACA,EAAA,OAAOC,UAAU,aAAgD,CAAA;AACnE;;AC3HO,MAAM,SAAA,GAAY;AAiBlB,SAAS,QAAA,CAAY,QAAW,OAAA,EAA8B;AACnE,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,MAAM,QAAA,GAAW,qBAAA,CAAsB,MAAM,CAAA,IAAK,EAAC;AACnD,EAAA,MAAM,MAAA,GAAS,YAAY,MAAM,CAAA;AACjC,EAAA,cAAA,CAAe,IAAI,MAAA,EAAkB,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAChE,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,YAAe,MAAA,EAAc;AACpC,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,IAAI,OAAO,SAAA,CAAU,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAQ,UAAU,KAAA,EAAkB;AAAA,EACtC;AAGA,EAAA,MAAM,OAAO,SAAA,CAAU,WAAA;AACvB,EAAA,OAAO,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAChC;;;;"}

package/dist/shared/{attaform.CSXDW2tO.mjs → attaform.DlSu08F5.mjs}

@@ -1,6 +1,6 @@
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, b as getFieldMetaPathMap, m as mergeDeep, p as peelEmbeddedDefault, N as NO_EMBEDDED_DEFAULT } from './attaform.CXVmZtFq.mjs';
-import { o as humanize, p as getAtPath, n as slimKindOf, q as setAtPath, h as useAbstractForm } from './attaform.BoYqnIPI.mjs';
-import { A as AttaformError, _ as __DEV__, f as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.DGhIix5D.mjs';
+import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, c as createAbstractSchema, w as walkPathSegments, d as deriveDefaultWalk, b as getFieldMetaPathMap, m as mergeDeep, p as peelEmbeddedDefault, N as NO_EMBEDDED_DEFAULT } from './attaform.DDAmSFnl.mjs';
+import { p as humanize, q as getAtPath, o as slimKindOf, r as setAtPath, g as useAbstractForm } from './attaform.CyQxTOdX.mjs';
+import { A as AttaformError, _ as __DEV__, f as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.Da8EdI2t.mjs';
 
 const fieldMeta = fieldMetaStore;
 function withMeta(schema, payload) {
@@ -1628,4 +1628,4 @@ function useForm(configuration) {
 }
 
 export { fieldMeta as f, isZodSchemaType as i, useForm as u, withMeta as w, zodAdapter as z };
-//# sourceMappingURL=attaform.CSXDW2tO.mjs.map
+//# sourceMappingURL=attaform.DlSu08F5.mjs.map