attaform 0.21.1 → 0.22.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"attaform.Be8NZG9M.mjs","sources":["../../src/runtime/core/abstract-schema-factory.ts","../../src/runtime/core/merge-deep.ts","../../src/runtime/core/walk-path-segments.ts","../../src/runtime/core/walk-derive-default.ts","../../src/runtime/core/field-meta-store.ts","../../src/runtime/core/walk-slim-primitives.ts","../../src/runtime/core/walk-field-meta.ts"],"sourcesContent":["/**\n * `createAbstractSchema` — the schema-agnostic factory that hosts every\n * `AbstractSchema` method whose implementation is identical-modulo-\n * introspector between the v3 and v4 adapters.\n *\n * Each adapter wires through two small contracts:\n *\n *   - `SchemaIntrospector<Schema>` — pure, side-effect-free accessors\n *     that read schema shape. The factory branches on `kindOf`, walks\n *     discriminated-union literals via `getLiteralValues` /\n *     `getDiscriminatedOptions`, detects coerce / preprocess nodes,\n *     and consults the three async / container-refine flags.\n *\n *   - `AbstractSchemaServices<Schema, Form, GetValueFormType>` — the\n *     adapter-specific delegates the factory calls for everything that\n *     genuinely diverges per Zod version: fingerprinting, path-walking\n *     (the path walker itself has v3 / v4 quirks), default-value\n *     derivation, the strict-mode `getDefaultValues` flow,\n *     wrapper-peeling that's tied to the per-version wrapper set,\n *     field-meta resolution, and the per-version `safeParse`\n *     boundary.\n *\n * The two-interface split keeps the introspector reusable by any other\n * walker (fingerprint, slim-primitives, default-values) without dragging\n * in the side-effectful services. Services consume the introspector as\n * they wish; the factory consumes both.\n *\n * Behavior-neutral by design: the goal is one set of definitions for\n * the 13 structurally-parallel methods, with no observable change at\n * either adapter's `AbstractSchema` surface. Per-adapter caches keep\n * the same lifetime (one per `useForm()` call); `getSchemasAtPath`\n * preserves each adapter's prior sub-schema shape via the\n * `makeSubSchema` service (v3 recurses; v4 builds the 5-method stub).\n */\nimport type {\n  AbstractSchema,\n  DefaultValuesResponse,\n  FormKey,\n  GetDefaultValuesConfig,\n  ResolvedFieldMeta,\n  SlimPrimitiveKind,\n  UnionDiscriminatorContext,\n  ValidationError,\n  ValidationResponse,\n  ValidateOptions,\n} from '../types/types-api'\nimport type { SchemaFactoryOptions } from './get-computed-schema'\nimport { AttaformErrorCode } from './error-codes'\nimport { canonicalizePath, type Path, type PathKey } from './paths'\n\nconst PATH_SEPARATOR = '.'\n\n/**\n * Stable shape-discriminant the factory branches on. Adapters return\n * the union of v3 + v4 kinds plus `'unknown'` for anything they don't\n * recognise — the factory only inspects a small subset\n * (`'tuple'` / `'array'` for `arrayShapeAtPath`,\n * `'literal'` for the discriminated-union walk), so adapters can return\n * extra version-specific kinds (`'effects'` / `'pipeline'` / `'branded'`\n * / `'native-enum'` on v3) without confusing the factory.\n */\nexport type SharedZodKind =\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'bigint'\n  | 'date'\n  | 'null'\n  | 'undefined'\n  | 'literal'\n  | 'enum'\n  | 'native-enum'\n  | 'object'\n  | 'array'\n  | 'tuple'\n  | 'set'\n  | 'record'\n  | 'map'\n  | 'union'\n  | 'discriminated-union'\n  | 'intersection'\n  | 'optional'\n  | 'nullable'\n  | 'default'\n  | 'catch'\n  | 'readonly'\n  | 'branded'\n  | 'effects'\n  | 'pipeline'\n  | 'lazy'\n  | 'pipe'\n  | 'transform'\n  | 'preprocess'\n  | 'any'\n  | 'unknown'\n  | 'never'\n  | 'nan'\n  | 'void'\n  | 'file'\n  | 'function'\n  | 'symbol'\n  | 'promise'\n  | 'custom'\n  | 'template-literal'\n\n/**\n * Pure schema-shape accessors. The factory consults these to branch on\n * structural facts about a schema node. Every member is side-effect-\n * free and idempotent.\n *\n * `kindOf` returns the discriminant; the structural accessors\n * (`getObjectShape`, `getTupleItems`, `getDiscriminatedOptions`,\n * `getLiteralValues`) read a single field of the node's def shape.\n * The three boolean predicates summarise tree-walking detections each\n * adapter already exposes; both adapters memoise them at the\n * AbstractSchema level so calling per construction is cheap.\n */\nexport interface SchemaIntrospector<Schema> {\n  /** Discriminant on schema shape. Adapters may return extra kinds. */\n  kindOf(schema: Schema): SharedZodKind | string\n  /**\n   * Returns the property-to-sub-schema map of a `ZodObject`. Empty\n   * record for non-objects.\n   */\n  getObjectShape(schema: Schema): Record<string, Schema>\n  /** Returns the position-typed items of a `ZodTuple`. Empty for non-tuples. */\n  getTupleItems(schema: Schema): readonly Schema[]\n  /**\n   * Returns the option objects of a `ZodDiscriminatedUnion` — each one\n   * is itself a `ZodObject` whose `getObjectShape` includes the\n   * discriminator key as a `ZodLiteral`.\n   */\n  getDiscriminatedOptions(schema: Schema): readonly Schema[]\n  /** Returns the discriminator key of a `ZodDiscriminatedUnion`. */\n  getDiscriminator(schema: Schema): string | undefined\n  /**\n   * Returns the literal values a `ZodLiteral` admits. Multi-value\n   * literals (`z.literal(['a', 'b'])`) return both; single-value return\n   * the one. Empty for non-literals.\n   */\n  getLiteralValues(schema: Schema): readonly unknown[]\n  /**\n   * True iff the node is a preprocess-style schema-side normalizer:\n   * `z.preprocess(fn, inner)` in either version. v3's `ZodEffects`\n   * with `effect.type === 'preprocess'` and v4's `ZodPipe<ZodTransform,\n   * inner>` both collapse here. Coerce primitives go through\n   * `isCoercePrimitive` instead — they're not pipes in v4 and not\n   * effects in v3, but both adapters detect them off the same flag.\n   */\n  isPreprocessNode(schema: Schema): boolean\n  /**\n   * True iff the schema is a `z.coerce.X()` primitive. Both adapter\n   * versions store the coerce intent as a flag on the wrapped\n   * primitive's def (not as a wrapper), so detection is uniform.\n   */\n  isCoercePrimitive(schema: Schema): boolean\n  /**\n   * True iff the schema tree contains a refine whose predicate can run\n   * asynchronously. v3 is conservative (every `.refine` flagged because\n   * the inner sync wrapper hides the user fn); v4 is exact (inspects\n   * `def.checks[].def.fn.constructor.name`). Either way the runtime\n   * uses this to decide whether a construction-time async pass is\n   * needed.\n   */\n  containsAsyncRefine(schema: Schema): boolean\n  /**\n   * True iff the schema tree contains a `.transform(asyncFn)` /\n   * `z.preprocess(asyncFn, …)`. Statically detectable in both adapters\n   * via the user fn's `constructor.name === 'AsyncFunction'`. Disjoint\n   * from `containsAsyncRefine` — refines and transforms live in\n   * different slots.\n   */\n  containsAsyncTransform(schema: Schema): boolean\n  /**\n   * True iff any refine fires at a container node (object / array /\n   * tuple / union / discriminated-union / intersection / record / set)\n   * or the root. False means every refine is leaf-local, so per-keystroke\n   * subtree validation catches the same verdicts as a whole-form pass.\n   */\n  hasContainerOrRootRefine(schema: Schema): boolean\n\n  // ---------------------------------------------------------------------\n  // Walker accessors — consumed by the shared `core/walk-*` walkers (D2 /\n  // D3 / D5) so the path-walking / slim-primitive / default-derivation\n  // shapes don't fork per adapter. v3 / v4 each expose the full surface;\n  // members not applicable to one adapter return `undefined` (kept on the\n  // contract so the walkers don't branch on adapter identity).\n  // ---------------------------------------------------------------------\n\n  /** Element schema of a `z.array(...)`. Undefined for non-arrays / malformed defs. */\n  getArrayElement(schema: Schema): Schema | undefined\n  /** Element schema of a `z.set(...)`. Undefined for non-sets / malformed defs. */\n  getSetValueType(schema: Schema): Schema | undefined\n  /** Key schema of a `z.record(K, V)`. Undefined for non-records / single-arg records. */\n  getRecordKeyType(schema: Schema): Schema | undefined\n  /** Value schema of a `z.record(...)`. Undefined for non-records / malformed defs. */\n  getRecordValueType(schema: Schema): Schema | undefined\n  /** Option array of a `z.union(...)`. Empty for non-unions. */\n  getUnionOptions(schema: Schema): readonly Schema[]\n  /** Left side of a `z.intersection(L, R)`. Undefined for non-intersections. */\n  getIntersectionLeft(schema: Schema): Schema | undefined\n  /** Right side of a `z.intersection(L, R)`. Undefined for non-intersections. */\n  getIntersectionRight(schema: Schema): Schema | undefined\n  /** Values of a `z.enum(...)`. Empty for non-enums. */\n  getEnumValues(schema: Schema): readonly (string | number)[]\n  /**\n   * Raw reverse-mapped values object of a `z.nativeEnum(E)`. v3 returns\n   * the TS enum object directly; v4 always returns `undefined` because\n   * v4 folds nativeEnum into the regular `enum` kind.\n   */\n  getNativeEnumValues(schema: Schema): Record<string, unknown> | undefined\n\n  /**\n   * Inner schema of any wrapper exposing `def.innerType` — Optional /\n   * Nullable / Default / Readonly / Catch in both v3 and v4. Branded\n   * (v3-only) uses `def.type` instead — see `unwrapBranded`. Returns\n   * `undefined` when no inner is available.\n   */\n  unwrapInner(schema: Schema): Schema | undefined\n  /**\n   * v3-only: `ZodBranded`'s inner schema (`_def.type`). Returns\n   * `undefined` on v4 (no branded wrapper) and on non-branded schemas.\n   */\n  unwrapBranded(schema: Schema): Schema | undefined\n  /**\n   * v3-only: structural source of a `ZodEffects` (refine / transform /\n   * preprocess) — `_def.schema`. Returns `undefined` on v4 (no\n   * ZodEffects wrapper; effects live as pipe sides / leaf checks).\n   */\n  unwrapEffectsSource(schema: Schema): Schema | undefined\n  /** Input side of v4's `z.pipe(IN, OUT)` (also v3's `z.pipeline(...)`). */\n  unwrapPipeIn(schema: Schema): Schema | undefined\n  /** Output side of a pipe — undefined on v3's `ZodEffects`. */\n  unwrapPipeOut(schema: Schema): Schema | undefined\n  /**\n   * Inner schema of a `z.lazy(() => inner)`. Each call invokes the\n   * getter fresh; if the getter throws (recursive cycle resolved before\n   * its target is constructed) returns `undefined`.\n   */\n  unwrapLazy(schema: Schema): Schema | undefined\n  /**\n   * Getter function reference of a `z.lazy()` wrapper — used by walkers\n   * that track cycle identity by the getter rather than its result\n   * (each call returns a distinct schema instance).\n   */\n  getLazyGetter(schema: Schema): (() => unknown) | undefined\n\n  /**\n   * Resolve a `z.default(...)` wrapper to its declared default value.\n   * v3 stores the default as a thunk (`() => value`); v4 stores it as\n   * a getter that returns the value directly. Both adapters return the\n   * resolved value here.\n   */\n  getDefaultValue(schema: Schema): unknown\n  /**\n   * Resolve a `z.catch(inner, val)` wrapper to its fallback value.\n   * The catch slot stores a `(ctx) => value` function; both adapters\n   * invoke it with a placeholder context and surface `undefined` if\n   * the consumer's function throws.\n   */\n  getCatchDefault(schema: Schema): unknown\n  /**\n   * True iff the schema carries a callable `z.catch(...)` fallback.\n   * Lets callers distinguish \"no catch wrapper\" from \"catch wrapper\n   * whose value happens to be `undefined`.\"\n   */\n  hasCatchValue(schema: Schema): boolean\n}\n\n/**\n * Adapter-specific delegates the factory calls for operations that\n * genuinely differ per Zod version (path walking, default-value\n * derivation, wrapper-peeling, error normalization, sub-schema\n * construction). Each service is a thin wrapper around per-adapter\n * helpers; the factory composes them.\n *\n * `safeParseSync` / `safeParseAsync` abstract the per-version\n * `safeParse` / `safeParseAsync` calls so the factory can stay\n * version-agnostic. Both return a uniform success-discriminant shape;\n * `safeParseSync` is allowed to throw when the schema is async-only\n * (the factory catches and falls back to the async path).\n *\n * `makeSubSchema` is the per-adapter sub-schema constructor for\n * `getSchemasAtPath`. v3 recurses through the full adapter factory\n * (sub-schemas expose the entire `AbstractSchema` surface). v4 builds\n * a 5-method stub (fingerprint / needsAsyncValidation /\n * getDefaultValues / getSchemasAtPath / validateAtPath) because none\n * of its consumers reach for the wider surface and the stub keeps\n * sub-walker allocation cheap. The factory preserves each adapter's\n * prior behavior by routing through this service rather than hard-\n * coding one strategy.\n */\nexport interface AbstractSchemaServices<Schema, Form, GetValueFormType> {\n  /**\n   * Resolves the deterministic structural fingerprint of the schema.\n   * Async so adapters can dynamic-import the fingerprint walker, keeping\n   * it off the eager path (only opt-in async features consume it).\n   */\n  fingerprint(schema: Schema): Promise<string>\n  /**\n   * Returns every sub-schema reachable at the given path. Multiple\n   * results indicate a union / discriminated-union split; empty\n   * indicates the path doesn't resolve. Adapters cap descent through\n   * `z.lazy(...)` via `maxRecursionDepth`.\n   */\n  getNestedSchemasAtPath(schema: Schema, path: Path, maxRecursionDepth: number): Schema[]\n  /**\n   * \"Slim-mode\" path walk — the variant `getSlimPrimitiveTypesAtPath`\n   * and `getSchemasAtPath` consume. v3 strips refinements / defaults /\n   * optional / nullable / effects off the root before walking, so the\n   * yielded candidates reflect the slim shape (matches what the slim-\n   * primitive gate sees and what consumers expect when introspecting\n   * sub-schemas). v4 walks the original schema and aliases this to\n   * `getNestedSchemasAtPath` — its path walker already inlines the\n   * wrapper peeling.\n   */\n  getNestedSchemasInSlimMode(schema: Schema, path: Path, maxRecursionDepth: number): Schema[]\n  /** Returns the slim-primitive accept-set of a single sub-schema. */\n  slimPrimitivesOf(schema: Schema, maxRecursionDepth: number): Set<SlimPrimitiveKind>\n  /**\n   * Returns the schema's prescribed default at the given root. The\n   * runtime calls this in `getDefaultAtPath` (`useDefault=true` — honor\n   * `.default(x)`) and `getEmptyValueAtPath` (`useDefault=false` —\n   * yield the inner-schema's falsy concrete). v3 and v4 each implement\n   * their own walker; the factory only consumes the result.\n   */\n  deriveDefault(\n    schema: Schema,\n    useDefault: boolean,\n    maxRecursionDepth: number,\n    formKey: FormKey\n  ): unknown\n  /**\n   * Adapter-owned construction-time default-values flow. v3 runs a\n   * validate-then-fix loop against a slim schema with strict-mode\n   * refine seeding; v4 runs a strict-pass-or-lax-success against the\n   * derived data. Both honour `config.strict ?? true` and\n   * `config.constraints`.\n   */\n  runStrictGetDefaults(\n    schema: Schema,\n    config: GetDefaultValuesConfig<Form>,\n    formKey: FormKey,\n    maxRecursionDepth: number\n  ): DefaultValuesResponse<Form>\n  /**\n   * Peels `.optional()` / `.nullable()` only when the inner is\n   * structurally fillable (object / array / tuple / record /\n   * union / intersection or a chain of peelable wrappers that resolve\n   * to one of those). Used by `getDefaultAtPath` so partial writes\n   * through optional sub-schemas fill from the inner shape's defaults.\n   * `.default(x)` is preserved at every layer.\n   */\n  unwrapStructuralWrappers(schema: Schema): Schema\n  /**\n   * Peels every transparent wrapper (optional / nullable / default /\n   * readonly / catch / pipe / lazy / branded / effects) and descends\n   * intersection sides looking for a single discriminated union.\n   * Returns the matching DU or `undefined` when no DU is found or\n   * when ambiguity bails (two different DUs both reachable).\n   */\n  unwrapToDiscriminatedUnion(schema: Schema): Schema | undefined\n  /**\n   * Peels every transparent wrapper off a schema — for `arrayShapeAtPath`\n   * the goal is the structural kind regardless of default-value\n   * semantics, so `.default(x)` / `.catch(x)` are peeled here whereas\n   * `unwrapStructuralWrappers` preserves them.\n   */\n  peelAllWrappers(schema: Schema): Schema\n  /**\n   * Returns `true` iff the leaf schema is \"required\" at the\n   * union-aware sense documented on `AbstractSchema.isRequiredAtPath`:\n   * `.optional()` / `.nullable()` / `.default()` / `.catch()` at any\n   * wrapper layer make the leaf permissive; union requires every\n   * branch; intersection requires either side.\n   */\n  isLeafRequired(schema: Schema): boolean\n  /** Returns the resolved field-meta payload for the schema at `path`. */\n  resolveFieldMetaAtPath(schema: Schema, path: Path, maxRecursionDepth: number): ResolvedFieldMeta\n  /**\n   * Normalise schema-library issues into the runtime's\n   * `ValidationError[]` shape. v3 and v4 have slightly different\n   * `ZodIssue` payloads; each adapter knows how to map its own.\n   */\n  issuesToValidationErrors(issues: readonly unknown[], formKey: FormKey): ValidationError[]\n  /**\n   * Run a sync `safeParse` against the schema. Returns a tagged result\n   * the factory aggregates into a `ValidationResponse`. MAY throw when\n   * the schema contains async-only refines / transforms (the factory\n   * catches and falls back to the async path).\n   */\n  safeParseSync(\n    schema: Schema,\n    data: unknown\n  ): { success: true; data: unknown } | { success: false; issues: readonly unknown[] }\n  /** Async sister of `safeParseSync`. MUST NOT throw (catch user-fn rejections). */\n  safeParseAsync(\n    schema: Schema,\n    data: unknown\n  ): Promise<{ success: true; data: unknown } | { success: false; issues: readonly unknown[] }>\n  /**\n   * Per-adapter sub-schema constructor for `getSchemasAtPath`. v3\n   * recurses through the full factory (sub-schemas carry the entire\n   * `AbstractSchema` surface). v4 returns a 5-method stub. The factory\n   * delegates here to preserve each adapter's prior shape; consumers\n   * across the runtime only reach for `needsAsyncValidation()` on\n   * sub-schemas, so both shapes are observationally interchangeable.\n   */\n  makeSubSchema(\n    schema: Schema,\n    formKey: FormKey,\n    maxRecursionDepth: number\n  ): AbstractSchema<unknown, GetValueFormType>\n}\n\n/**\n * Build a runtime `AbstractSchema` for `rootSchema` by composing the\n * shared uniform-method implementations with the per-adapter introspector\n * + services. Each adapter calls this once per `useForm({ schema })` —\n * the returned object plus its three caches (`leafCache`,\n * `preprocessOrCoerceCache`, `discriminatorCache`) plus the two memoised\n * lazy flags live for the form's lifetime.\n */\nexport function createAbstractSchema<Schema, Form, GetValueFormType>(\n  rootSchema: Schema,\n  intro: SchemaIntrospector<Schema>,\n  services: AbstractSchemaServices<Schema, Form, GetValueFormType>,\n  formKey: FormKey,\n  options: SchemaFactoryOptions\n): AbstractSchema<Form, GetValueFormType> {\n  const maxRecursionDepth = options.maxRecursionDepth\n\n  // Per-adapter caches. Lifetime = one `createAbstractSchema` call (one\n  // per `useForm()`). These memoise the schema walks that the proxy\n  // traps + reactive computeds hit on every read so the schema doesn't\n  // get re-walked per keystroke / per field-state get.\n  const leafCache = new Map<PathKey, boolean>()\n  const preprocessOrCoerceCache = new Map<PathKey, boolean>()\n  const discriminatorCache = new Map<PathKey, UnionDiscriminatorContext | undefined>()\n  // Memoised one-shot tree walks. `needsAsyncValidation` is queried at\n  // construction by the store (drives the construction-time async seed);\n  // `hasContainerOrRootRefine` is queried per keystroke (drives the\n  // subtree-vs-whole-form scope cut).\n  let asyncValidationFlag: boolean | null = null\n  let containerRefineFlag: boolean | null = null\n\n  function computeDiscriminator(path: Path): UnionDiscriminatorContext | undefined {\n    const candidates =\n      path.length === 0\n        ? [rootSchema]\n        : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n    // `unwrapToDiscriminatedUnion` peels every transparent wrapper\n    // (Optional / Nullable / Default / Readonly / Catch / Effects /\n    // Pipeline / Branded) and descends Intersection sides looking for a\n    // single discriminated union. Ambiguous resolutions (two distinct\n    // DUs both reachable across candidates) bail — the runtime then\n    // falls back to a plain write.\n    let matchedUnion: Schema | undefined\n    for (const candidate of candidates) {\n      const du = services.unwrapToDiscriminatedUnion(candidate)\n      if (du === undefined) continue\n      if (matchedUnion !== undefined && matchedUnion !== du) return undefined\n      matchedUnion = du\n    }\n    if (matchedUnion === undefined) return undefined\n    const discKey = intro.getDiscriminator(matchedUnion)\n    if (discKey === undefined) return undefined\n    const unionOptions = intro.getDiscriminatedOptions(matchedUnion)\n    const literalSet = new Set<unknown>()\n    for (const opt of unionOptions) {\n      const shape = intro.getObjectShape(opt)\n      const litSchema = shape[discKey]\n      if (litSchema === undefined) continue\n      if (intro.kindOf(litSchema) !== 'literal') continue\n      // Multi-value literals (`z.literal(['a','b'])`) register every\n      // member as a selectable variant.\n      for (const v of intro.getLiteralValues(litSchema)) literalSet.add(v)\n    }\n    return {\n      discriminatorKey: discKey,\n      getVariantDefault(value: unknown): unknown {\n        for (const opt of unionOptions) {\n          const shape = intro.getObjectShape(opt)\n          const litSchema = shape[discKey]\n          if (litSchema === undefined) continue\n          if (intro.kindOf(litSchema) !== 'literal') continue\n          const literalValues = intro.getLiteralValues(litSchema)\n          if (literalValues.includes(value)) {\n            return services.deriveDefault(opt, true, maxRecursionDepth, formKey)\n          }\n        }\n        return undefined\n      },\n      isVariantSelected(value: unknown): boolean {\n        return literalSet.has(value)\n      },\n    }\n  }\n\n  const abstractSchema: AbstractSchema<Form, GetValueFormType> = {\n    fingerprint: () => services.fingerprint(rootSchema),\n\n    needsAsyncValidation(): boolean {\n      asyncValidationFlag ??=\n        intro.containsAsyncRefine(rootSchema) || intro.containsAsyncTransform(rootSchema)\n      return asyncValidationFlag\n    },\n\n    hasContainerOrRootRefine(): boolean {\n      containerRefineFlag ??= intro.hasContainerOrRootRefine(rootSchema)\n      return containerRefineFlag\n    },\n\n    getDefaultValues(config: GetDefaultValuesConfig<Form>): DefaultValuesResponse<Form> {\n      return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth)\n    },\n\n    getDefaultAtPath(path) {\n      // Empty path → root default. Reuses the same generator used at\n      // form construction so refines / wrappers behave consistently.\n      if (path.length === 0) {\n        return services.deriveDefault(rootSchema, true, maxRecursionDepth, formKey)\n      }\n      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (first === undefined) return undefined\n      // STRUCTURAL default: peel `.optional()` / `.nullable()` so partial\n      // object writes through optional sub-schemas (`{ profile:\n      // z.object({...}).optional() }`) get the inner shape's defaults\n      // filled in. `.default(x)` is preserved so deriveDefault returns\n      // the explicit default. First candidate matches\n      // `validateAtPath`'s first-success semantic.\n      const peeled = services.unwrapStructuralWrappers(first)\n      return services.deriveDefault(peeled, true, maxRecursionDepth, formKey)\n    },\n\n    getEmptyValueAtPath(path) {\n      // `clear`'s underlying value lookup. Same path-resolution flow as\n      // `getDefaultAtPath` but with `useDefault=false` so `.default(x)`\n      // / `.catch(x)` wrappers are skipped — the walker yields the\n      // inner-schema's empty concrete instead. Structural wrappers\n      // (`.optional()` / `.nullable()`) are NOT peeled: clearing an\n      // `.optional()` slot is legitimately `undefined`, clearing a\n      // `.nullable()` slot is `null`.\n      if (path.length === 0) {\n        return services.deriveDefault(rootSchema, false, maxRecursionDepth, formKey)\n      }\n      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (first === undefined) return undefined\n      return services.deriveDefault(first, false, maxRecursionDepth, formKey)\n    },\n\n    arrayShapeAtPath(path) {\n      if (path.length === 0) return undefined\n      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (first === undefined) return undefined\n      const peeled = services.peelAllWrappers(first)\n      const kind = intro.kindOf(peeled)\n      if (kind === 'tuple') return intro.getTupleItems(peeled).length\n      if (kind === 'array') return null\n      return undefined\n    },\n\n    isFixedObjectAtPath(path) {\n      // Root form is a fixed object — a closed top-level key set.\n      if (path.length === 0) return true\n      const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      // A path the schema doesn't declare is not a fixed object; the\n      // proxy falls back to live keys there.\n      if (resolved.length === 0) return false\n      // The walker returns the NODE itself at a terminal path (it only\n      // splits a union / DU into variants while descending THROUGH one),\n      // so a record / array / set / union / DU surfaces here as its own\n      // single non-object kind. Multiple candidates appear only when the\n      // path descended through a union and landed on a key present in\n      // several variants; that key is a fixed object iff it's an object\n      // in every variant. Peel wrappers first so `z.object().optional()`\n      // still reads as an object.\n      return resolved.every((s) => intro.kindOf(services.peelAllWrappers(s)) === 'object')\n    },\n\n    getSchemasAtPath(path) {\n      // Slim-mode walk: v3 strips refinements / defaults / wrappers off\n      // the root so the yielded sub-schemas reflect the slim shape (the\n      // shape the slim-primitive gate consults). v4 aliases the slim\n      // and unstripped walks to the same call. The factory uses one\n      // hook for both `getSlimPrimitiveTypesAtPath` and\n      // `getSchemasAtPath` — same v3 strip semantic, same v4 alias.\n      const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth)\n      // Empty list is a valid result for paths the schema doesn't\n      // declare — callers (getValue / register / custom introspection)\n      // treat `[]` as \"no sub-schema here\". No warning needed.\n      if (resolved.length === 0) return []\n      return resolved.map((sub) => services.makeSubSchema(sub, formKey, maxRecursionDepth))\n    },\n\n    getSlimPrimitiveTypesAtPath(path): Set<SlimPrimitiveKind> {\n      // Empty path is the root form: always an object.\n      if (path.length === 0) return new Set<SlimPrimitiveKind>(['object'])\n      const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth)\n      // Path doesn't resolve in the schema → no kinds accepted. The\n      // gate's membership check rejects every kind against an empty\n      // set, blocking writes to typo / unknown paths.\n      if (resolved.length === 0) return new Set<SlimPrimitiveKind>()\n      const out = new Set<SlimPrimitiveKind>()\n      for (const candidate of resolved) {\n        for (const k of services.slimPrimitivesOf(candidate, maxRecursionDepth)) {\n          out.add(k)\n        }\n      }\n      return out\n    },\n\n    isLeafAtPath(path): boolean {\n      const cacheKey = canonicalizePath(path).key\n      const cached = leafCache.get(cacheKey)\n      if (cached !== undefined) return cached\n      const prim = this.getSlimPrimitiveTypesAtPath(path)\n      // Empty set → path doesn't exist in schema → descend permissively\n      // (treat as container so schema-named reserved keys at depth 2+\n      // don't shadow). Any container kind in the set → descend.\n      // Otherwise every kind is a primitive → leaf.\n      const isLeaf =\n        prim.size > 0 &&\n        !prim.has('object') &&\n        !prim.has('array') &&\n        !prim.has('map') &&\n        !prim.has('set')\n      leafCache.set(cacheKey, isLeaf)\n      return isLeaf\n    },\n\n    isPreprocessOrCoerceLeaf(path): boolean {\n      // Walks prefixes of `path` looking for either shape adapters\n      // use for schema-side input normalizers (`z.preprocess(...)` or\n      // `z.coerce.X()`). Returns true at such a node OR anywhere\n      // underneath it; the slim-primitive gate uses this to accept\n      // raw consumer writes verbatim throughout that subtree.\n      const cacheKey = canonicalizePath(path).key\n      const cached = preprocessOrCoerceCache.get(cacheKey)\n      if (cached !== undefined) return cached\n      let hit = false\n      for (let i = 0; i <= path.length && !hit; i++) {\n        const prefix = path.slice(0, i)\n        const candidates: Schema[] =\n          prefix.length === 0\n            ? [rootSchema]\n            : services.getNestedSchemasAtPath(rootSchema, prefix, maxRecursionDepth)\n        for (const candidate of candidates) {\n          if (intro.isCoercePrimitive(candidate) || intro.isPreprocessNode(candidate)) {\n            hit = true\n            break\n          }\n        }\n      }\n      preprocessOrCoerceCache.set(cacheKey, hit)\n      return hit\n    },\n\n    isRequiredAtPath(path): boolean {\n      // Root form is structurally required (it's the parsed object).\n      // The required-empty check tracks primitive leaves only, so this\n      // branch is academic for the call sites that matter.\n      if (path.length === 0) return true\n      const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (resolved.length === 0) return false\n      // Every candidate must be required for the path overall to be\n      // required — matches the union \"any-branch-permissive\" rule\n      // when the path traverses a union.\n      return resolved.every((candidate) => services.isLeafRequired(candidate))\n    },\n\n    getFieldMetaAtPath(path): ResolvedFieldMeta {\n      return services.resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth)\n    },\n\n    getUnionDiscriminatorAtPath(path): UnionDiscriminatorContext | undefined {\n      const cacheKey = canonicalizePath(path).key\n      if (discriminatorCache.has(cacheKey)) {\n        return discriminatorCache.get(cacheKey)\n      }\n      const result = computeDiscriminator(path)\n      discriminatorCache.set(cacheKey, result)\n      return result\n    },\n\n    validateAtPath(\n      data: unknown,\n      path: Path | undefined,\n      validateOptions?: ValidateOptions\n    ): ReturnType<AbstractSchema<Form, GetValueFormType>['validateAtPath']> {\n      // Sync attempt: when `options.sync === true`, try the sync parse.\n      // It throws on async refines / pipes / transforms; we catch and\n      // fall through to the async path. Without the flag the adapter\n      // goes straight to async — the historical contract every non-\n      // reshape callsite expects.\n      const trySync = validateOptions?.sync === true\n      if (trySync) {\n        try {\n          return runSync()\n        } catch {\n          // Async-only schema. Fall through to the async path.\n        }\n      }\n      return runAsync()\n\n      function runSync(): ValidationResponse<GetValueFormType> {\n        if (path === undefined) {\n          const result = services.safeParseSync(rootSchema, data)\n          return result.success\n            ? {\n                data: result.data as GetValueFormType,\n                errors: undefined,\n                success: true,\n                formKey,\n              }\n            : {\n                data: undefined,\n                errors: services.issuesToValidationErrors(result.issues, formKey),\n                success: false,\n                formKey,\n              }\n        }\n        const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n        if (resolved.length === 0) return pathNotFound(path)\n        const aggregated: ValidationError[] = []\n        for (const candidate of resolved) {\n          const result = services.safeParseSync(candidate, data)\n          if (result.success) {\n            return {\n              data: result.data as GetValueFormType,\n              errors: undefined,\n              success: true,\n              formKey,\n            }\n          }\n          aggregated.push(...services.issuesToValidationErrors(result.issues, formKey))\n        }\n        return { data: undefined, errors: aggregated, success: false, formKey }\n      }\n\n      async function runAsync(): Promise<ValidationResponse<GetValueFormType>> {\n        if (path === undefined) {\n          let result: Awaited<ReturnType<typeof services.safeParseAsync>>\n          try {\n            result = await services.safeParseAsync(rootSchema, data)\n          } catch (err) {\n            return validatorThrewResponse(err, [])\n          }\n          return result.success\n            ? {\n                data: result.data as GetValueFormType,\n                errors: undefined,\n                success: true,\n                formKey,\n              }\n            : {\n                data: undefined,\n                errors: services.issuesToValidationErrors(result.issues, formKey),\n                success: false,\n                formKey,\n              }\n        }\n        const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n        if (resolved.length === 0) return pathNotFound(path)\n        // Sequential await — parallelising would run every branch's\n        // async side effects on a value only one branch should see.\n        const aggregated: ValidationError[] = []\n        for (const candidate of resolved) {\n          let result: Awaited<ReturnType<typeof services.safeParseAsync>>\n          try {\n            result = await services.safeParseAsync(candidate, data)\n          } catch (err) {\n            return validatorThrewResponse(err, path)\n          }\n          if (result.success) {\n            return {\n              data: result.data as GetValueFormType,\n              errors: undefined,\n              success: true,\n              formKey,\n            }\n          }\n          aggregated.push(...services.issuesToValidationErrors(result.issues, formKey))\n        }\n        return { data: undefined, errors: aggregated, success: false, formKey }\n      }\n\n      // User code inside `z.preprocess` / `.refine` / `.transform` can\n      // throw (sync) or reject (async). Zod does NOT wrap these into\n      // issues; they propagate out of `safeParse` / `safeParseAsync`.\n      // Without this catch the throw bubbles through `validateAtPath`\n      // into the runtime's submit / change-mode pipelines as either a\n      // `submitError` (handleSubmit) or an unhandled rejection\n      // (scheduleFieldValidation), and the consumer would never see a\n      // path-scoped error message. Surface as a `ValidationError` at\n      // the field path so the form's normal error pipeline handles it.\n      function validatorThrewResponse(\n        err: unknown,\n        errPath: Path\n      ): ValidationResponse<GetValueFormType> {\n        const message =\n          err instanceof Error ? err.message : typeof err === 'string' ? err : 'Validator threw'\n        return {\n          data: undefined,\n          errors: [\n            {\n              message,\n              path: [...errPath],\n              formKey,\n              code: AttaformErrorCode.ValidatorThrew,\n            },\n          ],\n          success: false,\n          formKey,\n        }\n      }\n\n      function pathNotFound(p: Path): ValidationResponse<GetValueFormType> {\n        return {\n          data: undefined,\n          errors: [\n            {\n              message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,\n              path: [...p],\n              formKey,\n              code: AttaformErrorCode.PathNotFound,\n            },\n          ],\n          success: false,\n          formKey,\n        }\n      }\n    },\n  }\n\n  return abstractSchema\n}\n","/**\n * Plain-record deep merge for default-value derivation.\n *\n * Leaf semantics (anything not a plain `{}` record is a leaf):\n *   - `undefined` override → no-op (base wins).\n *   - `null` override → replaces base (a deliberate \"clear this field\"\n *     signal that mustn't be merged into).\n *   - Primitives / arrays / Date / Map / class instances → replace\n *     wholesale (e.g. an array override doesn't concat).\n *\n * Recursion only when BOTH sides are plain records. The override-key\n * walk uses `Object.keys` (own enumerable) so a key with an explicit\n * `undefined` value lands here too — the consumer's choice to name the\n * path overrides the base's value, mirroring how an explicit `null`\n * would.\n *\n * Hosted in core so the v3 and v4 default-value walkers single-source\n * the intersection / constraint-merge step. Previously identical\n * `mergeDeep` / `mergeDeepV3` bodies lived per-adapter.\n */\nimport { isPlainRecord } from './path-walker'\nimport { safeAssign, safeOwnRead } from './safe-assign'\n\nexport function mergeDeep(base: unknown, override: unknown): unknown {\n  if (override === undefined) return base\n  if (!isPlainRecord(override)) return override\n  if (!isPlainRecord(base)) return override\n\n  // Object spread carries `base`'s own properties through the\n  // spec's `CreateDataProperty` step, which bypasses the\n  // `__proto__` setter — so a `base` carrying a literal\n  // `__proto__` own property (e.g. from JSON-parsed adapter\n  // defaults that round-tripped through storage) survives the\n  // spread without reassigning the result's prototype. The\n  // per-key reads route through `safeOwnRead` so a\n  // `key === '__proto__'` doesn't resolve via the inherited\n  // accessor on the regular target. The per-key `safeAssign` lands\n  // an `override`'s `__proto__` entry as an own data property via\n  // `Object.defineProperty`; every other key takes the plain\n  // bracket-assign branch. Legitimate consumer-schema fields named\n  // `prototype` / `constructor` / `__proto__` flow through default-\n  // value derivation alongside every other key, and\n  // `Object.prototype` stays untouched.\n  const result: Record<string, unknown> = { ...base }\n  for (const key of Object.keys(override)) {\n    const oVal = safeOwnRead(override, key)\n    const bVal = safeOwnRead(base, key)\n    if (isPlainRecord(oVal) && isPlainRecord(bVal)) {\n      safeAssign(result, key, mergeDeep(bVal, oVal))\n    } else {\n      safeAssign(result, key, oVal)\n    }\n  }\n  return result\n}\n","/**\n * Shared path walker — descends a dotted segment array through a Zod\n * schema tree and returns the sub-schemas reachable at that path.\n *\n * One body, two adapters: v3 and v4 each invoke `walkPathSegments`\n * with their `SchemaIntrospector` instance. Wrapper / container kinds\n * (Optional / Nullable / Default / Readonly / Catch / Pipe / Pipeline /\n * Effects / Branded / Lazy / Intersection / Union / DiscriminatedUnion /\n * Object / Array / Set / Record / Tuple) all dispatch through the\n * introspector accessors, so the walker stays agnostic to per-version\n * `def.*` shape.\n *\n * Semantics (preserved verbatim from the prior per-adapter\n * implementations — characterised by `test/adapters/zod-v3/path-walker.test.ts`\n * and `test/adapters/zod-v4/path-walker.test.ts`):\n *\n *  - Unions return multiple candidates (caller tries each).\n *  - Discriminated unions filter options to those whose shape owns the\n *    next segment (`Object.hasOwn`, NOT `in`, so `Object.prototype` keys\n *    don't leak); fall back to every option when no shape matches\n *    (the segment is the discriminator key itself).\n *  - Object shape access uses `Object.hasOwn` for the same reason: a\n *    bare `shape[head]` would resolve `'toString'` / `'valueOf'` etc.\n *    to the inherited Function and treat it as a schema.\n *  - Transparent wrappers (optional / nullable / default / readonly /\n *    catch / pipe / pipeline / effects / branded) descend without\n *    consuming a segment.\n *  - `lazy` bumps the lazy counter; past the cap the walker returns\n *    `[]` so writes at recursive paths deeper than `maxRecursionDepth`\n *    fall back to a permissive type gate.\n *  - Intersection unions both sides' resolutions — callers try each\n *    candidate, matching parse-time semantics where a value must\n *    satisfy both.\n *  - Leaf kinds (string / number / boolean / literal / enum / etc.)\n *    return `[]` when path remains, so a caller that asked for\n *    `firstName.middle` against a string schema gets an empty\n *    resolution rather than a wrong schema.\n *  - Unsupported kinds (`map` / `symbol` / `function` / `promise`) are\n *    rejected at adapter construction by `assertSupportedKinds`; the\n *    walker's exhaustiveness on those kinds returns `[]` defensively\n *    so a downstream caller that instantiates a sub-schema directly\n *    isn't crashed.\n */\nimport type { SchemaIntrospector } from './abstract-schema-factory'\n\nexport function walkPathSegments<Schema>(\n  schema: Schema,\n  segments: readonly string[],\n  intro: SchemaIntrospector<Schema>,\n  maxDepth: number,\n  lazyDepth: number\n): Schema[] {\n  if (segments.length === 0) return [schema]\n  const [head, ...rest] = segments\n  if (head === undefined) return [schema]\n  const kind = intro.kindOf(schema)\n  switch (kind) {\n    case 'object': {\n      const shape = intro.getObjectShape(schema)\n      if (!Object.hasOwn(shape, head)) return []\n      const next = shape[head]\n      return next === undefined ? [] : walkPathSegments(next, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'array': {\n      const inner = intro.getArrayElement(schema)\n      return inner === undefined ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'set': {\n      // Sets aren't position-indexed; the head segment is a synthetic\n      // indexer (`[...path, 0]`) used to query the element type. Descend\n      // into the value schema and consume the segment.\n      const inner = intro.getSetValueType(schema)\n      return inner === undefined ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'record': {\n      const inner = intro.getRecordValueType(schema)\n      return inner === undefined ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'tuple': {\n      const index = Number(head)\n      if (!Number.isInteger(index)) return []\n      const items = intro.getTupleItems(schema)\n      const item = items[index]\n      return item === undefined ? [] : walkPathSegments(item, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'union':\n      return intro\n        .getUnionOptions(schema)\n        .flatMap((opt) => walkPathSegments(opt, segments, intro, maxDepth, lazyDepth))\n    case 'discriminated-union': {\n      const options = intro.getDiscriminatedOptions(schema)\n      const matching = options.filter((opt) => Object.hasOwn(intro.getObjectShape(opt), head))\n      const candidates = matching.length > 0 ? matching : options\n      return candidates.flatMap((opt) =>\n        walkPathSegments(opt, segments, intro, maxDepth, lazyDepth)\n      )\n    }\n    case 'optional':\n    case 'nullable':\n    case 'default':\n    case 'readonly':\n    case 'catch': {\n      // `catch` peels like a wrapper — descend into the inner schema.\n      // The catch fallback only matters at parse time, not path lookup.\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'pipe': {\n      // v4: `z.pipe(IN, OUT)` / `z.preprocess(fn, inner)` desugars to\n      // pipe-with-transform-on-`in`. Both sides are sub-schemas; the\n      // walker peeks at either, preferring `in`.\n      const inner = intro.unwrapPipeIn(schema) ?? intro.unwrapPipeOut(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'pipeline': {\n      // v3: `z.pipeline(...)` — peel to the input side.\n      const inner = intro.unwrapPipeIn(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'effects': {\n      // v3: `ZodEffects` (refine / transform / preprocess) — peel to\n      // the structural source schema. Path resolution lands on the\n      // inner shape regardless of effect type.\n      const inner = intro.unwrapEffectsSource(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'branded': {\n      // v3: `ZodBranded` — peel to the inner schema. Brands are\n      // compile-time tags with no runtime structural impact.\n      const inner = intro.unwrapBranded(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'lazy': {\n      // Bump the lazy counter. Past the cap, return [] so callers fall\n      // back to permissive behaviour at recursive paths beyond the cap.\n      if (lazyDepth >= maxDepth) return []\n      const inner = intro.unwrapLazy(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth + 1)\n    }\n    case 'intersection': {\n      const left = intro.getIntersectionLeft(schema)\n      const right = intro.getIntersectionRight(schema)\n      const leftResults =\n        left === undefined ? [] : walkPathSegments(left, segments, intro, maxDepth, lazyDepth)\n      const rightResults =\n        right === undefined ? [] : walkPathSegments(right, segments, intro, maxDepth, lazyDepth)\n      return [...leftResults, ...rightResults]\n    }\n    // Leaves — can't descend further. The unsupported kinds (`map` /\n    // `symbol` / `function` / `promise`) are rejected at adapter\n    // construction by `assertSupportedKinds`; falling through to `[]`\n    // keeps the walker defensive in case construction is skipped\n    // (e.g. a downstream test instantiates a sub-schema directly).\n    default:\n      return []\n  }\n}\n","/**\n * Shared default-value walker — derives the initial seed value the\n * runtime places at every leaf of a Zod schema tree.\n *\n * Both v3 and v4 adapters dispatch through this body via their\n * `SchemaIntrospector` instance plus a small `DeriveDefaultContext`\n * carrying per-adapter knobs (`unsupportedKindFallback`, `formKey`).\n * The per-version kind sets — v3's `branded` / `effects` / `pipeline`\n * / `native-enum`, v4's `pipe` / `file` — collapse to distinct cases\n * on the SharedZodKind switch.\n *\n * Semantics (preserved verbatim from the prior per-adapter\n * implementations — characterised by the `default-values`,\n * `get-default-at-path`, and `default-values-parity` test suites in\n * `test/adapters/zod-v{3,4}/`):\n *\n *  - When `useDefault=true`, the walker FIRST peels transparent\n *    wrappers (Optional / Nullable / Readonly / Catch-without-value /\n *    Branded / Effects / Pipeline) looking for an embedded\n *    `ZodDefault` — and returns its value if found. This mirrors v3's\n *    prior `unwrapDefault` chain-peel and CLOSES a v3↔v4 parity gap:\n *    on v4, `z.string().default('x').optional()` previously returned\n *    `undefined` because the outer-kind switch hit `case 'optional'`\n *    first; under the unified walker it returns `'x'`. ZodCatch\n *    precedence is preserved: catch wraps default → catch wins (the\n *    chain-peel returns the catch value at the outer Catch layer).\n *\n *  - Schema-side input normalizers (`z.coerce.X()`,\n *    `z.preprocess(fn, _)`) declare a write boundary the runtime\n *    cannot honestly synthesise a default for. Both early-return\n *    `undefined` so the consumer's `defaultValues` or a later\n *    `setValue` owns what lands in storage.\n *\n *  - Containers recurse into children; leaves return their kind's\n *    canonical empty value (`'' / 0 / 0n / false / new Date(0) /\n *    null / undefined / NaN / first enum or literal value /\n *    [] / new Set() / {}`).\n *\n *  - Unions / DUs use the first option as the seed.\n *\n *  - Intersections merge both sides via the shared `mergeDeep`.\n *\n *  - Lazy bumps a counter; past `maxDepth` returns `undefined` (the\n *    recursive node falls back to consumer-supplied defaultValues).\n *\n *  - Catch with `useDefault=true` returns the catch fallback; with\n *    `useDefault=false` recurses the inner so the leaf's empty value\n *    wins.\n *\n *  - `void` / `any` / `unknown` / `never` / opaque kinds return\n *    `undefined`.\n */\nimport type { SchemaIntrospector } from './abstract-schema-factory'\nimport { mergeDeep } from './merge-deep'\nimport { safeAssign } from './safe-assign'\n\nexport interface DeriveDefaultContext<Schema> {\n  /**\n   * Fallback for a kind the walker doesn't have a case for. Returning\n   * `undefined` is the safe default; v3 wires a `console.warn` here\n   * for visibility into custom-adapter consumers, v4 returns\n   * `undefined` silently (its kind set is exhaustive against\n   * `SchemaIntrospector.kindOf`).\n   */\n  unsupportedKindFallback(schema: Schema, kind: string): unknown\n  /**\n   * How `case 'catch'` resolves when `useDefault=false`. The two\n   * adapters chose differently and pinned the choice with tests:\n   *\n   *   - v3 wires `'preserveCatch'`: a `.catch(v)` wrapper always\n   *     surfaces its fallback `v`, regardless of `useDefault`. Rationale:\n   *     the catch is an emphatic consumer statement that should\n   *     resurface across submit failures, hydration, and history.\n   *   - v4 wires `'recurseInner'`: `useDefault=false` means \"show the\n   *     leaf empty\", and `.catch()` is a default-like wrapper that gets\n   *     skipped. The walker recurses into the inner so the leaf's\n   *     bare empty value (`'' / 0 / false / ...`) wins.\n   *\n   * On `useDefault=true` the chain-peel at the top of the walker\n   * already finds and returns the catch fallback at either adapter,\n   * so this knob only takes effect on `useDefault=false`.\n   */\n  catchOnUseDefaultFalse: 'preserveCatch' | 'recurseInner'\n}\n\n/**\n * Sentinel for the chain-peel-default helper. Distinct from\n * `undefined`, which IS a legal returned default value (e.g.\n * `z.string().default(undefined)`).\n */\nexport const NO_EMBEDDED_DEFAULT = Symbol('atta:no-embedded-default')\n\n/**\n * Peel transparent wrappers looking for an embedded `ZodDefault` (or\n * a `ZodCatch` with a fallback value, which takes precedence over a\n * nested default at the same depth). Returns the resolved value or\n * the sentinel `NO_EMBEDDED_DEFAULT` if none found.\n *\n * Mirrors v3's prior `unwrapDefault` loop and now applies on v4 too.\n * v4's kind set means `branded` / `effects` / `pipeline` peels\n * silently no-op (the introspector stubs return undefined).\n *\n * Bounded loop (32 iterations) matches the prior cap and acts as a\n * runaway guard for pathological wrapper stacks / self-referential\n * lazy loops resolved before their inner is constructed.\n *\n * Exported so the v3 strict-mode fix-up loop in `zod-v3/index.ts`\n * (the `runStrictGetDefaultsV3` validate-then-fix path) can reuse\n * it for the issue-driven default-resolution step.\n */\nexport function peelEmbeddedDefault<Schema>(\n  schema: Schema,\n  intro: SchemaIntrospector<Schema>\n): unknown {\n  let current: Schema | undefined = schema\n  for (let i = 0; i < 32; i++) {\n    if (current === undefined) return NO_EMBEDDED_DEFAULT\n    const k = intro.kindOf(current)\n    if (k === 'default') return intro.getDefaultValue(current)\n    if (k === 'catch') {\n      if (intro.hasCatchValue(current)) return intro.getCatchDefault(current)\n      current = intro.unwrapInner(current)\n      continue\n    }\n    if (k === 'optional' || k === 'nullable' || k === 'readonly') {\n      current = intro.unwrapInner(current)\n      continue\n    }\n    if (k === 'branded') {\n      current = intro.unwrapBranded(current)\n      continue\n    }\n    if (k === 'effects') {\n      current = intro.unwrapEffectsSource(current)\n      continue\n    }\n    if (k === 'pipeline') {\n      current = intro.unwrapPipeIn(current)\n      continue\n    }\n    return NO_EMBEDDED_DEFAULT\n  }\n  return NO_EMBEDDED_DEFAULT\n}\n\n/**\n * Walk transparent wrappers looking for a `ZodDefault` in the chain.\n * Used by the preprocess branch to decide whether the inner has a\n * consumer-declared default the adapter should honor (recurse the\n * inner) or whether the slot is fully consumer-owned (`undefined`).\n *\n * Distinct from `peelEmbeddedDefault` in that the result is a\n * boolean — the caller decides what to do with it, not the value\n * itself.\n */\nfunction hasDeclaredDefaultInChain<Schema>(\n  schema: Schema,\n  intro: SchemaIntrospector<Schema>\n): boolean {\n  let current: Schema | undefined = schema\n  for (let i = 0; i < 32; i++) {\n    if (current === undefined) return false\n    const k = intro.kindOf(current)\n    if (k === 'default') return true\n    if (k === 'optional' || k === 'nullable' || k === 'readonly' || k === 'catch') {\n      current = intro.unwrapInner(current)\n      continue\n    }\n    return false\n  }\n  return false\n}\n\nexport function deriveDefaultWalk<Schema>(\n  schema: Schema,\n  useDefault: boolean,\n  intro: SchemaIntrospector<Schema>,\n  maxDepth: number,\n  ctx: DeriveDefaultContext<Schema>,\n  lazyDepth = 0\n): unknown {\n  // Pre-check the wrapper chain for an embedded ZodDefault / ZodCatch\n  // fallback. Returning it here is what makes\n  // `z.string().default('x').optional()` resolve to 'x' rather than\n  // undefined. Closes the v3↔v4 parity gap (v4 previously stopped at\n  // the outer Optional and returned undefined).\n  if (useDefault) {\n    const peeled = peelEmbeddedDefault(schema, intro)\n    if (peeled !== NO_EMBEDDED_DEFAULT) return peeled\n  }\n\n  // `z.coerce.X()` flags the wrapped primitive's def with `coerce:\n  // true`; the consumer's pre-conversion input shape is unknown so\n  // synthesising the primitive's slim concrete (`''` / `0` / etc.)\n  // would claim a value the consumer never supplied. Leave the slot\n  // `undefined` so `defaultValues` or a later `setValue` owns what\n  // lands in storage. A consumer-declared `.default(x)` on the coerce\n  // primitive was already honored by the chain-peel above.\n  if (intro.isCoercePrimitive(schema)) return undefined\n\n  const kind = intro.kindOf(schema)\n  switch (kind) {\n    case 'object': {\n      const shape = intro.getObjectShape(schema)\n      // Default container carries `Object.prototype`. The default\n      // flows directly into `form.values`; matching the rest of the\n      // value-write pipeline keeps the initial tree consistent with\n      // what `setAtPath` and `mergeDeep` produce. Schema field names\n      // can legitimately include `__proto__` (an architecture firm\n      // tracking prototypes; a Zod schema with `z.object({ __proto__: … })`);\n      // `safeAssign` lands such a key as an own data property.\n      const out: Record<string, unknown> = {}\n      for (const [key, subSchema] of Object.entries(shape)) {\n        safeAssign(\n          out,\n          key,\n          deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, ctx, lazyDepth)\n        )\n      }\n      return out\n    }\n    case 'array':\n      return []\n    case 'set':\n      return new Set()\n    case 'record':\n      return {}\n    case 'tuple': {\n      const items = intro.getTupleItems(schema)\n      return items.map((item) =>\n        deriveDefaultWalk(item, useDefault, intro, maxDepth, ctx, lazyDepth)\n      )\n    }\n    case 'union': {\n      const options = intro.getUnionOptions(schema)\n      const first = options[0]\n      return first === undefined\n        ? undefined\n        : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'discriminated-union': {\n      const options = intro.getDiscriminatedOptions(schema)\n      const first = options[0]\n      return first === undefined\n        ? undefined\n        : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'optional':\n      return undefined\n    case 'nullable':\n      return null\n    case 'default': {\n      // `useDefault=false` path: the chain-peel above is suppressed,\n      // so a direct ZodDefault still lands here — recurse the inner\n      // to produce the leaf's bare empty value (the explicit default\n      // is the consumer's \"starting state\" intent, not the leaf's\n      // type-honest blank).\n      if (useDefault) return intro.getDefaultValue(schema)\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'readonly':\n    case 'branded': {\n      // Readonly: v3 + v4 transparent wrapper.\n      // Branded: v3-only — `_def.type` carrier.\n      const inner = kind === 'branded' ? intro.unwrapBranded(schema) : intro.unwrapInner(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'effects': {\n      // v3-only. `ZodEffects` wraps refine / transform / preprocess.\n      // For `preprocess`: the input side is the user-supplied fn, so\n      // the slot has no canonical empty value the adapter can honestly\n      // synthesise. If the inner declares a default, recurse (the\n      // chain-peel finds it for useDefault=true; under useDefault=false\n      // we recurse to the leaf's empty). Otherwise return undefined so\n      // `defaultValues` or a later setValue owns the slot.\n      // For `refinement` / `transform`: recurse the structural source.\n      const inner = intro.unwrapEffectsSource(schema)\n      if (intro.isPreprocessNode(schema)) {\n        if (inner !== undefined && hasDeclaredDefaultInChain(inner, intro)) {\n          return deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n        }\n        return undefined\n      }\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'pipeline': {\n      // v3-only. The pre-transform default is the input schema's\n      // natural default.\n      const inner = intro.unwrapPipeIn(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'pipe': {\n      // v4-only. Two sub-cases mirroring v3's preprocess branch:\n      //\n      //   - `z.preprocess(fn, inner)` — `in` is a ZodTransform. The\n      //     input shape is unknown until the consumer writes. If the\n      //     inner carries a declared default, recurse; otherwise\n      //     return undefined.\n      //   - `.transform(fn)` (transform on output) / generic / codec\n      //     pipes — the input side IS the source schema; peel to it.\n      const inn = intro.unwrapPipeIn(schema)\n      if (inn !== undefined && intro.kindOf(inn) === 'transform') {\n        const out = intro.unwrapPipeOut(schema)\n        if (out !== undefined && hasDeclaredDefaultInChain(out, intro)) {\n          return deriveDefaultWalk(out, useDefault, intro, maxDepth, ctx, lazyDepth)\n        }\n        return undefined\n      }\n      const out = intro.unwrapPipeOut(schema)\n      const real =\n        inn !== undefined && intro.kindOf(inn) !== 'transform'\n          ? inn\n          : out !== undefined && intro.kindOf(out) !== 'transform'\n            ? out\n            : (inn ?? out)\n      return real === undefined\n        ? undefined\n        : deriveDefaultWalk(real, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'string':\n      return ''\n    case 'number':\n      return 0\n    case 'bigint':\n      // z.bigint() strictly rejects numbers; the default must be a\n      // bigint literal. Using `0` here would fail the schema's own\n      // validation during default-values derivation.\n      return 0n\n    case 'boolean':\n      return false\n    case 'date':\n      return new Date(0)\n    case 'null':\n      return null\n    case 'undefined':\n      return undefined\n    case 'enum': {\n      const values = intro.getEnumValues(schema)\n      return values[0]\n    }\n    case 'native-enum': {\n      // v3-only. Numeric enums get reverse-mapped\n      // (`enum E { A }` → `{ A: 0, '0': 'A' }`); the valid runtime\n      // members are the keys whose VALUE'S key isn't itself a number.\n      // String enums have no reverse mapping, so every key is valid.\n      // Pick the first valid value.\n      const values = intro.getNativeEnumValues(schema)\n      if (values === undefined) return undefined\n      const validKeys = Object.keys(values).filter(\n        (k) => typeof values[values[k] as string] !== 'number'\n      )\n      if (validKeys.length === 0) return undefined\n      const first = validKeys[0]\n      return first === undefined ? undefined : values[first]\n    }\n    case 'literal': {\n      const values = intro.getLiteralValues(schema)\n      return values[0]\n    }\n    case 'nan':\n      return NaN\n    case 'lazy': {\n      // Bump the lazy counter ONLY here — structural recursion doesn't\n      // accumulate. Past the cap, return undefined so a recursive node\n      // ends in a non-fatal blank; `defaultValues` (consumer-supplied)\n      // is the authority for what the seed should be at the recursive\n      // boundary anyway.\n      if (lazyDepth >= maxDepth) return undefined\n      let inner: Schema | undefined\n      try {\n        inner = intro.unwrapLazy(schema)\n      } catch {\n        return undefined\n      }\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth + 1)\n    }\n    case 'intersection': {\n      const left = intro.getIntersectionLeft(schema)\n      const right = intro.getIntersectionRight(schema)\n      const l =\n        left === undefined\n          ? undefined\n          : deriveDefaultWalk(left, useDefault, intro, maxDepth, ctx, lazyDepth)\n      const r =\n        right === undefined\n          ? undefined\n          : deriveDefaultWalk(right, useDefault, intro, maxDepth, ctx, lazyDepth)\n      // `mergeDeep` prefers `right` where both sides carry a plain-\n      // record value at a key, and returns `right` wholesale when\n      // either side is a leaf. Matches parse-time semantics: an\n      // intersection of `{ a }` and `{ b }` must satisfy both, so the\n      // merged shape carries both keys' defaults.\n      return mergeDeep(l, r)\n    }\n    case 'catch': {\n      // `useDefault=true` was already caught by `peelEmbeddedDefault`\n      // at the top of the walker; reaching this branch implies\n      // `useDefault=false`. The two adapters chose different\n      // semantics here and pinned the choice with tests (see the\n      // `catchOnUseDefaultFalse` docblock on `DeriveDefaultContext`).\n      if (useDefault) return intro.getCatchDefault(schema)\n      if (ctx.catchOnUseDefaultFalse === 'preserveCatch' && intro.hasCatchValue(schema)) {\n        return intro.getCatchDefault(schema)\n      }\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'file':\n      // `z.file()` has no canonical \"empty file\" — the user picks one\n      // through the directive's change handler. `null` is the storage\n      // blank value the directive canonicalises to on register / clear;\n      // emitting `null` here keeps `getEmptyValueAtPath` aligned with\n      // what `form.clear(path)` writes.\n      return null\n    case 'any':\n    case 'unknown':\n    case 'void':\n    case 'never':\n    case 'promise':\n    case 'custom':\n    case 'template-literal':\n    case 'transform':\n    case 'map':\n    case 'symbol':\n    case 'function':\n      // `promise` / `custom` / `template-literal` / `map` / `symbol` /\n      // `function` are rejected by `assertSupportedKinds` at adapter\n      // construction, so these branches are unreachable through the\n      // public surface. `transform` is the input side of a\n      // `z.preprocess(fn, inner)` and has no own default — callers\n      // walk to `inner` via the surrounding pipe / effects. Kept for\n      // exhaustive switch safety.\n      return undefined\n    default:\n      return ctx.unsupportedKindFallback(schema, kind)\n  }\n}\n","/**\n * Shared field-metadata storage. Both Zod adapters (v3 and v4) and the\n * unified `attaform/zod` entry read from the same `WeakMap`s so a\n * payload written via any entry's `withMeta` / `fieldMeta.add` is\n * visible to whichever adapter actually runs at lookup time.\n *\n * No `zod` runtime import — pure JavaScript primitives. The previous\n * v4 adapter built `fieldMeta` via `z.registry<FieldMetaPayload>()`,\n * which left a `z.registry` namespace reference reachable from\n * `attaform/zod`'s module graph; bundlers analysing a `zod@^3` consumer\n * resolved that against zod 3's exports map (no `registry` export) and\n * emitted an `IMPORT_IS_UNDEFINED` warning. Lifting storage here drops\n * that reference entirely so the unified entry behaves cleanly on any\n * Zod major.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` still\n * works against this shim — Zod 4's `.register()` only calls\n * `registry.add(this, payload)` and returns the schema; structural\n * matching is enough.\n *\n * Two parallel maps:\n * - `store` — last-write-wins single payload per schema reference.\n *   Backs `fieldMeta.get(schema)` and the adapter's\n *   `getFieldMetaAtPath` single-payload fallback.\n * - `lists` — every registration in order, per schema reference.\n *   Backs the v4 adapter's path-walker disambiguation when the same\n *   schema instance is bound at multiple form paths.\n */\n\nimport type { FieldMetaPayload } from './field-meta'\n\n/**\n * Minimal registry shape the shared store satisfies — `.add` / `.get`\n * / `.has` / `.remove`. Cast to `z.$ZodRegistry<FieldMetaPayload>` at\n * the v4 adapter's re-export so the native `schema.register(fieldMeta,\n * payload)` chain type-checks; the v3 adapter exports it as its own\n * registry-shaped surface.\n */\nexport type FieldMetaStore = {\n  add(schema: object, payload: FieldMetaPayload): FieldMetaStore\n  get(schema: object): FieldMetaPayload | undefined\n  has(schema: object): boolean\n  remove(schema: object): FieldMetaStore\n}\n\nconst store = new WeakMap<object, FieldMetaPayload>()\nconst lists = new WeakMap<object, FieldMetaPayload[]>()\n\nconst registry: FieldMetaStore = {\n  add(schema, payload) {\n    store.set(schema, payload)\n    const list = lists.get(schema) ?? []\n    list.push(payload)\n    lists.set(schema, list)\n    return registry\n  },\n  get(schema) {\n    return store.get(schema)\n  },\n  has(schema) {\n    return store.has(schema)\n  },\n  remove(schema) {\n    store.delete(schema)\n    lists.delete(schema)\n    return registry\n  },\n}\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of Zod major. One module-scoped\n * instance — every adapter entry re-exports this same object so\n * writes from one entry are visible at lookup through any other.\n */\nexport const fieldMetaStore: FieldMetaStore = registry\n\n/**\n * Last-write-wins payload lookup for a schema reference. Returns\n * `undefined` if nothing has been registered.\n */\nexport function getFieldMetaForSchema(schema: object): FieldMetaPayload | undefined {\n  return store.get(schema)\n}\n\n/**\n * Read every payload registered against `schema` in registration\n * order. Empty list when nothing has been registered. Used by the v4\n * adapter's path-resolver to disambiguate per occurrence when one\n * schema instance is bound at multiple form paths.\n */\nexport function getFieldMetaListForSchema(schema: object): readonly FieldMetaPayload[] {\n  return lists.get(schema) ?? []\n}\n","/**\n * Shared slim-primitive walker — returns the set of\n * `SlimPrimitiveKind`s a schema accepts at write time. Wrappers\n * (Optional / Nullable / Default / Readonly / Catch / Pipe /\n * Pipeline / Effects / Branded / Lazy) are peeled; refinement-level\n * constraints (`.email()`, `.min(N)`, enum membership, literal\n * equality, regex) are ignored.\n *\n * Both v3 and v4 adapters dispatch through this body via their\n * `SchemaIntrospector` instance. Their per-version kind sets — v3's\n * `branded` / `effects` / `pipeline` / `native-enum`, v4's `pipe` /\n * `file` — collapse to distinct cases on the SharedZodKind switch;\n * each adapter's `kindOf` returns only the kinds it knows.\n *\n * Semantics (preserved verbatim from the prior per-adapter\n * implementations — characterised by `test/adapters/zod-v{3,4}/\n * slim-primitives.test.ts`):\n *\n *  - Leaves (string / number / boolean / bigint / date / null /\n *    undefined / void / nan) map to their kind singleton.\n *  - Enum walks values, categorising each by typeof (string / number\n *    members register their respective kinds). Empty enum falls back\n *    to string.\n *  - Literal walks values through the shared `slimKindOf` to map each\n *    value to a kind. Multi-value literals (`z.literal(['a', 1])`)\n *    register both.\n *  - Object / record → object; array / tuple → array; set → set;\n *    file → file + null (the directive's \"no file selected\"\n *    sentinel — v4 only).\n *  - Optional adds 'undefined' to the inner set; nullable adds 'null'.\n *  - Default / readonly / catch / branded peel transparently.\n *  - Pipe (v4) consults both `in` and `out`: if `in` is a transform,\n *    use `out` (the structural side of a preprocess); else prefer\n *    `in` (the source schema). Pipeline (v3) takes the `in` side.\n *  - Effects (v3) peels to the structural source.\n *  - Lazy bumps the depth counter; past the cap returns `permissive`\n *    so recursive paths beyond the cap aren't false-rejected.\n *  - Union / discriminated-union: union the option sets.\n *  - Intersection: intersect both sides (must satisfy both at parse\n *    time).\n *  - Native-enum (v3) walks values, categorising by typeof.\n *  - Never returns empty; any / unknown / unrecognised return\n *    permissive.\n */\nimport type { SchemaIntrospector } from './abstract-schema-factory'\nimport { slimKindOf } from './slim-primitive-gate'\nimport type { SlimPrimitiveKind } from '../types/types-api'\n\n// The slim-primitive permissive set — kinds the gate accepts when the\n// walker can't characterise a schema. Identical between v3 and v4 by\n// design; hosted in core for single-source-of-truth.\nexport const PERMISSIVE_SLIM_KINDS: ReadonlySet<SlimPrimitiveKind> =\n  /* @__PURE__ */ new Set<SlimPrimitiveKind>([\n    'string',\n    'number',\n    'boolean',\n    'bigint',\n    'date',\n    'null',\n    'undefined',\n    'object',\n    'array',\n    'symbol',\n    'function',\n    'map',\n    'set',\n    'file',\n  ])\n\n// Module-level frozen singletons for the leaf branches. Returning a\n// shared instance instead of `new Set([…])` per call cuts a hot\n// allocation when slim-primitives is reached through wrappers and\n// collapses the inline literal Set constructions into shared\n// references for a small bundle-size win. The walker returns\n// `ReadonlySet`; callers that need to mutate (optional / nullable /\n// union branches, and the public boundary) clone first.\nconst KIND_STRING: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['string'])\nconst KIND_NUMBER: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['number'])\nconst KIND_BOOLEAN: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['boolean'])\nconst KIND_BIGINT: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['bigint'])\nconst KIND_DATE: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['date'])\nconst KIND_NULL: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['null'])\nconst KIND_UNDEFINED: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['undefined'])\nconst KIND_OBJECT: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['object'])\nconst KIND_ARRAY: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['array'])\nconst KIND_SET: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['set'])\nconst KIND_FILE: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['file', 'null'])\nconst EMPTY_KINDS: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set()\n\nexport function slimPrimitivesWalk<Schema>(\n  schema: Schema,\n  intro: SchemaIntrospector<Schema>,\n  maxDepth: number,\n  lazyDepth = 0\n): ReadonlySet<SlimPrimitiveKind> {\n  const kind = intro.kindOf(schema)\n  switch (kind) {\n    case 'string':\n      return KIND_STRING\n    case 'number':\n    case 'nan':\n      return KIND_NUMBER\n    case 'boolean':\n      return KIND_BOOLEAN\n    case 'bigint':\n      return KIND_BIGINT\n    case 'date':\n      return KIND_DATE\n    case 'file':\n      // `z.file()` accepts `File` instances at write time. `null` is\n      // also accepted at the slim-primitive level so the directive's\n      // canonical blank value (the \"no file selected\" sentinel) lands\n      // even on required-file schemas — the blank-path channel + the\n      // derived \"No value supplied\" error already gates submission, so\n      // permitting `null` storage here doesn't loosen schema enforcement.\n      return KIND_FILE\n    case 'null':\n      return KIND_NULL\n    case 'undefined':\n    case 'void':\n      return KIND_UNDEFINED\n    case 'enum': {\n      const values = intro.getEnumValues(schema)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const v of values) {\n        if (typeof v === 'string') out.add('string')\n        else if (typeof v === 'number') out.add('number')\n      }\n      return out.size === 0 ? KIND_STRING : out\n    }\n    case 'native-enum': {\n      // v3 only — `z.nativeEnum(E)` exposes the reverse-mapped TS enum\n      // object on `_def.values`. Categorise each member by typeof.\n      // Numeric enums also include reverse-mapped string keys whose\n      // value is a number; both string and number kinds get registered.\n      const values = intro.getNativeEnumValues(schema)\n      if (values === undefined) return KIND_STRING\n      const out = new Set<SlimPrimitiveKind>()\n      for (const v of Object.values(values)) {\n        if (typeof v === 'string') out.add('string')\n        else if (typeof v === 'number') out.add('number')\n      }\n      return out.size === 0 ? KIND_STRING : out\n    }\n    case 'literal': {\n      const values = intro.getLiteralValues(schema)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const v of values) out.add(slimKindOf(v))\n      return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out\n    }\n    case 'object':\n    case 'record':\n      return KIND_OBJECT\n    case 'array':\n    case 'tuple':\n      return KIND_ARRAY\n    case 'set':\n      return KIND_SET\n    case 'optional': {\n      const inner = intro.unwrapInner(schema)\n      const innerSet =\n        inner === undefined ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n      const out = new Set<SlimPrimitiveKind>(innerSet)\n      out.add('undefined')\n      return out\n    }\n    case 'nullable': {\n      const inner = intro.unwrapInner(schema)\n      const innerSet =\n        inner === undefined ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n      const out = new Set<SlimPrimitiveKind>(innerSet)\n      out.add('null')\n      return out\n    }\n    case 'default':\n    case 'readonly':\n    case 'catch': {\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'branded': {\n      // v3-only. Brand wrappers carry their inner on `_def.type`.\n      const inner = intro.unwrapBranded(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'effects': {\n      // v3-only. ZodEffects wraps refines / transforms / preprocess;\n      // for slim-primitive purposes the structural source is the\n      // pre-transform shape (consumers write to that shape).\n      const inner = intro.unwrapEffectsSource(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'pipeline': {\n      // v3-only. Take the input side.\n      const inner = intro.unwrapPipeIn(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'pipe': {\n      // v4-only. `z.preprocess(fn, inner)` and `z.coerce.X()`\n      // (pipe-with-transform-on-input) and `inner.transform(fn)`\n      // (transform-on-output) all serialise as ZodPipe, but the\n      // \"storage shape\" lives on opposite sides. For preprocess /\n      // coerce, the input side IS the transform (shapeless,\n      // PERMISSIVE) and the inner schema sits on the output. For\n      // `.transform`, the input side is the source schema. Pick the\n      // non-transform side so `isLeafAtPath` and the directive coerce\n      // target both resolve against a real shape.\n      const pipeIn = intro.unwrapPipeIn(schema)\n      const pipeOut = intro.unwrapPipeOut(schema)\n      const inner =\n        pipeIn !== undefined && intro.kindOf(pipeIn) === 'transform' ? pipeOut : (pipeIn ?? pipeOut)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'lazy': {\n      // Bump on lazy crossing only; past the cap, fall back to\n      // permissive so recursive paths beyond the cap aren't gated.\n      if (lazyDepth >= maxDepth) return PERMISSIVE_SLIM_KINDS\n      const inner = intro.unwrapLazy(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth + 1)\n    }\n    case 'union':\n    case 'discriminated-union': {\n      // Both adapters store DU options on `def.options` too, so\n      // `getUnionOptions` works for either kind.\n      const options = intro.getUnionOptions(schema)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const opt of options) {\n        for (const k of slimPrimitivesWalk(opt, intro, maxDepth, lazyDepth)) out.add(k)\n      }\n      return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out\n    }\n    case 'intersection': {\n      const left = intro.getIntersectionLeft(schema)\n      const right = intro.getIntersectionRight(schema)\n      const leftSet =\n        left === undefined\n          ? PERMISSIVE_SLIM_KINDS\n          : slimPrimitivesWalk(left, intro, maxDepth, lazyDepth)\n      const rightSet =\n        right === undefined\n          ? PERMISSIVE_SLIM_KINDS\n          : slimPrimitivesWalk(right, intro, maxDepth, lazyDepth)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const k of leftSet) if (rightSet.has(k)) out.add(k)\n      return out\n    }\n    case 'never':\n      return EMPTY_KINDS\n    case 'any':\n    case 'unknown':\n      return PERMISSIVE_SLIM_KINDS\n    // Opaque / unsupported kinds: be permissive so legitimate writes\n    // aren't false-rejected. The unsupported kinds (`map` / `symbol` /\n    // `function` / `promise`) are rejected at adapter construction by\n    // `assertSupportedKinds`; this fallthrough keeps the walker\n    // defensive in case construction is skipped.\n    default:\n      return PERMISSIVE_SLIM_KINDS\n  }\n}\n","import type { SchemaIntrospector } from './abstract-schema-factory'\nimport type { FieldMetaPayload } from './field-meta'\nimport { canonicalizePath, type Path, type PathKey } from './paths'\n\n/**\n * Version-specific primitives the field-meta walk consumes. Both\n * adapters already expose all three:\n *\n *   - `intro` — the adapter's `SchemaIntrospector` (kind discriminant +\n *     structural accessors + wrapper unwraps). The walk dispatches on\n *     `intro.kindOf`, which differs per version (v3 returns\n *     `effects` / `pipeline` / `branded`; v4 returns `pipe` / `transform`),\n *     so the switch below handles both vocabularies.\n *   - `peelAllWrappers` — the catch-peeling structural peel\n *     (`peelAllV3Wrappers` on v3, `peelAllWrappers` on v4). Used to reach\n *     a registration that sits on the inner before wrapping, e.g.\n *     `withMeta(z.string(), {...}).optional()`.\n *   - `getFieldMetaList` — reads the adapter's per-instance registration\n *     list. The registry is adapter-local (keyed by schema instance), so\n *     it can't be a shared import.\n *\n * All required: the walk has no sensible default for any of them.\n */\nexport interface FieldMetaWalkServices<Schema> {\n  intro: SchemaIntrospector<Schema>\n  peelAllWrappers: (schema: Schema) => Schema\n  getFieldMetaList: (schema: Schema) => readonly FieldMetaPayload[]\n}\n\n// Per-rootSchema cache of path -> payload maps, shared across adapters.\n// Build is a single tree-walk; lookups are O(1) thereafter. Keyed on the\n// root schema instance (a given instance belongs to exactly one Zod\n// version, so v3 and v4 roots never collide) so entries GC with the form.\nconst pathMetaCache = new WeakMap<object, Map<PathKey, FieldMetaPayload>>()\n\n/**\n * Build the path -> field-meta-payload map for `rootSchema` by walking\n * the schema tree once. Both adapters' `resolveFieldMetaAtPath` delegate\n * here so the path-keyed disambiguation of shared schemas registered at\n * multiple paths lives in one place.\n *\n * After the walk, \"surplus\" registrations get absorbed into the schema's\n * last-visited path — covers chains like\n * `withMeta(s, {label}).register(fieldMeta, {desc})` where one path\n * consumes list[0] and list[1] would otherwise go unread.\n */\nexport function getFieldMetaPathMap<Schema extends object>(\n  rootSchema: Schema,\n  services: FieldMetaWalkServices<Schema>\n): Map<PathKey, FieldMetaPayload> {\n  const cached = pathMetaCache.get(rootSchema)\n  if (cached !== undefined) return cached\n  const map = new Map<PathKey, FieldMetaPayload>()\n  const counters = new Map<Schema, number>()\n  const lastPathPerSchema = new Map<Schema, PathKey>()\n  const inProgress = new WeakSet<object>()\n  walkForMeta(rootSchema, [], map, counters, lastPathPerSchema, inProgress, services)\n  for (const [schema, lastPath] of lastPathPerSchema) {\n    const list = services.getFieldMetaList(schema)\n    const consumed = counters.get(schema) ?? 0\n    if (list.length <= consumed) continue\n    const surplus = list\n      .slice(consumed)\n      .reduce<FieldMetaPayload>((acc, p) => ({ ...acc, ...p }), {})\n    const existing = map.get(lastPath) ?? {}\n    map.set(lastPath, { ...existing, ...surplus })\n  }\n  pathMetaCache.set(rootSchema, map)\n  return map\n}\n\n/**\n * Pull a payload off `schema`'s registration list, counter-indexed so a\n * schema registered at multiple paths pairs each visit with the next\n * payload in declaration order. Clamp to the last entry — schemas reused\n * MORE times than they're registered (e.g. an array element registered\n * once, visited per-index) all share the single registration.\n */\nfunction consumePayload<Schema>(\n  schema: Schema,\n  counters: Map<Schema, number>,\n  getFieldMetaList: (schema: Schema) => readonly FieldMetaPayload[]\n): FieldMetaPayload | undefined {\n  const list = getFieldMetaList(schema)\n  if (list.length === 0) return undefined\n  const idx = counters.get(schema) ?? 0\n  const payload = list[Math.min(idx, list.length - 1)]\n  counters.set(schema, idx + 1)\n  return payload\n}\n\n/**\n * Walk the schema tree from `schema`, emitting a payload for each path\n * that has registered metadata. Visits the schema first (terminal-position\n * registration), then the peeled inner if different (inner-then-wrap\n * registration). At each point the FIRST list-payload found wins for that\n * path. `inProgress` bounds recursive `z.lazy(...)` cycles.\n */\nfunction walkForMeta<Schema extends object>(\n  schema: Schema,\n  path: Path,\n  map: Map<PathKey, FieldMetaPayload>,\n  counters: Map<Schema, number>,\n  lastPathPerSchema: Map<Schema, PathKey>,\n  inProgress: WeakSet<object>,\n  services: FieldMetaWalkServices<Schema>\n): void {\n  if (inProgress.has(schema)) return\n  inProgress.add(schema)\n  try {\n    const { intro, peelAllWrappers, getFieldMetaList } = services\n    const pathKey = canonicalizePath(path).key\n    if (!map.has(pathKey)) {\n      const payload = consumePayload(schema, counters, getFieldMetaList)\n      if (payload !== undefined) {\n        map.set(pathKey, payload)\n        lastPathPerSchema.set(schema, pathKey)\n      }\n    }\n    const peeled = peelAllWrappers(schema)\n    if (peeled !== schema && !map.has(pathKey)) {\n      const payload = consumePayload(peeled, counters, getFieldMetaList)\n      if (payload !== undefined) {\n        map.set(pathKey, payload)\n        lastPathPerSchema.set(peeled, pathKey)\n      }\n    }\n    // Descend by kind. The switch handles both adapters' kind\n    // vocabularies; unhandled and leaf kinds fall through to `default`\n    // and stop (their own metadata was captured above).\n    const kind = intro.kindOf(schema)\n    switch (kind) {\n      case 'object': {\n        for (const [key, child] of Object.entries(intro.getObjectShape(schema))) {\n          walkForMeta(child, [...path, key], map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'array': {\n        const inner = intro.getArrayElement(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'tuple': {\n        const items = intro.getTupleItems(schema)\n        for (let i = 0; i < items.length; i++) {\n          const item = items[i]\n          if (item !== undefined)\n            walkForMeta(item, [...path, i], map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'set': {\n        const inner = intro.getSetValueType(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'record': {\n        const inner = intro.getRecordValueType(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, [...path, '*'], map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'union': {\n        for (const opt of intro.getUnionOptions(schema)) {\n          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'discriminated-union': {\n        for (const opt of intro.getDiscriminatedOptions(schema)) {\n          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'optional':\n      case 'nullable':\n      case 'default':\n      case 'readonly':\n      case 'catch': {\n        const inner = intro.unwrapInner(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'pipe':\n      case 'pipeline': {\n        const inner = intro.unwrapPipeIn(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'effects': {\n        const inner = intro.unwrapEffectsSource(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'branded': {\n        const inner = intro.unwrapBranded(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'lazy': {\n        // A throwing lazy getter (a recursive cycle resolved before its\n        // target is constructed) must not crash form setup. v3's\n        // unwrapLazy already swallows it; the try guards v4's, which\n        // rethrows. Either way the inProgress check bounds a true cycle.\n        try {\n          const inner = intro.unwrapLazy(schema)\n          if (inner !== undefined)\n            walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        } catch {\n          // Treat an unresolvable lazy as a leaf.\n        }\n        return\n      }\n      case 'intersection': {\n        const left = intro.getIntersectionLeft(schema)\n        const right = intro.getIntersectionRight(schema)\n        if (left !== undefined)\n          walkForMeta(left, path, map, counters, lastPathPerSchema, inProgress, services)\n        if (right !== undefined)\n          walkForMeta(right, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      default:\n        return\n    }\n  } finally {\n    inProgress.delete(schema)\n  }\n}\n"],"names":["out"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"attaform.BupwXkj_.mjs","sources":["../../src/runtime/lib/core/transforms/_shared-props.ts","../../src/runtime/lib/core/transforms/component-bridge-transform.ts","../../src/runtime/lib/core/transforms/input-text-area-transform.ts","../../src/runtime/lib/core/transforms/v-register-hint-transform.ts","../../src/runtime/lib/core/transforms/v-register-preamble-transform.ts"],"sourcesContent":["import type {\n  AttributeNode,\n  CompoundExpressionNode,\n  DirectiveNode,\n  ExpressionNode,\n  RootNode,\n  SimpleExpressionNode,\n  TemplateChildNode,\n} from '@vue/compiler-core'\nimport { NodeTypes } from '@vue/compiler-core'\n\n/**\n * Shared prop-summarization toolkit for the compile-time node\n * transforms. `input-text-area-transform.ts` and `select-transform.ts`\n * both summarize their host element's props into a uniform\n * `{ key, value }` shape before deciding which directive to inject,\n * which props to strip, and how to construct the synthesized binding.\n * The summarization rules are byte-identical across both transforms;\n * keeping two copies risked silent drift — particularly on key-shape\n * decisions (`isExactKey`) and quoting (`renderAsStatic`).\n *\n * Consumers in the `transforms/` directory only — not exported from\n * any package barrel. The underscore prefix mirrors the existing\n * convention for transform-internal modules.\n */\n\n/**\n * Uniform summary of a Vue-compiler AST prop. `key` is the prop name\n * (string for attributes, the rendered text of `arg` for directive\n * binds); `value` is either a string (attribute literal, simple\n * expression, or quoted static) or the children array of a\n * `CompoundExpressionNode` (template literals, interpolated\n * expressions, etc.).\n */\nexport type SummarizedProp = {\n  key: string\n  value: string | CompoundExpressionNode['children']\n}\n\n/**\n * Summarize every prop on a Vue-compiler element node into the\n * `SummarizedProp` shape. Returns an empty array for nodes that don't\n * carry props (template / interpolation / comment).\n */\nexport function getSummarizedProps(node: RootNode | TemplateChildNode): SummarizedProp[] {\n  if (!('props' in node)) return []\n  const props = node.props\n\n  const summarizedProps = props.reduce<SummarizedProp[]>((acc, currProp) => {\n    if (currProp.type === NodeTypes.ATTRIBUTE) {\n      const key = currProp.name\n      const value = currProp.value?.content ?? ''\n      return [...acc, { key, value: renderAsStatic(value, true) }]\n    }\n\n    if (currProp.exp === undefined) return acc\n    const key = currProp.arg\n      ? getSummarizedPropValue(currProp.arg)\n      : renderAsStatic(currProp.name, true)\n    if (typeof key !== 'string') return acc // key must always be a string\n    const value = getSummarizedPropValue(currProp.exp)\n\n    return [...acc, { key, value }]\n  }, [])\n\n  return summarizedProps\n}\n\n/**\n * Wrap a static value in double quotes so it serializes back to a\n * JS string literal. Pass `isStatic: false` to return the raw text\n * unchanged (already a dynamic-expression source string).\n */\nexport function renderAsStatic(val: string, isStatic: boolean): string {\n  return isStatic ? `\"${val}\"` : val\n}\n\n/**\n * Resolve an ExpressionNode to its `SummarizedProp['value']` shape —\n * either a quoted static literal (for simple static expressions) or\n * the raw children array (for compound / interpolated expressions).\n */\nexport function getSummarizedPropValue(exp: ExpressionNode): SummarizedProp['value'] {\n  if (exp.type === NodeTypes.SIMPLE_EXPRESSION) {\n    return renderAsStatic(exp.content, exp.isStatic)\n  }\n\n  return exp.children\n}\n\n/**\n * Mutate `props` in place to drop every entry whose name (or\n * directive-arg content) matches any of `propNames`. Indices are\n * collected high-to-low so the splice loop doesn't shift remaining\n * entries mid-iteration.\n */\nexport function removePropsByName(\n  props: (AttributeNode | DirectiveNode)[],\n  propNames: string[]\n): void {\n  const removePropIndices: number[] = []\n  for (let index = 0; index < props.length; index++) {\n    const prop = props[index]\n    if (!prop) continue\n\n    if (\n      propNames.includes(prop.name) ||\n      ('arg' in prop && prop.arg && 'content' in prop.arg && propNames.includes(prop.arg.content))\n    ) {\n      removePropIndices.push(index) // store index to remove later, don't mutate variable while looping through it\n    }\n  }\n\n  for (const index of removePropIndices.sort((a, z) => z - a)) {\n    props.splice(index, 1) // index runs from high to low, so this works\n  }\n}\n\n/**\n * Exact prop-name match. Pre-rewrite used .includes('register') /\n * .includes('value') / .includes('type') which false-positived on\n * any user prop whose name contained those substrings (e.g.\n * `data-register-id`, `valueFoo`, `prototype`, `:registerField`).\n *\n * Summarized keys come in three shapes depending on prop type:\n *   attribute       -> \"name\"          (from getSummarizedProps)\n *   v-bind:name=\"x\" -> \"\\\"name\\\"\"      (quoted via renderAsStatic)\n *   static v-prefix -> \"\\\"name\\\"\"\n */\nexport function isExactKey(summarizedKey: string, name: string): boolean {\n  return summarizedKey === name || summarizedKey === `\"${name}\"`\n}\n\n/**\n * Flatten an ExpressionNode (`SimpleExpressionNode` |\n * `CompoundExpressionNode`) back to its source-text string. Compound\n * nodes carry a list of strings interleaved with nested expression\n * nodes — concatenate the textual content to reconstruct the source.\n *\n * Single source of truth for the select transform's per-`<option>`\n * processExpression input AND the v-register preamble transform's\n * pre-wrap binding capture. Both call sites built equivalent inline\n * helpers; the consolidation prevents drift in how a future Vue node-\n * type addition gets handled.\n *\n * Children that aren't string / SIMPLE / COMPOUND (symbols from the\n * codegen helper indices; node types added in a future Vue) are\n * dropped silently — the serialized text is for downstream parsing,\n * not faithful round-trip.\n */\nexport function flattenExpression(exp: ExpressionNode): string {\n  if (exp.type === NodeTypes.SIMPLE_EXPRESSION) return exp.content\n  let out = ''\n  for (const child of exp.children) {\n    if (typeof child === 'string') {\n      out += child\n      continue\n    }\n    if (typeof child === 'symbol') continue\n    const node = child as ExpressionNode | SimpleExpressionNode\n    if (node.type === NodeTypes.SIMPLE_EXPRESSION) {\n      out += node.content\n      continue\n    }\n    if (node.type === NodeTypes.COMPOUND_EXPRESSION) {\n      out += flattenExpression(node)\n    }\n  }\n  return out\n}\n","import {\n  createCompoundExpression,\n  createSimpleExpression,\n  ElementTypes,\n  NodeTypes,\n  processExpression,\n  type AttributeNode,\n  type CompoundExpressionNode,\n  type DirectiveNode,\n  type ExpressionNode,\n  type NodeTransform,\n  type RootNode,\n  type SourceLocation,\n  type TemplateChildNode,\n} from '@vue/compiler-core'\nimport {\n  flattenExpression,\n  getSummarizedProps,\n  isExactKey,\n  removePropsByName,\n  type SummarizedProp,\n} from './_shared-props'\n\nfunction generateEqualityExpression(\n  selectValue: SummarizedProp['value'],\n  optionValue: SummarizedProp['value'],\n  previousOptionExpressions: CompoundExpressionNode['children'][]\n): CompoundExpressionNode['children'] {\n  const multipleExpression = previousOptionExpressions?.[0] // this should always exist\n  if (multipleExpression === undefined) {\n    // this should NEVER happen\n    throw new Error(\n      'Programming error: `multiple` expression for `select` node not generated while transforming AST'\n    )\n  }\n\n  const optExpressions = previousOptionExpressions.slice(1)\n\n  // for `multiple`=\"false\", we ONLY execute latest expression if all past expressions were falsy\n  const noMultipleOptExpressions = optExpressions.reduce<CompoundExpressionNode['children']>(\n    (acc, curr, index) => {\n      if (index === 0) {\n        acc.push('(')\n      }\n\n      acc.push(...curr) // all expressions from last operation were grouped into an array\n      if (index < optExpressions.length - 1) {\n        acc.push(' || ')\n      }\n\n      if (index === optExpressions.length - 1) {\n        acc.push(')')\n      }\n\n      return acc\n    },\n    []\n  )\n\n  const selectValueArr = Array.isArray(selectValue) ? selectValue : [selectValue]\n  const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue]\n\n  function getImplicitTrueMultipleExpression(expression: CompoundExpressionNode['children']) {\n    // Identify user passing in `multiple` as an implied truthy prop\n    if (expression.length === 1 && expression[0] === '') return [`true`]\n    return expression\n  }\n\n  // capture the current expression for the next round\n  previousOptionExpressions.push(['(', ...selectValueArr, ') === (', ...optionValueArr, ')'])\n  // Single-select branch String-coerces both sides to mirror the\n  // runtime directive's `looseEqual`-style match — a typed-numeric\n  // model (`z.number()`) matches `<option value=\"1\">` at SSR time.\n  // The `typeof !== 'object'` guard preserves the pre-existing\n  // \"array model on a single-select doesn't match\" behaviour: an\n  // array stringifies to its joined elements, which would otherwise\n  // false-positive against a single-element option.\n  // The multi-select branch keeps `innerRef.value` because Array\n  // / Set models need findIndex / membership iteration.\n  if (!noMultipleOptExpressions.length) {\n    return [\n      '(',\n      ...getImplicitTrueMultipleExpression(multipleExpression),\n      `) ? ((`,\n      ...selectValueArr,\n      `)?.innerRef?.value?.findIndex?.(el => el === (`,\n      ...optionValueArr,\n      `)) > -1) : (typeof (`,\n      ...selectValueArr,\n      `)?.innerRef?.value !== 'object' && String((`,\n      ...selectValueArr,\n      `)?.innerRef?.value) === String((`,\n      ...optionValueArr,\n      `)))`,\n    ]\n  }\n\n  return [\n    '(',\n    ...getImplicitTrueMultipleExpression(multipleExpression),\n    `) ? ((`,\n    ...selectValueArr,\n    `)?.innerRef?.value?.findIndex?.(el => el === (`,\n    ...optionValueArr,\n    `)) > -1) : ((`,\n    ...noMultipleOptExpressions, // if true, we already found the relevant option\n    `) ? false : (typeof (`,\n    ...selectValueArr,\n    `)?.innerRef?.value !== 'object' && String((`,\n    ...selectValueArr,\n    `)?.innerRef?.value) === String((`,\n    ...optionValueArr,\n    `))))`,\n  ]\n}\n\nfunction extractMultipleFromSelectSummarizedProps(\n  props: SummarizedProp[]\n): SummarizedProp['value'] {\n  const multipleDirectiveIndex = props.findIndex(\n    (prop) => prop.key.replace(/\"/g, `'`) === \"'multiple'\"\n  )\n  const multipleAttributeIndex = props.findIndex((prop) => prop.key === 'multiple')\n\n  if (multipleDirectiveIndex === -1 && multipleAttributeIndex === -1) {\n    return 'false'\n  }\n  const priorityIndex =\n    multipleDirectiveIndex >= 0 ? multipleDirectiveIndex : multipleAttributeIndex\n  const value = props[priorityIndex]?.value\n\n  // attempt to convert expression within string into boolean\n  // if undefined, make value `true` because of `<input multiple />` usage\n  return typeof value === 'string' ? value.replace(/'|\"/g, '') : (value ?? 'true')\n}\n\n// Whitelist of node types that contain iterable child nodes. Used by\n// traverseSelectNode so we don't recurse into interpolation / comment / text\n// nodes (which have no `children` in the traversal sense) and don't crash on\n// future Vue node-type additions.\nconst RECURSABLE_NODE_TYPES: ReadonlySet<number> = new Set<number>([\n  NodeTypes.ELEMENT,\n  NodeTypes.FOR,\n  NodeTypes.IF,\n  NodeTypes.IF_BRANCH,\n])\n\n// Native form-shell tags excluded from the kebab-case extension. The\n// hyphen check on `node.tag` already excludes most native HTML tags\n// (which have no hyphen), but listing the form-shell ones explicitly\n// documents the conservative stance: even if a future native tag like\n// `<my-form-something>` lands, it won't accidentally collide with a\n// custom-element transform branch. `<input>`, `<select>`, `<textarea>`\n// already have dedicated branches via inputTextAreaNodeTransform and\n// the isSelect path above; the others (form, fieldset, label, button,\n// option) carry no meaningful v-register binding and shouldn't be\n// rewritten with component-style props.\nconst NATIVE_FORM_TAGS: ReadonlySet<string> = new Set<string>([\n  'input',\n  'textarea',\n  'select',\n  'option',\n  'form',\n  'fieldset',\n  'label',\n  'button',\n])\n\n/**\n * Synthesise a static value for `<option>foo</option>` (no `value=`\n * attr). Returns the text content as a single-quoted JS string literal\n * so the equality check rendered into the AST treats it as a string.\n *\n * Returns:\n *   - quoted-string `\"'apple'\"` for a single static text child,\n *   - `null` for mixed / dynamic / empty children — caller skips the\n *     binding rather than synthesise a guess.\n *\n * The HTML spec says an option's value defaults to its descendant\n * text. We restrict to \"single static text node\" to keep the\n * code-path safe: handling interpolation correctly would need a\n * wrapped runtime expression, which we can't emit at compile time\n * without leaking runtime references that may not exist in the\n * template's binding scope.\n */\nfunction inferOptionValueFromChildren(node: TemplateChildNode | RootNode): string | null {\n  if (!('children' in node)) return null\n  const children = node.children\n  if (children.length !== 1) return null\n  const only = children[0]\n  if (only === undefined) return null\n  if (typeof only === 'string' || typeof only === 'symbol') return null\n  if (only.type !== NodeTypes.TEXT) return null\n  // Mirror Vue's option-value semantic: trim leading/trailing whitespace\n  // so `<option> apple </option>` matches a model value of `'apple'`.\n  const text = only.content.trim()\n  // Emit a fully escaped JS string literal — `JSON.stringify` covers\n  // backslashes, quotes, and line terminators (`\\n`, `\\r`, U+2028,\n  // U+2029) so the synthesized literal stays single-line and valid.\n  return JSON.stringify(text)\n}\n\n/**\n * Vue compiler node transform that bridges `v-register` into the\n * downstream binding shapes its consumers expect:\n *\n *   - `<select v-register>` — injects `:value` (single-select) and\n *     per-`<option>` `:selected` so the runtime directive can pre-mark\n *     selected options at SSR time.\n *   - `<MyComponent v-register>` and kebab-case custom-element hosts\n *     — injects a `:registerValue` bridge prop so `useRegister` inside\n *     the child sees the parent's RegisterValue (the binding the audit\n *     called out as the transform's \"fires on every component\" path).\n *\n * Wired automatically by `attaform/vite` and `attaform/nuxt`. Use\n * directly only when integrating with a custom bundler.\n *\n * Renamed from `selectNodeTransform` (DIR-F6): the original name read\n * as a `<select>`-only transform, but the component-bridge path is\n * load-bearing for every `useRegister` consumer.\n */\nexport const componentBridgeTransform: NodeTransform = (node, context) => {\n  // Snapshot every prop array we're about to mutate so a throw\n  // mid-traversal rewinds to the pre-transform state. Without this,\n  // a partial transform leaves the template with some `<option\n  // :selected>` bindings rewritten and others not — worse than\n  // skipping the transform entirely, since the runtime directive\n  // would then miscompute initial state against a shape it doesn't\n  // recognise. `snapshotProps` is idempotent per target; calling\n  // twice records one snapshot.\n  type NodeProps = (AttributeNode | DirectiveNode)[]\n  const snapshots: Array<{ target: NodeProps; snapshot: NodeProps }> = []\n  const snapshotProps = (target: NodeProps): void => {\n    if (snapshots.some((entry) => entry.target === target)) return\n    snapshots.push({ target, snapshot: [...target] })\n  }\n  try {\n    const isSelect = node.type === NodeTypes.ELEMENT && node.tag === 'select'\n    const isCustomComponent =\n      node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.COMPONENT\n    // Kebab-case tags (those with a hyphen, like `<my-input>`) compile\n    // as `tagType === ElementTypes.ELEMENT` — Vue's compiler can't tell\n    // statically whether the tag will resolve to an `app.component`\n    // registration or to a user-supplied `compilerOptions.isCustomElement`\n    // predicate, so it emits an element creation that the runtime\n    // disambiguates. The transform fires the bridge prop injection on\n    // these tags too: a kebab-case Vue component sees `useRegister`\n    // work in its setup; a real Web Component sees `:value` /\n    // `:registerValue` as DOM attributes (the documented `assignKey`\n    // escape hatch handles that interop).\n    //\n    // NATIVE_FORM_TAGS keeps the conservative stance: only inject on\n    // tags Vue would NEVER treat as a component. The hyphen check\n    // already excludes most native HTML tags (which have no hyphen);\n    // the explicit list documents the contract and guards against\n    // hypothetical future native form tags with hyphens.\n    const isKebabCustomElement =\n      node.type === NodeTypes.ELEMENT &&\n      node.tagType === ElementTypes.ELEMENT &&\n      node.tag.includes('-') &&\n      !NATIVE_FORM_TAGS.has(node.tag)\n\n    if (!(isSelect || isCustomComponent || isKebabCustomElement)) return\n\n    const selectSummarizedProps = getSummarizedProps(node)\n\n    const registerIndex = selectSummarizedProps.findIndex((p) => isExactKey(p.key, 'register'))\n    if (\n      selectSummarizedProps.length === 0 ||\n      registerIndex < 0 ||\n      registerIndex >= selectSummarizedProps.length\n    )\n      return\n\n    const registerSummarizedProp = selectSummarizedProps[registerIndex]\n\n    // Inject location matches the originating element so source maps\n    // for runtime errors in the synthesized expressions point at the\n    // user's <select v-register=...> rather than line 0.\n    const selectLoc: SourceLocation = node.loc\n\n    function traverseSelectNode(\n      _node: RootNode | TemplateChildNode,\n      previousOptionExpressions: CompoundExpressionNode['children'][]\n    ): void {\n      const isOption = _node.type === NodeTypes.ELEMENT && _node.tag === 'option'\n      if (!isOption) {\n        // Only recurse into node types that genuinely hold iterable children.\n        // Text / interpolation / comment nodes are skipped; future Vue node\n        // types that we don't know about are also skipped rather than\n        // crashing on a shape we didn't expect.\n        if (!RECURSABLE_NODE_TYPES.has(_node.type)) return\n        const hasChildren = 'children' in _node\n        if (!hasChildren) return\n        for (const child of _node.children) {\n          if (typeof child === 'symbol' || typeof child === 'string') continue\n          if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue\n          traverseSelectNode(child, previousOptionExpressions)\n        }\n        return\n      }\n\n      const optionProps = getSummarizedProps(_node)\n      const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, 'value'))\n\n      // D3: HTML lets `<option>apple</option>` use text content as the\n      // value. The original transform required an explicit `value=`\n      // attr and silently dropped value-less options — they'd render\n      // unselectable through `register('fruit')` because the AST\n      // emitted no `:selected` binding.\n      //\n      // Fallback: if no `value=`, look at the option's children. A\n      // single static TextNode → use it as the static value. Anything\n      // else (interpolation, mixed children, no children) → skip with\n      // a dev-warn rather than guess.\n      let optionValueSummarizedProp: SummarizedProp | undefined\n      if (valueIndex >= 0 && valueIndex < optionProps.length) {\n        optionValueSummarizedProp = optionProps[valueIndex]\n      } else {\n        const fallback = inferOptionValueFromChildren(_node)\n        if (fallback === null) {\n          // Dynamic / mixed children — can't synthesize a static\n          // equality expression. Bail without binding so the option\n          // simply isn't reactive (matches pre-D3 behaviour for the\n          // genuinely-dynamic cases). Producing a wrong binding would\n          // be worse than no binding.\n          return\n        }\n        optionValueSummarizedProp = { key: 'value', value: fallback }\n      }\n\n      const props = _node.props\n      snapshotProps(props)\n      removePropsByName(props, ['selected'])\n\n      const newProp: DirectiveNode = {\n        arg: createSimpleExpression('selected', true),\n        exp: createCompoundExpression(\n          generateEqualityExpression(\n            registerSummarizedProp?.value ?? 'undefined',\n            optionValueSummarizedProp?.value ?? 'undefined',\n            previousOptionExpressions\n          )\n        ),\n        name: 'bind',\n        modifiers: [],\n        type: NodeTypes.DIRECTIVE,\n        loc: _node.loc,\n      }\n      props.push(newProp)\n    }\n\n    const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps)\n\n    const previousOptionExpressions: CompoundExpressionNode['children'][] =\n      typeof multipleExpression === 'string' ? [[multipleExpression]] : [multipleExpression]\n\n    // Multi-select hydration trap. Setting `select.value = X` on a\n    // `<select multiple>` runs the spec's value-setter loop: for each\n    // option, set selectedness to (option.value === X). For an array\n    // model, `displayValue.value` resolves to `String(arr)` —\n    // `\"red,blue\"` — which matches NO option's value, so the patch\n    // DESELECTS every option (including the SSR-selected ones the\n    // per-option `:selected` injection just placed). At runtime the\n    // directive's `setSelected` re-syncs from the model, but the value\n    // patch + the directive's identity-skip path can leave the DOM\n    // stuck deselected if the model hasn't moved since the last apply.\n    //\n    // Per-option `:selected` bindings are the canonical mechanism for\n    // multi-select initial state — the runtime directive's setSelected\n    // mirrors exactly the same logic on the client. The select-level\n    // `:value` adds nothing for multi: it's only useful as Vue's\n    // single-select `value` patch shorthand, which is benign there\n    // (`select.value = \"1\"` selects the matching option, a no-op when\n    // it's already selected via `<option selected>`).\n    //\n    // Conservative gate: skip `:value` whenever `multiple` isn't\n    // statically false. Static `<select>` and static `<select\n    // multiple=\"false\">` keep the injection (`extractMultipleFromSelect…`\n    // returns the literal string `'false'` for both). Anything else —\n    // static `multiple`, `multiple=\"true\"`, or a dynamic `:multiple`\n    // expression we can't evaluate at compile time — skips. The\n    // dynamic case is rare; trading SSR `value=` on the select for\n    // hydration correctness is the right call.\n    const isStaticallyNonMultiple = multipleExpression === 'false'\n\n    const selectProps = node.props\n    snapshotProps(selectProps)\n    removePropsByName(selectProps, ['value']) // actively prevent an attribute collision\n\n    if (isStaticallyNonMultiple) {\n      // construct `:value` dynamic prop based on the existing `v-register` directive\n      const valuePropExpArray = Array.isArray(registerSummarizedProp?.value)\n        ? registerSummarizedProp.value\n        : [registerSummarizedProp?.value ?? 'undefined']\n      // Read `displayValue.value` rather than `innerRef.value` so\n      // selects share the same single read surface as text inputs.\n      // The directive never marks select paths blank (no\n      // DOM \"empty\" state), so in normal flow `displayValue` is just\n      // `String(storage)` — identical to today. The edge case where a\n      // consumer programmatically calls `setValue(numericPath, unset)`\n      // bound to a `<select>` is documented in the docs (browser falls\n      // back to first option; meta.blank surfaces the intent).\n      const initExpression = createCompoundExpression([\n        '(',\n        ...valuePropExpArray,\n        ')?.displayValue.value',\n      ])\n\n      const simpleExpression = createSimpleExpression(flattenExpression(initExpression), false)\n      // `processExpression` can throw on malformed identifiers or\n      // exotic expression shapes. Pre-fix, the throw bubbled to the\n      // outer try/catch, which then ran the snapshot-restore path AND\n      // skipped both the select's `:value` injection AND every option's\n      // `:selected` binding — turning a single-expression problem into\n      // a whole-template fallback. Isolate here so a parser failure on\n      // this one expression keeps the other injections.\n      let outputExp: ExpressionNode\n      try {\n        outputExp = processExpression(simpleExpression, { ...context, prefixIdentifiers: false })\n      } catch (err) {\n        console.error(\n          '[attaform] component-bridge transform: processExpression failed; falling back to the unprocessed expression.',\n          err\n        )\n        outputExp = simpleExpression\n      }\n\n      const valueProp: DirectiveNode = {\n        rawName: ':value',\n        arg: createSimpleExpression('value', true),\n        exp: outputExp,\n        name: 'bind',\n        modifiers: [],\n        type: NodeTypes.DIRECTIVE,\n        loc: selectLoc,\n      }\n\n      node.props.push(valueProp)\n    }\n\n    if (isSelect) {\n      for (const child of node.children) {\n        traverseSelectNode(child, previousOptionExpressions) // start searching for options in dfs manner\n      }\n      return\n    }\n\n    const registerProps = node.props.filter(\n      (x) => x.type === NodeTypes.DIRECTIVE && x.name === 'register'\n    )\n    const registerProp = registerProps[0]\n\n    if (!registerProp) return\n\n    // Idempotency marker. The hint and preamble transforms record\n    // their own per-node markers; this one detects an already-injected\n    // `:registerValue` directive on the props array and skips\n    // re-pushing. Without the check, a doubly-registered transform\n    // pipeline (rare in production, common in test combinatorics)\n    // would emit two `registerValue:` keys in the generated render —\n    // the last wins for prop resolution, but the output is bloated and\n    // confusing under codegen inspection.\n    const alreadyInjected = node.props.some(\n      (p) =>\n        p.type === NodeTypes.DIRECTIVE &&\n        p.name === 'bind' &&\n        p.arg !== undefined &&\n        'content' in p.arg &&\n        p.arg.content === 'registerValue'\n    )\n    if (alreadyInjected) return\n\n    const customElementProp: DirectiveNode = {\n      arg: createSimpleExpression('registerValue', true),\n      exp: 'exp' in registerProp ? registerProp.exp : createSimpleExpression('undefined', false),\n      name: 'bind',\n      modifiers: [],\n      type: NodeTypes.DIRECTIVE,\n      loc: selectLoc,\n    }\n\n    node.props.push(customElementProp)\n  } catch (err) {\n    // AST shape drift or malformed template: rewind every prop array\n    // we mutated so the template falls back cleanly to the runtime\n    // directive. Reverse order mirrors the push order so later\n    // snapshots restore against the state their earlier siblings\n    // saw. Runtime directive alone still handles value binding; only\n    // SSR initial-render correctness is affected.\n    for (const { target, snapshot } of snapshots.slice().reverse()) {\n      target.splice(0, target.length, ...snapshot)\n    }\n\n    console.error('[attaform] component-bridge transform failed, skipping:', err)\n  }\n}\n","import type {\n  CompoundExpressionNode,\n  DirectiveNode,\n  NodeTransform,\n  PlainElementNode,\n  SourceLocation,\n} from '@vue/compiler-core'\nimport { createCompoundExpression, NodeTypes } from '@vue/compiler-core'\nimport {\n  getSummarizedProps,\n  isExactKey,\n  removePropsByName,\n  type SummarizedProp,\n} from './_shared-props'\n\nfunction generateEqualityExpression(\n  registerValue: SummarizedProp['value'],\n  optionValue: SummarizedProp['value'],\n  scalarTarget: SummarizedProp['value']\n): CompoundExpressionNode['children'] {\n  const registerValueArr = Array.isArray(registerValue) ? registerValue : [registerValue]\n  const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue]\n  const scalarTargetArr = Array.isArray(scalarTarget) ? scalarTarget : [scalarTarget]\n\n  // Discriminator selection:\n  //   - Array model     → membership of the option-value (e.g. value=\"apple\")\n  //   - Set model       → membership of the option-value\n  //   - Scalar model    → coerced String() equality with the scalar target\n  //\n  // The scalar target differs from the option-value for two checkbox\n  // shapes that the directive's runtime `setChecked` already handles\n  // via `getCheckboxValue(el, true)`:\n  //\n  //   - boolean model + no `value=` → target is `true`\n  //   - string model + `:true-value=\"'X'\"` → target is `'X'`\n  //\n  // For radio inputs the model is always scalar and the discriminator\n  // IS the option-value, so `optionValue === scalarTarget` there.\n  //\n  // The scalar branch routes both sides through `String(...)` to mirror\n  // the runtime `setChecked` path, which uses Vue's `looseEqual` —\n  // looseEqual coerces primitives via `String(...)` before comparing.\n  // Without the coerce, SSR on `<input type=\"radio\" value=\"2\">` bound\n  // to a `z.number()` model of `2` evaluated `2 === \"2\"` → `false` and\n  // emitted unchecked HTML, then the runtime's `looseEqual(2, applyCoerce(\"2\"))`\n  // returned `true` on hydration and flipped to checked — a one-tick\n  // visible flicker (DIR-F4). The `typeof !== 'object'` guard preserves\n  // current behaviour for non-array / non-Set object models, which both\n  // ladders fall through this scalar branch with no realistic match.\n  return [\n    'Array.isArray((',\n    ...registerValueArr,\n    ')?.innerRef?.value) ? ',\n    '(',\n    ...registerValueArr,\n    ')?.innerRef?.value?.includes(',\n    ...optionValueArr,\n    ') : ',\n    '(',\n    ...registerValueArr,\n    ')?.innerRef?.value instanceof Set ? (',\n    ...registerValueArr,\n    ')?.innerRef?.value?.has(',\n    ...optionValueArr,\n    ') : ',\n    '(typeof (',\n    ...registerValueArr,\n    \")?.innerRef?.value !== 'object' && String((\",\n    ...registerValueArr,\n    ')?.innerRef?.value) === String((',\n    ...scalarTargetArr,\n    ')))',\n  ]\n}\n\n/**\n * Parse a one-line JS string literal from `text`. Returns `null` for\n * any non-literal source (dynamic expression, compound, mismatched\n * quotes); on a match returns the quote character and the inner\n * payload separately so callers can disambiguate template literals\n * with interpolations from literal-static strings.\n *\n * Doesn't attempt to handle escaped quotes inside the literal — a\n * value containing escaped quotes is vanishingly rare in the prop\n * shapes the transforms inspect (HTML attribute values, type names).\n * Callers that can't prove safety on `null` should bail conservatively.\n */\nfunction parseStaticStringLiteral(text: string): { quote: string; inner: string } | null {\n  const literalMatch = /^([\"'`])(.*)\\1$/.exec(text.trim())\n  if (literalMatch === null) return null\n  return { quote: literalMatch[1] as string, inner: literalMatch[2] as string }\n}\n\n/**\n * Returns true iff the type prop's value is the static-attribute literal\n * matching one of `names` (case-insensitive). Used to detect static\n * `type=\"checkbox\"` / `type=\"radio\"` shapes where the `value` attribute\n * is the option-value (a discriminator within the group), not display\n * state — so the transform must NOT strip it.\n *\n * Conservative on dynamic shapes — `:type=\"x\"` returns false, falling\n * through to the text-input branch which strips `value`. Authors using\n * dynamic types between checkbox/radio and text are rare; if they hit\n * this they can add a static `type=` to lock the shape.\n */\nfunction isStaticTypeOneOf(value: SummarizedProp['value'], names: readonly string[]): boolean {\n  if (Array.isArray(value)) return false\n  const parsed = parseStaticStringLiteral(value)\n  if (parsed === null) return false\n  return names.includes(parsed.inner.toLowerCase())\n}\n\n/**\n * Returns true if the type prop's value MIGHT resolve to \"file\" at runtime.\n * Conservative — anything not provably non-\"file\" returns true so the caller\n * skips the transform.\n *\n * Concretely:\n *   - `type=\"text\"`   → value is `'\"text\"'`         → false (static literal != \"file\")\n *   - `type=\"file\"`   → value is `'\"file\"'`         → true  (static \"file\")\n *   - `:type=\"'text'\"`→ value is `\"'text'\"`         → false\n *   - `:type=\"'file'\"`→ value is `\"'file'\"`         → true\n *   - `:type=\"kind\"`  → value is `'kind'`           → true  (dynamic identifier)\n *   - `:type=\"`a-${x}`\"` → array or template lit    → true  (compound expression)\n */\nfunction couldResolveToFileType(value: SummarizedProp['value']): boolean {\n  if (Array.isArray(value)) return true\n  const parsed = parseStaticStringLiteral(value)\n  if (parsed === null) return true // dynamic expression — can't prove safe\n  // Template literals with interpolations resolve at runtime.\n  if (parsed.quote === '`' && parsed.inner.includes('${')) return true\n  // The HTML spec matches `type` ASCII case-insensitively, so\n  // `<input type=\"FILE\">` behaves identically to `<input type=\"file\">`.\n  // Compare lower-cased so we catch both.\n  return parsed.inner.toLowerCase() === 'file'\n}\n\n/**\n * Vue compiler node transform for `<input v-register>` and\n * `<textarea v-register>`. Injects the `:value` / `:checked`\n * bindings required for SSR-correct initial render.\n *\n * Wired automatically by `attaform/vite` and\n * `attaform/nuxt`. Use directly only when integrating with\n * a custom bundler.\n */\nexport const inputTextAreaNodeTransform: NodeTransform = (node) => {\n  try {\n    if (node.type !== NodeTypes.ELEMENT) return\n\n    const isInput = node.tag === 'input'\n    const isTextArea = node.tag === 'textarea'\n\n    if (!isInput && !isTextArea) return\n\n    const elementProps = getSummarizedProps(node)\n\n    const registerIndex = elementProps.findIndex((p) => isExactKey(p.key, 'register'))\n    const registerSummarizedProp = elementProps[registerIndex]\n    if (!registerSummarizedProp) return // no v-register directive; nothing to transform\n\n    // <input type=\"file\" v-register=\"...\"> bypasses the value-binding\n    // injection — the runtime `vRegisterFile` variant owns the DOM\n    // contract for file inputs (read `el.files` on change; clear via\n    // `el.value = ''` only). Skipping at compile-time avoids the\n    // `:value=\"\"` binding browsers would otherwise reject on a file\n    // input. We must skip not just the static `type=\"file\"` case but any\n    // dynamic binding (`:type=\"x\"`, template-literal expressions, etc.)\n    // that COULD resolve to \"file\" at runtime — `couldResolveToFileType`\n    // errs on the conservative side.\n    const typeIndex = elementProps.findIndex((p) => isExactKey(p.key, 'type'))\n    const typeProp = elementProps[typeIndex]\n    if (typeProp !== undefined && couldResolveToFileType(typeProp.value)) return\n\n    const valueIndex = elementProps.findIndex((p) => isExactKey(p.key, 'value'))\n    const elementValueSummarizedProp = elementProps?.[valueIndex] ?? {\n      key: 'value',\n      value: \"''\",\n    }\n\n    const inputTypeIndex = typeIndex\n\n    const defaultSummarizedTextProp = { key: 'type', value: \"'text'\" }\n    const inputTypeSummarizedProp: SummarizedProp =\n      inputTypeIndex === -1\n        ? defaultSummarizedTextProp\n        : (elementProps[inputTypeIndex] ?? defaultSummarizedTextProp)\n    const inputTypeExpressionArray =\n      typeof inputTypeSummarizedProp.value === 'string'\n        ? [inputTypeSummarizedProp.value]\n        : inputTypeSummarizedProp.value\n\n    // this gets paired with `value` to get the [selectionLabel]=[label] prop for the given input\n    // checkbox and radio are marked as selected via `checked`, others typically use `value`\n    //\n    // The HTML spec matches `type` ASCII case-insensitively, so\n    // `<input type=\"CHECKBOX\">` and `<input type=\"Radio\">` produce the\n    // same runtime element as their lowercase counterparts. The\n    // injected expression normalizes via `String(t).toLowerCase()`\n    // before comparing — the compile-time `isStaticTypeOneOf` already\n    // uses case-insensitive matching, so without the runtime\n    // normalization a `type=\"CHECKBOX\"` input would have its static\n    // `value` preserved (per `keepStaticValue`) but still emit\n    // `:value=\"...\"` instead of `:checked=\"...\"`, breaking SSR initial\n    // checked state.\n    const elementSelectionLabelExpression = createCompoundExpression([\n      '(',\n      'String((',\n      ...inputTypeExpressionArray,\n      ')).toLowerCase()',\n      \" === 'checkbox' || \",\n      'String((',\n      ...inputTypeExpressionArray,\n      \")).toLowerCase() === 'radio'\",\n      \") ? 'checked' : 'value'\",\n    ])\n\n    // Narrowed from `PlainElementNode | ComponentNode | SlotOutletNode |\n    // TemplateNode` — `<input>` / `<textarea>` are always PlainElementNode\n    // in Vue's AST. The previous wide union let a TemplateNode slip\n    // through and crash on `_node.props`.\n    function computeProps(\n      _node: PlainElementNode,\n      registerSummarizedProp: SummarizedProp,\n      elementValueSummarizedProp: SummarizedProp\n    ): void {\n      // Reuse the originating element's source location for the\n      // injected directive — runtime errors in the synthesized expression\n      // get reported at the v-register binding site rather than line 0.\n      const injectedLoc: SourceLocation = _node.loc\n\n      const props = _node.props\n      // For statically-typed checkbox / radio inputs, the `value=`\n      // attribute is the OPTION-value (the discriminator the directive\n      // matches against the model), not display state. The synthesized\n      // binding below resolves to `:checked=\"...\"` for those types, a\n      // different attribute key — so the static `value` survives\n      // alongside it without conflict. Stripping it (as we still do\n      // for text/textarea, where the synthesized binding resolves to\n      // `:value`) leaves the SSR HTML without the attribute, and on\n      // hydration the directive can't tell which option this checkbox\n      // represents.\n      const isStaticCheckbox =\n        typeProp !== undefined && isStaticTypeOneOf(typeProp.value, ['checkbox'])\n      const isStaticRadio = typeProp !== undefined && isStaticTypeOneOf(typeProp.value, ['radio'])\n      const keepStaticValue = isStaticCheckbox || isStaticRadio\n      removePropsByName(props, keepStaticValue ? ['checked'] : ['checked', 'value'])\n      const registerValueArr = Array.isArray(registerSummarizedProp.value)\n        ? registerSummarizedProp.value\n        : [registerSummarizedProp.value]\n      // Read `displayValue.value` rather than `innerRef.value` so the\n      // `:value` binding renders the blank `''` when the\n      // user clears a numeric field. `displayValue` returns\n      // `String(storage)` for non-empty storage and `''` for both\n      // null/undefined storage and paths in the form's\n      // `blankPaths` set — a single read surface for the\n      // injected expression. For checkbox / radio (the ternary's\n      // truthy branch above), this leg is unreached, so behaviour\n      // there is unchanged.\n      const valueExpression = createCompoundExpression([\n        '(',\n        ...registerValueArr,\n        ')?.displayValue?.value',\n      ])\n\n      // Scalar-equality target. Three cases (see the long-form comment\n      // on `generateEqualityExpression`):\n      //   - static checkbox + `:true-value=\"X\"` → X (the explicit\n      //     mapped string the model takes when checked)\n      //   - static checkbox without `:true-value` → boolean `true`\n      //     (matches the runtime's `getCheckboxValue(el, true)` default)\n      //   - static radio → the option-value (since radio model is\n      //     always scalar and the `value=` IS the discriminator)\n      //   - dynamic type → fall back to the option-value (current\n      //     behaviour); a dynamic-type element can't be statically\n      //     classified into checkbox vs radio vs text.\n      const trueValueIndex = elementProps.findIndex((p) => isExactKey(p.key, 'true-value'))\n      const trueValueProp = elementProps[trueValueIndex]\n      const scalarTarget: SummarizedProp['value'] = isStaticCheckbox\n        ? trueValueProp !== undefined\n          ? trueValueProp.value\n          : 'true'\n        : elementValueSummarizedProp.value\n\n      const valueOrCheckedProp: DirectiveNode = {\n        // reconstruct the `value` attribute based on the provided v-registerer, now that the computation is complete\n        arg: elementSelectionLabelExpression,\n        exp: createCompoundExpression([\n          '(',\n          ...elementSelectionLabelExpression.children,\n          \") === 'checked' ? (\",\n          // resolves to a boolean\n          ...generateEqualityExpression(\n            registerSummarizedProp.value,\n            elementValueSummarizedProp.value,\n            scalarTarget\n          ),\n          ') : (',\n          // resolves to the provided register value\n          ...valueExpression.children,\n          ')',\n        ]),\n        name: 'bind',\n        modifiers: [],\n        type: NodeTypes.DIRECTIVE,\n        loc: injectedLoc,\n      }\n\n      props.push(valueOrCheckedProp)\n    }\n\n    // The outer guards (`node.type === NodeTypes.ELEMENT` + `node.tag\n    // === 'input' | 'textarea'`) narrow `node` to a PlainElementNode\n    // at runtime; the cast records that for the type system.\n    computeProps(node as PlainElementNode, registerSummarizedProp, elementValueSummarizedProp)\n  } catch (err) {\n    // AST shapes can shift with minor Vue compiler updates. If we hit\n    // anything unexpected, skip this transform — the runtime directive\n    // alone handles value binding (via mounted/beforeUpdate), so the only\n    // cost is a one-frame flash on SSR initial render.\n\n    console.error('[attaform] input/textarea transform failed, skipping:', err)\n  }\n}\n","import {\n  createCompoundExpression,\n  NodeTypes,\n  type CompoundExpressionNode,\n  type ExpressionNode,\n  type NodeTransform,\n} from '@vue/compiler-core'\n\n/**\n * `vRegisterHintTransform` — for every `<element v-register=\"<expr>\">`,\n * rewrite the directive's binding expression to wrap `<expr>` in an\n * IIFE that calls `markConnectedOptimistically()` on the resulting\n * `RegisterValue` and returns the same object:\n *\n *   ((__attaRv) => (__attaRv?.markConnectedOptimistically?.(), __attaRv))(<expr>)\n *\n * Why this exists: Vue intentionally skips directive lifecycle hooks\n * during SSR (see `core/directive.ts`'s top comment). That means the\n * `v-register` directive's `created` hook — the one that flips\n * `connected: true` for the field — never fires server-side. Every\n * SSR'd FieldState therefore serialises `connected: false`, and on\n * hydration the directive runs and the flag flickers to `true`. Anyone\n * reading `getFieldState(path).connected` in a server-rendered\n * template sees the stale value baked into the static HTML.\n *\n * The wrapping IIFE captures the `RegisterValue` produced by `<expr>`,\n * fires the optimistic mark (which itself is guarded by `state.ssr`,\n * so client-side it's a free no-op), and returns the same object so\n * the directive receives exactly what the author wrote.\n *\n * The transform is deliberately agnostic to the shape of `<expr>`:\n *\n *   - inline:   `v-register=\"form.register('email')\"`\n *   - hoisted:  `v-register=\"emailReg\"` (where `emailReg = form.register(...)`)\n *   - dynamic:  `v-register=\"form.register(`${prefix}.email`)\"`\n *\n * All three produce a `RegisterValue` at runtime, and the wrapper\n * doesn't need to know the path string. Setup-time `register()` calls\n * that are NEVER bound to `v-register` get no wrapper, no optimistic\n * mark, and stay `connected: false` post-hydration — exactly the\n * desired negative case (those calls don't represent a rendered DOM\n * element).\n *\n * Idempotent: if the transform runs twice on the same AST (some\n * bundler configurations do this), the second pass detects the marker\n * and skips re-wrapping.\n */\n\nconst HINT_MARKER = '__attaRv'\nconst HINT_PREFIX = `((${HINT_MARKER}) => (${HINT_MARKER}?.markConnectedOptimistically?.(), ${HINT_MARKER}))(`\nconst HINT_SUFFIX = `)`\n\n/**\n * Vue compiler node transform that wraps every `v-register`\n * expression in a small IIFE so the directive can flag a field as\n * connected during SSR. Eliminates the `false → true` flicker on\n * `getFieldState(path).connected` after hydration.\n *\n * Must run after `vRegisterPreambleTransform`. Wired automatically\n * by `attaform/vite` and `attaform/nuxt`.\n */\nexport const vRegisterHintTransform: NodeTransform = (node) => {\n  try {\n    if (node.type !== NodeTypes.ELEMENT) return\n    for (const prop of node.props) {\n      if (prop.type !== NodeTypes.DIRECTIVE) continue\n      if (prop.name !== 'register') continue\n      if (prop.exp === undefined) continue\n      if (isAlreadyWrapped(prop.exp)) continue\n      prop.exp = wrapWithOptimisticHint(prop.exp)\n    }\n  } catch (err) {\n    // AST shape drift across @vue/compiler-core versions or a malformed\n    // directive: skip this transform entirely. The runtime mark is\n    // fail-safe — without the wrapper, we just get the existing\n    // false→true flicker on first paint, never an incorrect render.\n    console.error('[attaform] v-register hint transform failed, skipping:', err)\n  }\n}\n\nfunction isAlreadyWrapped(exp: ExpressionNode): boolean {\n  if (exp.type === NodeTypes.SIMPLE_EXPRESSION) {\n    return exp.content.includes(HINT_MARKER)\n  }\n  // Compound expression: scan only the string children. Nested\n  // SimpleExpressionNodes were copied verbatim from the user's\n  // expression and won't contain our marker; the marker only ever\n  // appears in the literal prefix/suffix strings we add.\n  for (const child of exp.children) {\n    if (typeof child === 'string' && child.includes(HINT_MARKER)) return true\n  }\n  return false\n}\n\nfunction wrapWithOptimisticHint(exp: ExpressionNode): CompoundExpressionNode {\n  // For a SimpleExpression we keep the node intact as a child so any\n  // later `processExpression` pass (identifier prefixing for setup\n  // refs) still walks it. For a CompoundExpression we splice its\n  // children in — prepending the prefix string and appending the\n  // suffix preserves the post-prefix shape downstream transforms\n  // expect.\n  const innerChildren: CompoundExpressionNode['children'] =\n    exp.type === NodeTypes.SIMPLE_EXPRESSION ? [exp] : [...exp.children]\n  // Reuse the wrapped expression's source location — runtime errors\n  // in the wrapped IIFE point at the v-register binding site rather\n  // than line 0.\n  return createCompoundExpression([HINT_PREFIX, ...innerChildren, HINT_SUFFIX], exp.loc)\n}\n","import {\n  createSimpleExpression,\n  NodeTypes,\n  type DirectiveNode,\n  type ElementNode,\n  type ExpressionNode,\n  type NodeTransform,\n  type RootNode,\n  type SimpleExpressionNode,\n} from '@vue/compiler-core'\nimport { flattenExpression } from './_shared-props'\n\n/**\n * `vRegisterPreambleTransform` — closes the render-order edge that\n * `vRegisterHintTransform` alone leaves open.\n *\n * The hint transform wraps each `v-register` directive expression in an\n * IIFE that calls `markConnectedOptimistically()` when the element's\n * vnode is created. That works for any expression evaluated AT or AFTER\n * the input in render order. But Vue's SSR is single-pass top-to-bottom,\n * so a template like:\n *\n *   <pre>{{ form.fields.password.connected }}</pre>\n *   <input v-register=\"form.register('password')\" />\n *\n * evaluates the `<pre>` first, BEFORE the v-register wrapper has had a\n * chance to fire. The serialized HTML carries `connected: false` for\n * password — and the post-hydration steady state shows `true`, leaving\n * a one-tick `false → true` flicker visible to the user.\n *\n * Fix: hoist the marks one level up. We walk the entire template AST,\n * collect every static `v-register` binding (skipping descendants of\n * `v-for`, since those reference loop locals not available at root\n * scope), and prepend a synthetic `:data-atta-pre-mark` directive on the\n * first root element. Vue evaluates element prop bindings before\n * recursing into children, so the IIFE inside `:data-atta-pre-mark` fires\n * every collected mark BEFORE any descendant template expression runs.\n *\n * The binding's expression resolves to `undefined`, which Vue's SSR\n * renderer drops (no `data-atta-pre-mark` attribute appears in the\n * rendered HTML). The side effect — flipping `connected: true` on\n * each field record — is the only output we want.\n *\n * Companion to `vRegisterHintTransform`: register both, with this one\n * BEFORE the hint transform. The pre-order pass here captures each\n * `v-register` expression's original (un-wrapped) text into a\n * per-template state map; the hint transform then wraps the in-place\n * directive expression. The exit hook on the first root element\n * builds the preamble using the captured originals — exit hooks on\n * an element fire before `transformElement`'s codegen exit, so the\n * injected prop lands in the rendered output.\n *\n * For `v-for` descendants the per-element wrapper from\n * `vRegisterHintTransform` is still load-bearing — those bindings can't\n * be hoisted because their path expressions reference loop-scoped\n * identifiers (e.g. `form.register(`item.${i}`)`).\n */\n\n/**\n * Per-root traversal state. Keyed by the RootNode object — stable for\n * the duration of one compile pass and GC-friendly across pipelines.\n *   - `captured`: collected pre-wrap expression strings, in template\n *     visit order.\n *   - `vForDepth`: nesting count for `v-for` ancestry, bumped on FOR\n *     entry / decremented on FOR exit, so element visits in between\n *     can skip captures cheaply.\n *   - `firstRootElementVisited`: ensures we only register the\n *     injection exit-hook on the very first root element (templates\n *     with multiple top-level elements still have one \"first\" — Vue\n *     wraps multi-root in a fragment, but the FIRST element's props\n *     evaluate before any sibling).\n */\ntype TraversalState = {\n  readonly captured: string[]\n  /**\n   * Elements whose v-register binding has already been captured for\n   * THIS root traversal. Guards against double-capture when the same\n   * transform is registered twice in the `nodeTransforms` array (some\n   * bundler chains do this) — without it, every binding's mark call\n   * would be duplicated in the injected expression.\n   */\n  readonly capturedElements: WeakSet<ElementNode>\n  vForDepth: number\n  firstRootElementVisited: boolean\n}\nconst stateByRoot: WeakMap<RootNode, TraversalState> = new WeakMap()\n\nconst PREAMBLE_ATTR = 'data-atta-pre-mark'\n\n/**\n * Vue compiler node transform that hoists `v-register`'s SSR\n * connection marks to the root of the template. Together with\n * `vRegisterHintTransform`, ensures expressions earlier in the\n * template that read `getFieldState(path).connected` see the\n * correct value during the server's single-pass render.\n *\n * Must run before `vRegisterHintTransform`. Wired automatically\n * by `attaform/vite` and `attaform/nuxt`.\n */\nexport const vRegisterPreambleTransform: NodeTransform = (node, context) => {\n  try {\n    if (node.type === NodeTypes.ROOT) {\n      // If state already exists, a duplicate registration of this\n      // transform is at work — keep the first run's state intact.\n      // Otherwise its captures would get wiped by this re-init.\n      if (stateByRoot.has(node)) return\n      stateByRoot.set(node, {\n        captured: [],\n        capturedElements: new WeakSet<ElementNode>(),\n        vForDepth: 0,\n        firstRootElementVisited: false,\n      })\n      return () => {\n        // Cleanup on root exit. The actual injection happened on the\n        // first root element's exit (registered below) — by the time\n        // we get here, that element's transformElement codegen has\n        // already absorbed the injected prop.\n        stateByRoot.delete(node)\n      }\n    }\n\n    const state = stateByRoot.get(context.root)\n    if (state === undefined) return\n\n    if (node.type === NodeTypes.FOR) {\n      // The structural `transformFor` (built into compiler-core, runs\n      // before our transform) wraps any element carrying v-for in a\n      // NodeTypes.FOR node. Bumping the depth on entry / decrementing\n      // on exit gives us O(1) \"am I inside a v-for ancestor?\" checks\n      // during the element visits below.\n      state.vForDepth += 1\n      return () => {\n        state.vForDepth -= 1\n      }\n    }\n\n    if (node.type !== NodeTypes.ELEMENT) return\n\n    // Capture this element's v-register binding (if any) BEFORE\n    // deciding about exit-hook registration — that way the very first\n    // root element, which itself might carry v-register, contributes\n    // its binding to the preamble it hosts.\n    captureVRegisterIfStatic(node, state)\n\n    // First root element — register the exit hook that injects the\n    // preamble using the FINAL collected state. Exit hooks fire after\n    // children are traversed, so by then every descendant capture has\n    // landed in `state.captured`.\n    if (!state.firstRootElementVisited && context.parent?.type === NodeTypes.ROOT) {\n      state.firstRootElementVisited = true\n      return () => {\n        const finalState = stateByRoot.get(context.root)\n        if (finalState === undefined || finalState.captured.length === 0) return\n        injectPreamble(node, finalState.captured)\n      }\n    }\n    return\n  } catch (err) {\n    // AST shape drift or a malformed directive: skip this transform\n    // entirely. The per-element vRegisterHintTransform still covers\n    // the common case (read at-or-after the input). Failure here only\n    // affects the read-before-input edge.\n    console.error('[attaform] v-register preamble transform failed, skipping:', err)\n    return\n  }\n}\n\nfunction captureVRegisterIfStatic(node: ElementNode, state: TraversalState): void {\n  if (state.vForDepth > 0) return\n  // An element that itself carries v-for hasn't been wrapped yet by\n  // transformFor at the moment user transforms see it (transform\n  // ordering varies by bundler), so check the directive directly.\n  if (hasVForDirective(node)) return\n  // Idempotency: only one capture per element per root traversal.\n  // Without this, registering the transform twice in the\n  // `nodeTransforms` array would double every binding's mark call\n  // inside the injected expression.\n  if (state.capturedElements.has(node)) return\n\n  const exp = findVRegisterExpression(node)\n  if (exp === null) return\n  state.capturedElements.add(node)\n  // Pre-wrap capture. This transform is registered BEFORE\n  // vRegisterHintTransform, so prop.exp is still the original\n  // expression here; the hint's wrap happens after our pre-order\n  // returns from the same node.\n  state.captured.push(flattenExpression(exp))\n}\n\nfunction findVRegisterExpression(node: ElementNode): ExpressionNode | null {\n  for (const prop of node.props) {\n    if (prop.type !== NodeTypes.DIRECTIVE) continue\n    if (prop.name !== 'register') continue\n    if (prop.exp === undefined) continue\n    return prop.exp\n  }\n  return null\n}\n\nfunction hasVForDirective(node: ElementNode): boolean {\n  for (const prop of node.props) {\n    if (prop.type === NodeTypes.DIRECTIVE && prop.name === 'for') return true\n  }\n  return false\n}\n\n/**\n * Build and prepend the `:data-atta-pre-mark` directive to the element's\n * props. The expression is a comma-chain of\n * `(<expr>)?.markConnectedOptimistically?.()` calls, ending in\n * `undefined` so the attribute resolves to `undefined` and Vue's SSR\n * renderer omits it entirely. Side effects (the marks) happen during\n * evaluation; no observable HTML attribute appears.\n *\n * The exp is a SimpleExpressionNode with `isStatic: false` — when\n * `transformElement`'s exit codegen processes it, identifiers like\n * `form` get prefixed (`_ctx.form`) the same way every other dynamic\n * binding does. This works because our exit hook runs BEFORE\n * `transformElement`'s exit (we're registered later in the\n * `nodeTransforms` array, so our exit fires earlier in the reverse\n * pass).\n */\nfunction injectPreamble(element: ElementNode, captured: readonly string[]): void {\n  if (hasPreamble(element)) return\n\n  // Each entry is wrapped in a try/catch IIFE: the preamble is best-\n  // effort optimisation (only matters for the read-before-input edge,\n  // see the file header), and any throw inside one entry must not\n  // prevent the rest from firing or break SSR. Common throw paths the\n  // catch covers: a v-register against a null `ctx` (e.g. when\n  // `injectForm` returned null and the input is gated by a v-if\n  // the AST walker can't see — the v-if check fires later, so the\n  // preamble would otherwise dereference null here).\n  const callList = captured\n    .map((source) => `(()=>{try{(${source})?.markConnectedOptimistically?.()}catch{}})()`)\n    .join(', ')\n  const expressionText = `(${callList}, undefined)`\n  const exp: SimpleExpressionNode = createSimpleExpression(expressionText, false /* not static */)\n\n  const directive: DirectiveNode = {\n    type: NodeTypes.DIRECTIVE,\n    name: 'bind',\n    arg: createSimpleExpression(PREAMBLE_ATTR, true /* static arg */),\n    exp,\n    modifiers: [],\n    // Reuse the host element's source location so any runtime error\n    // in the synthesized expression points at the consumer's template\n    // line, not at the dummyLoc that pre-fix was line 0.\n    loc: element.loc,\n  }\n  element.props.unshift(directive)\n}\n\nfunction hasPreamble(element: ElementNode): boolean {\n  for (const prop of element.props) {\n    if (prop.type !== NodeTypes.DIRECTIVE) continue\n    if (prop.name !== 'bind') continue\n    if (prop.arg === undefined) continue\n    if (prop.arg.type !== NodeTypes.SIMPLE_EXPRESSION) continue\n    if (prop.arg.content === PREAMBLE_ATTR) return true\n  }\n  return false\n}\n"],"names":["key","value","generateEqualityExpression","previousOptionExpressions","registerSummarizedProp","elementValueSummarizedProp"],"mappings":"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"}