attaform 0.19.0 → 0.20.1

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

@@ -0,0 +1 @@
+{"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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"}

package/dist/shared/{attaform.ePUcKxId.d.cts → attaform.D5-1XGQU.d.cts}

@@ -1,4 +1,4 @@
-import { t as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, T as PathKey, S as Path, am as ValidationError, A as AbstractSchema, x as GetDisplayState, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, Y as PersistOptInRegistry, aa as Segment, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.C0uGZQ4M.cjs';
+import { t as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, T as PathKey, S as Path, am as ValidationError, A as AbstractSchema, x as GetDisplayState, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, Y as PersistOptInRegistry, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.SfhU0OEY.cjs';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -61,7 +61,7 @@ type FormStatus = {
  * entry carries the formKey + path tuple so consumers can route to the
  * offending field from a wizard-wide error summary.
  */
-type AggregateError = {
+type WizardAggregateError = {
     readonly formKey: FormKey;
     readonly path: ReadonlyArray<string | number>;
     readonly message: string;
@@ -213,7 +213,7 @@ type WizardOnSubmit = (ctx: WizardSubmitContext) => void | Promise<void>;
  * validation and activation failures (`atta:activation-failed`). Sync
  * or async; the returned promise gates `wizard.submitting`.
  */
-type WizardOnError = (errors: readonly AggregateError[]) => void | Promise<void>;
+type WizardOnError = (errors: readonly WizardAggregateError[]) => void | Promise<void>;
 /**
  * Options for `useWizard({ steps, … })`. `steps` is the only required
  * field; the rest are optional and default sensibly for the common
@@ -439,7 +439,7 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly count: number;
     readonly statuses: WizardStatusesProxy<Record<string, FormStatus>>;
     readonly allValues: Readonly<Record<FormKey, unknown>>;
-    readonly allErrors: Readonly<Record<FormKey, readonly AggregateError[]>>;
+    readonly allErrors: Readonly<Record<FormKey, readonly WizardAggregateError[]>>;
     readonly progress: number;
     readonly canAdvance: boolean;
     readonly canGoBack: boolean;
@@ -701,6 +701,15 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * plain-value forms. Read by `form.rehydrate()`.
      */
     readonly defaultValuesFactory: Ref<(() => unknown | Promise<unknown>) | undefined>;
+    /**
+     * `true` when this store carries an SSR prefetch queue (server path
+     * where `state.activate()` must enqueue intent before deciding
+     * whether to fire). The flag lets `buildFormApi` skip the lazy
+     * activation gate for forms with no factory AND no SSR prefetch —
+     * the common client-side case where `gated()` is otherwise pure
+     * reactive overhead on every public method call.
+     */
+    readonly hasSsrPrefetch: boolean;
     /**
      * `true` once the form's effective defaults have been applied —
      * sync `defaultValues` at construction, or async factory whose
@@ -797,6 +806,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * answer.
      */
     pathHasAsyncValidation(path: Path): boolean;
+    /**
+     * Precomputed-key shortcut for `pathHasAsyncValidation`. The
+     * canonical key is required and must correspond to `segments`; the
+     * helper skips the `canonicalizePath` round-trip so descendant-walk
+     * loops (whose Map iteration already yields the canonical key) can
+     * read the async-gate verdict without a per-leaf canonicalize.
+     */
+    pathHasAsyncValidationByKey(key: PathKey, segments: Path): boolean;
     /**
      * Per-path counter of in-flight field-level validation runs.
      * `field.validating` on `FieldState` mirrors
@@ -852,14 +869,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     arrayElementKey(path: Path): string;
     reset(nextDefaultValues?: DeepPartial<WriteShape<F>>): void;
     resetField(path: Path): void;
-    /**
-     * Wipe `path` (or the whole form when `path === ''`) to the
-     * schema's "appropriate nullish value" — the underlying type's
-     * empty/falsy concrete, with `.default()` / `.catch()` wrappers
-     * INTENTIONALLY skipped. Sugar for
-     * `setValueAtPath(path, schema.getEmptyValueAtPath(path))`.
-     */
-    clear(path: Path): boolean;
     setSchemaErrorsForPath(path: Path, errors: ValidationError[]): void;
     setAllSchemaErrors(errors: readonly ValidationError[]): void;
     clearSchemaErrors(path?: Path): void;
@@ -912,7 +921,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     markFocused(path: Path, focused: boolean, meta?: {
         readonly instance?: WriteMeta['instance'];
     }): void;
-    markTouched(path: Path): void;
     /**
      * Flip `interacted: true` on a leaf — the sticky value-mutation flag.
      * Driven by the directive's input listeners (via the RegisterValue's
@@ -945,6 +953,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * isn't exposed to consumers.
      */
     isPristineAtPath(path: Path): boolean;
+    /**
+     * Precomputed-key shortcut for `isPristineAtPath`. The canonical
+     * key is required and must correspond to `segments`; the helper
+     * skips the `canonicalizePath` round-trip so descendant-walk loops
+     * (whose Map iteration already yields the canonical key) can read
+     * the pristine verdict without a per-leaf canonicalize.
+     */
+    isPristineAtPathByKey(key: PathKey, segments: Path): boolean;
     /**
      * Whether any tracked array under `path` has changed shape — a reorder,
      * insert, or removal — relative to its construction/reset baseline. The
@@ -1086,7 +1102,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * Resolved sensitive-path predicate for THIS form. Honors the
      * cascade (`useForm({ sensitiveNames })` > global default >
      * library `DEFAULT_SENSITIVE_NAMES`). Used by:
-     *  - persistence enforcement (`enforceSensitiveCheck` at write time);
+     *  - the persistence opt-in gate (`allowSensitivePersist`);
      *  - the multi-tab sync module (outbound strip + inbound reject);
      *  - DevTools edit rejection;
      *  - any future surface that needs to flag "this path holds
@@ -1097,14 +1113,6 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * resolved-config surface.
      */
     readonly isSensitivePath: (path: Path | PathKey | string) => boolean;
-    /**
-     * Single-segment variant of `isSensitivePath`. Used by the DevTools
-     * redact walk to short-circuit whole subtrees the moment any
-     * ancestor segment matches — saving an O(leaves × ancestors) regex
-     * sweep per timeline event. Resolved from the same `sensitiveNames`
-     * cascade as `isSensitivePath`.
-     */
-    readonly segmentMatchesSensitive: (segment: Segment) => boolean;
     /**
      * Canonical path keys explicitly opted OUT of multi-tab sync by
      * `register(path, { multiTab: false })`. The sync module's outbound
@@ -1428,6 +1436,83 @@ type InjectFormInput = {
  */
 declare function injectForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form>(input?: FormKey | InjectFormInput): UseFormReturnType<Form, GetValueFormType> | null;
 
+/**
+ * Re-bind a parent's `v-register` onto an inner native element. Use
+ * inside a component that wraps a single form field whose root is
+ * NOT the input itself (e.g. a labelled-row that renders `<label>`
+ * around the input).
+ *
+ * ```vue
+ * <!-- Parent -->
+ * <MyInput v-register="form.register('email')" />
+ *
+ * <!-- MyInput.vue -->
+ * <script setup lang="ts">
+ *   import { useRegister } from 'attaform'
+ *   const rv = useRegister()
+ *   // rv.path / rv.segments / rv.formKey / rv.formInstanceId / rv.innerRef
+ *   // are all reachable directly — no `.value` unwrap.
+ * </script>
+ *
+ * <template>
+ *   <label class="field">
+ *     <span>Email</span>
+ *     <input v-register="rv" />
+ *   </label>
+ * </template>
+ * ```
+ *
+ * Returns a hybrid Proxy: it answers `__v_isRef` / `.value` like a
+ * Vue `Ref<RegisterValue | undefined>` (so templates auto-unwrap
+ * correctly and `v-register="rv"` feeds the underlying RV to the
+ * directive — preserving the directive's path-migration diff across
+ * renders), AND every other property read pierces to the captured
+ * RV's field (so `rv.path` works directly in script setup). Reads
+ * inside reactive scopes (`computed` / `watchEffect`) track the
+ * underlying `shallowRef`, so `rv.path` re-runs when the parent
+ * rebinds to a different path.
+ *
+ * Unbound state: when the parent didn't pass `v-register`, every
+ * piercing read returns `undefined` at runtime, and the return type
+ * surfaces this honestly as `UseRegisterReturn<V> | undefined`.
+ * Consumers defend with optional chaining (`rv?.formKey`,
+ * `rv?.segments`); the directive accepts `undefined` peacefully (its
+ * binding value type is already `RegisterValue<V> | undefined`), so
+ * `v-register="rv"` works whether or not a parent has bound. The
+ * composable's `onMounted` warn fires once per instance to surface
+ * the misuse case at runtime.
+ *
+ * Diagnostic: in dev mode, a single `console.warn` fires per instance
+ * at `onMounted` if the captured value is still `undefined` — by then
+ * the parent has had its full mount lifecycle to bind, so a missing
+ * binding is conclusive misuse. The warn does NOT fire on every read
+ * of the proxy, and is intentionally silent under SSR
+ * (`renderToString` skips `onMounted`); the CSR hydration pass
+ * surfaces the same diagnostic without double-counting through Nuxt's
+ * `dev:ssr-logs` channel.
+ *
+ * When the wrapper's root IS the input itself, Vue's attribute
+ * fallthrough handles the binding and `useRegister` is unnecessary.
+ * For wrappers that bind multiple fields (compound forms), use
+ * `injectForm<Form>(key?)` and call `ctx.register(...)` directly.
+ */
+
+/**
+ * Return type of `useRegister()`. Hybrid of `RegisterValue<V>` (so
+ * `rv.path` / `rv.segments` / `rv.formKey` etc. work directly in
+ * script setup) and `Ref<RegisterValue<V> | undefined>` (so Vue's
+ * template auto-unwrap surfaces the underlying RV to `v-register`
+ * and the directive's path-migration diff sees the real RV across
+ * renders).
+ *
+ * The two surfaces don't clash at the type level: `RegisterValue`
+ * doesn't carry a `value` field, and `Ref<T>`'s `value: T` becomes
+ * the hybrid's only `.value`. Older code that read `rv.value?.path`
+ * keeps working; new code can write `rv.path` directly.
+ */
+type UseRegisterReturn<V = unknown> = RegisterValue<V> & Ref<RegisterValue<V> | undefined>;
+declare function useRegister<V = unknown>(): UseRegisterReturn<V> | undefined;
+
 /**
  * Multistep-form orchestrator built around an ordered list of step slots.
  * Each slot resolves to a participating form: an existing `useForm`
@@ -1543,83 +1628,6 @@ declare function injectWizard(input?: string | InjectWizardInput): UseWizardRetu
  */
 declare function lazy<Ctx = WizardCtx>(resolve: (ctx: Ctx) => AnyForm | string | undefined): LazyMarker<Ctx>;
 
-/**
- * Re-bind a parent's `v-register` onto an inner native element. Use
- * inside a component that wraps a single form field whose root is
- * NOT the input itself (e.g. a labelled-row that renders `<label>`
- * around the input).
- *
- * ```vue
- * <!-- Parent -->
- * <MyInput v-register="form.register('email')" />
- *
- * <!-- MyInput.vue -->
- * <script setup lang="ts">
- *   import { useRegister } from 'attaform'
- *   const rv = useRegister()
- *   // rv.path / rv.segments / rv.formKey / rv.formInstanceId / rv.innerRef
- *   // are all reachable directly — no `.value` unwrap.
- * </script>
- *
- * <template>
- *   <label class="field">
- *     <span>Email</span>
- *     <input v-register="rv" />
- *   </label>
- * </template>
- * ```
- *
- * Returns a hybrid Proxy: it answers `__v_isRef` / `.value` like a
- * Vue `Ref<RegisterValue | undefined>` (so templates auto-unwrap
- * correctly and `v-register="rv"` feeds the underlying RV to the
- * directive — preserving the directive's path-migration diff across
- * renders), AND every other property read pierces to the captured
- * RV's field (so `rv.path` works directly in script setup). Reads
- * inside reactive scopes (`computed` / `watchEffect`) track the
- * underlying `shallowRef`, so `rv.path` re-runs when the parent
- * rebinds to a different path.
- *
- * Unbound state: when the parent didn't pass `v-register`, every
- * piercing read returns `undefined` at runtime, and the return type
- * surfaces this honestly as `UseRegisterReturn<V> | undefined`.
- * Consumers defend with optional chaining (`rv?.formKey`,
- * `rv?.segments`); the directive accepts `undefined` peacefully (its
- * binding value type is already `RegisterValue<V> | undefined`), so
- * `v-register="rv"` works whether or not a parent has bound. The
- * composable's `onMounted` warn fires once per instance to surface
- * the misuse case at runtime.
- *
- * Diagnostic: in dev mode, a single `console.warn` fires per instance
- * at `onMounted` if the captured value is still `undefined` — by then
- * the parent has had its full mount lifecycle to bind, so a missing
- * binding is conclusive misuse. The warn does NOT fire on every read
- * of the proxy, and is intentionally silent under SSR
- * (`renderToString` skips `onMounted`); the CSR hydration pass
- * surfaces the same diagnostic without double-counting through Nuxt's
- * `dev:ssr-logs` channel.
- *
- * When the wrapper's root IS the input itself, Vue's attribute
- * fallthrough handles the binding and `useRegister` is unnecessary.
- * For wrappers that bind multiple fields (compound forms), use
- * `injectForm<Form>(key?)` and call `ctx.register(...)` directly.
- */
-
-/**
- * Return type of `useRegister()`. Hybrid of `RegisterValue<V>` (so
- * `rv.path` / `rv.segments` / `rv.formKey` etc. work directly in
- * script setup) and `Ref<RegisterValue<V> | undefined>` (so Vue's
- * template auto-unwrap surfaces the underlying RV to `v-register`
- * and the directive's path-migration diff sees the real RV across
- * renders).
- *
- * The two surfaces don't clash at the type level: `RegisterValue`
- * doesn't carry a `value` field, and `Ref<T>`'s `value: T` becomes
- * the hybrid's only `.value`. Older code that read `rv.value?.path`
- * keeps working; new code can write `rv.path` directly.
- */
-type UseRegisterReturn<V = unknown> = RegisterValue<V> & Ref<RegisterValue<V> | undefined>;
-declare function useRegister<V = unknown>(): UseRegisterReturn<V> | undefined;
-
 /**
  * Stable identifiers for library-emitted `ValidationError` codes.
  *
@@ -1680,5 +1688,5 @@ declare const AttaformErrorCode: {
 };
 type AttaformErrorCode = (typeof AttaformErrorCode)[keyof typeof AttaformErrorCode];
 
-export { AttaformErrorCode as b, createRegistry as p, defaultCoercionRules as q, defineCoercion as r, getRegistryFromApp as s, injectForm as t, injectWizard as u, kAttaformRegistry as v, lazy as w, useRegister as x, useRegistry as y, useWizard as z };
-export type { AggregateError as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardCtx as W, AnyForm as a, AttaformRegistry as c, SerializedFormData as d, StepSlot as e, UseWizardReturnType as f, WizardCtxForm as g, WizardOnError as h, WizardOnSubmit as i, WizardOptions as j, WizardPersistFn as k, WizardRestoreFn as l, WizardRestoreState as m, WizardStatusesProxy as n, WizardSubmitContext as o };
+export { AttaformErrorCode as a, createRegistry as p, defaultCoercionRules as q, defineCoercion as r, getRegistryFromApp as s, injectForm as t, injectWizard as u, kAttaformRegistry as v, lazy as w, useRegister as x, useRegistry as y, useWizard as z };
+export type { AnyForm as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardAggregateError as W, AttaformRegistry as b, SerializedFormData as c, StepSlot as d, UseWizardReturnType as e, WizardCtx as f, WizardCtxForm as g, WizardOnError as h, WizardOnSubmit as i, WizardOptions as j, WizardPersistFn as k, WizardRestoreFn as l, WizardRestoreState as m, WizardStatusesProxy as n, WizardSubmitContext as o };