attaform 0.24.3 → 0.25.0

package/dist/shared/{attaform.CjdepGnw.cjs → attaform.ZXZ6dH72.cjs}

@@ -5,6 +5,7 @@ const vue = require('vue');
 const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
 const REGISTER_OWNER_MARKER = Symbol.for("attaform:register-owner-marker");
 const SSR_COMPONENT_HOST_MODIFIER = "attaformComponentHost";
+const V_REGISTER_COMPILED_MODIFIER = "attaformCompiled";
 function isRegisterValue(val) {
   if (typeof val !== "object" || val === null) return false;
   if (!("innerRef" in val)) return false;
@@ -21,7 +22,8 @@ function isTransforming(value) {
 
 exports.REGISTER_OWNER_MARKER = REGISTER_OWNER_MARKER;
 exports.SSR_COMPONENT_HOST_MODIFIER = SSR_COMPONENT_HOST_MODIFIER;
+exports.V_REGISTER_COMPILED_MODIFIER = V_REGISTER_COMPILED_MODIFIER;
 exports.V_REGISTER_MARKER = V_REGISTER_MARKER;
 exports.isRegisterValue = isRegisterValue;
 exports.isTransforming = isTransforming;
-//# sourceMappingURL=attaform.CjdepGnw.cjs.map
+//# sourceMappingURL=attaform.ZXZ6dH72.cjs.map

package/dist/shared/attaform.ZXZ6dH72.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.ZXZ6dH72.cjs","sources":["../../src/runtime/core/register-protocol.ts"],"sourcesContent":["import { isRef } from 'vue'\nimport type { InternalRegisterValue, RegisterValue } from '../types/types-api'\n\n// Shared register-protocol primitives: the markers and value guards that\n// the v-register directive, its file / lifecycle satellites, and\n// useRegister all build on. They live in this leaf (depending only on vue\n// and the types module) so those modules don't import directive.ts back,\n// which would form an import cycle.\n\n/**\n * Marker installed on the v-register directive object so consumers\n * (notably `useRegister`) can identify it in a child vnode's\n * directive list even when the consumer's bundler hasn't installed\n * attaform's compile-time transforms. `Symbol.for(...)` round-trips\n * across duplicate bundle copies: `attaform` and `attaform/zod` can\n * land on different `vRegister` references in the playground or\n * under pnpm-hoist edge cases, but both carry the same marker.\n */\nexport const V_REGISTER_MARKER: unique symbol = Symbol.for('attaform:v-register-directive')\n\n/**\n * Marker on the rendered root DOM element. Set by `useRegister`'s\n * `onMounted` hook; read by the directive's deferred warn check to\n * skip the \"is a no-op\" warn for components that handle binding via\n * an inner v-register.\n *\n * `Symbol.for(...)` so the marker round-trips across duplicate copies\n * of attaform — see `assignKey` in core/directive.ts for the same\n * reasoning. `useRegister` and the directive are typically loaded\n * from the same module copy, but a consumer importing from\n * `attaform/zod` (Vite-optimized bundle) and the Nuxt\n * plugin's relative-path import (live ESM) can land on different\n * copies; a global symbol means the marker check still works.\n */\nexport const REGISTER_OWNER_MARKER: unique symbol = Symbol.for('attaform:register-owner-marker')\n\n/**\n * Directive modifier the `componentBridgeTransform` stamps onto a\n * `v-register` that lands on a component host (or kebab custom element).\n * It is the compile-time -> runtime signal the directive's `getSSRProps`\n * reads under compiled SSR, where Vue passes a `null` vnode and the host\n * is otherwise indistinguishable from a native control. autoAria then\n * suppresses its attrs on the host root (the inner control the component\n * re-binds via useRegister carries them). Namespaced to avoid collision\n * with any author-written modifier. (#404)\n */\nexport const SSR_COMPONENT_HOST_MODIFIER = 'attaformComponentHost'\n\n/**\n * Directive modifier the `redundantBindingWarnTransform` stamps onto\n * every `v-register` it processes. It is the compile-time -> runtime\n * signal that Attaform's template transforms are active, and it lets the\n * runtime redundant-binding diagnostic (in the directive's `created`\n * hook) stand down.\n *\n * The hand-off matters because `inputTextAreaNodeTransform` strips the\n * author's `value` / `checked` and injects its own. Once that has run,\n * `vnode.props` no longer reflects what the author wrote, so a runtime\n * check would flag every field. With this marker present the compile\n * layer owns detection (it reads the authored props BEFORE injection);\n * with it absent (no bundler plugin) the runtime layer reads the\n * untouched `vnode.props` directly. Exactly one layer fires per\n * consumer, never both.\n *\n * Namespaced to avoid collision with any author-written modifier, like\n * `SSR_COMPONENT_HOST_MODIFIER` above.\n */\nexport const V_REGISTER_COMPILED_MODIFIER = 'attaformCompiled'\n\n/**\n * Type guard for a `RegisterValue`. Returns `true` when `val` looks\n * like the object returned from `form.register(path)`.\n *\n * ```ts\n * if (isRegisterValue(slotValue)) {\n *   // slotValue.innerRef is now a Ref<unknown>\n * }\n * ```\n *\n * Useful when building wrapper components that accept either a\n * `RegisterValue` or a plain ref via the same prop.\n */\nexport function isRegisterValue<Value = unknown>(val: unknown): val is RegisterValue<Value> {\n  if (typeof val !== 'object' || val === null) return false\n  if (!('innerRef' in val)) return false\n  if (!isRef(val.innerRef)) return false\n  if (!('registerElement' in val)) return false\n  if (typeof val.registerElement !== 'function') return false\n  if (!('setValueWithInternalPath' in val)) return false\n  if (typeof val.setValueWithInternalPath !== 'function') return false\n  return true\n}\n\n/**\n * `true` while a deferred async transform is in flight at this path.\n * `beginTransform` flips it synchronously inside the assigner, so a\n * listener's post-write force-sync block reads it (right after the\n * assigner returns) to skip snapping the DOM back to stale storage —\n * the resolved value is painted in by the orchestrator's `syncDom`\n * once the run lands.\n */\nexport function isTransforming(value: unknown): boolean {\n  return isRegisterValue(value) && (value as InternalRegisterValue).transforming\n}\n"],"names":["isRef"],"mappings":";;;;AAkBO,MAAM,iBAAA,GAAmC,MAAA,CAAO,GAAA,CAAI,+BAA+B;AAgBnF,MAAM,qBAAA,GAAuC,MAAA,CAAO,GAAA,CAAI,gCAAgC;AAYxF,MAAM,2BAAA,GAA8B;AAqBpC,MAAM,4BAAA,GAA+B;AAerC,SAAS,gBAAiC,GAAA,EAA2C;AAC1F,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,IAAI,EAAE,UAAA,IAAc,GAAA,CAAA,EAAM,OAAO,KAAA;AACjC,EAAA,IAAI,CAACA,SAAA,CAAM,GAAA,CAAI,QAAQ,GAAG,OAAO,KAAA;AACjC,EAAA,IAAI,EAAE,iBAAA,IAAqB,GAAA,CAAA,EAAM,OAAO,KAAA;AACxC,EAAA,IAAI,OAAO,GAAA,CAAI,eAAA,KAAoB,UAAA,EAAY,OAAO,KAAA;AACtD,EAAA,IAAI,EAAE,0BAAA,IAA8B,GAAA,CAAA,EAAM,OAAO,KAAA;AACjD,EAAA,IAAI,OAAO,GAAA,CAAI,wBAAA,KAA6B,UAAA,EAAY,OAAO,KAAA;AAC/D,EAAA,OAAO,IAAA;AACT;AAUO,SAAS,eAAe,KAAA,EAAyB;AACtD,EAAA,OAAO,eAAA,CAAgB,KAAK,CAAA,IAAM,KAAA,CAAgC,YAAA;AACpE;;;;;;;;;"}

package/dist/shared/{attaform.DUc6cetN.d.cts → attaform.i_LA3X9o.d.cts}

@@ -1396,6 +1396,14 @@ type ReactiveValidationStatus<Form> = PendingValidationStatus | SettledValidatio
  *   manually via `form.focusFirstError()` or `form.scrollToFirstError()`
  *   from an `onError` callback.
  *
+ * Both focusing policies request `focusVisible: true`, so the browser
+ * paints a focus ring even though the move is programmatic. Where a UA
+ * doesn't yet support that hint, non-text controls (radio, checkbox,
+ * custom widgets) may end up focused without a visible ring after a
+ * pointer-driven submit; if you target those browsers, pair the policy
+ * with your own indicator (e.g. a `:focus-within` ring on the option
+ * wrapper).
+ *
  * If no errored field has a currently mounted, visible element, the
  * policy silently no-ops.
  */
@@ -2442,6 +2450,16 @@ type RegisterValue<Value = unknown> = Readonly<{
      * unchanged.
      */
     setValueWithInternalPath: (value: unknown, meta?: WriteMeta) => boolean;
+    /**
+     * Commit a value emitted by a third-party component bound through
+     * `v-register`'s compile-time v-model desugar. Writes the value (the
+     * component's typed model output, authoritative -- no coercion) AND marks
+     * the field interacted, since a v-model host has no DOM input listener to
+     * flip the sticky `interacted` bit. The injected `onUpdate:modelValue`
+     * handler is the only caller. Returns `true` when the write was accepted.
+     * @internal
+     */
+    setValueFromHost: (value: unknown) => boolean;
     /**
      * Mark this field as DOM-connected during SSR so a server-rendered
      * template that reads `form.fields.<path>.connected` doesn't
@@ -2450,6 +2468,34 @@ type RegisterValue<Value = unknown> = Readonly<{
      * @internal
      */
     markConnectedOptimistically: () => void;
+    /**
+     * Mark this field DOM-connected (`true`) or disconnected (`false`) for a
+     * `v-register` component host that binds value through the v-model desugar
+     * but exposes no single inner control to register -- a composite widget,
+     * or none found. The directive calls it on mount / unmount; distinct from
+     * the SSR-only `markConnectedOptimistically`.
+     * @internal
+     */
+    markHostConnected: (connected: boolean) => void;
+    /**
+     * Mark this field focused (`true`) or blurred (`false`) for a `v-register`
+     * component host with no single latched control -- a composite widget whose
+     * focus moves between inner segments, or a control-less one. The directive
+     * tracks focusin / focusout on the widget root and forwards here, so focus
+     * state and blur-validation still arm without an element-level focus
+     * listener. Carries this binding's instance meta (its `validateOn`).
+     * @internal
+     */
+    markFocused: (focused: boolean) => void;
+    /**
+     * `true` when an element already registered for this binding's path is
+     * contained within (or equal to) `hostElement`. The directive's
+     * component-host branch reads it to tell a `useRegister` wrapper (whose
+     * inner control self-registered) from a third-party component (which
+     * registered nothing), so the latch only runs for the latter.
+     * @internal
+     */
+    hasRegisteredDescendant: (hostElement: HTMLElement) => boolean;
     /**
      * Canonical, JSON-encoded path key for this binding (e.g.
      * `'["items",0,"name"]'`). Useful for stable Map / Set keys, log
@@ -3667,8 +3713,8 @@ type FormMeta<F = unknown> = FieldState<F> & {
      * `getDisplayState` predicates) but does NOT drive the library's
      * default `getDisplayState` heuristic. The reveal-on-submit story
      * runs entirely through `submissionAttempts`, which
-     * `wizard.handleSubmit` bumps on the active form at intermediate
-     * steps and on every form at the final step.
+     * `wizard.handleSubmit` bumps on every form (it always validates the
+     * whole step list).
      *
      * Distinct from `submissionAttempts`, which counts `handleSubmit`
      * passes only — wizard departures and form submissions are tracked
@@ -4385,6 +4431,12 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      * Pass `{ preventScroll: true }` if you're scrolling separately
      * (e.g. via `scrollToFirstError`) and don't want the browser to
      * fight the explicit scroll.
+     *
+     * Requests `focusVisible: true` so the UA paints a focus ring even
+     * though the move is programmatic. Honored where supported; on
+     * browsers without it, non-text controls focused after a pointer
+     * submit may show no ring, so you may still want an app-side
+     * indicator.
      */
     focusFirstError: (options?: {
         preventScroll?: boolean;

package/dist/shared/{attaform.DUc6cetN.d.ts → attaform.i_LA3X9o.d.mts}

@@ -1396,6 +1396,14 @@ type ReactiveValidationStatus<Form> = PendingValidationStatus | SettledValidatio
  *   manually via `form.focusFirstError()` or `form.scrollToFirstError()`
  *   from an `onError` callback.
  *
+ * Both focusing policies request `focusVisible: true`, so the browser
+ * paints a focus ring even though the move is programmatic. Where a UA
+ * doesn't yet support that hint, non-text controls (radio, checkbox,
+ * custom widgets) may end up focused without a visible ring after a
+ * pointer-driven submit; if you target those browsers, pair the policy
+ * with your own indicator (e.g. a `:focus-within` ring on the option
+ * wrapper).
+ *
  * If no errored field has a currently mounted, visible element, the
  * policy silently no-ops.
  */
@@ -2442,6 +2450,16 @@ type RegisterValue<Value = unknown> = Readonly<{
      * unchanged.
      */
     setValueWithInternalPath: (value: unknown, meta?: WriteMeta) => boolean;
+    /**
+     * Commit a value emitted by a third-party component bound through
+     * `v-register`'s compile-time v-model desugar. Writes the value (the
+     * component's typed model output, authoritative -- no coercion) AND marks
+     * the field interacted, since a v-model host has no DOM input listener to
+     * flip the sticky `interacted` bit. The injected `onUpdate:modelValue`
+     * handler is the only caller. Returns `true` when the write was accepted.
+     * @internal
+     */
+    setValueFromHost: (value: unknown) => boolean;
     /**
      * Mark this field as DOM-connected during SSR so a server-rendered
      * template that reads `form.fields.<path>.connected` doesn't
@@ -2450,6 +2468,34 @@ type RegisterValue<Value = unknown> = Readonly<{
      * @internal
      */
     markConnectedOptimistically: () => void;
+    /**
+     * Mark this field DOM-connected (`true`) or disconnected (`false`) for a
+     * `v-register` component host that binds value through the v-model desugar
+     * but exposes no single inner control to register -- a composite widget,
+     * or none found. The directive calls it on mount / unmount; distinct from
+     * the SSR-only `markConnectedOptimistically`.
+     * @internal
+     */
+    markHostConnected: (connected: boolean) => void;
+    /**
+     * Mark this field focused (`true`) or blurred (`false`) for a `v-register`
+     * component host with no single latched control -- a composite widget whose
+     * focus moves between inner segments, or a control-less one. The directive
+     * tracks focusin / focusout on the widget root and forwards here, so focus
+     * state and blur-validation still arm without an element-level focus
+     * listener. Carries this binding's instance meta (its `validateOn`).
+     * @internal
+     */
+    markFocused: (focused: boolean) => void;
+    /**
+     * `true` when an element already registered for this binding's path is
+     * contained within (or equal to) `hostElement`. The directive's
+     * component-host branch reads it to tell a `useRegister` wrapper (whose
+     * inner control self-registered) from a third-party component (which
+     * registered nothing), so the latch only runs for the latter.
+     * @internal
+     */
+    hasRegisteredDescendant: (hostElement: HTMLElement) => boolean;
     /**
      * Canonical, JSON-encoded path key for this binding (e.g.
      * `'["items",0,"name"]'`). Useful for stable Map / Set keys, log
@@ -3667,8 +3713,8 @@ type FormMeta<F = unknown> = FieldState<F> & {
      * `getDisplayState` predicates) but does NOT drive the library's
      * default `getDisplayState` heuristic. The reveal-on-submit story
      * runs entirely through `submissionAttempts`, which
-     * `wizard.handleSubmit` bumps on the active form at intermediate
-     * steps and on every form at the final step.
+     * `wizard.handleSubmit` bumps on every form (it always validates the
+     * whole step list).
      *
      * Distinct from `submissionAttempts`, which counts `handleSubmit`
      * passes only — wizard departures and form submissions are tracked
@@ -4385,6 +4431,12 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      * Pass `{ preventScroll: true }` if you're scrolling separately
      * (e.g. via `scrollToFirstError`) and don't want the browser to
      * fight the explicit scroll.
+     *
+     * Requests `focusVisible: true` so the UA paints a focus ring even
+     * though the move is programmatic. Honored where supported; on
+     * browsers without it, non-text controls focused after a pointer
+     * submit may show no ring, so you may still want an app-side
+     * indicator.
      */
     focusFirstError: (options?: {
         preventScroll?: boolean;

package/dist/shared/{attaform.DUc6cetN.d.mts → attaform.i_LA3X9o.d.ts}

@@ -1396,6 +1396,14 @@ type ReactiveValidationStatus<Form> = PendingValidationStatus | SettledValidatio
  *   manually via `form.focusFirstError()` or `form.scrollToFirstError()`
  *   from an `onError` callback.
  *
+ * Both focusing policies request `focusVisible: true`, so the browser
+ * paints a focus ring even though the move is programmatic. Where a UA
+ * doesn't yet support that hint, non-text controls (radio, checkbox,
+ * custom widgets) may end up focused without a visible ring after a
+ * pointer-driven submit; if you target those browsers, pair the policy
+ * with your own indicator (e.g. a `:focus-within` ring on the option
+ * wrapper).
+ *
  * If no errored field has a currently mounted, visible element, the
  * policy silently no-ops.
  */
@@ -2442,6 +2450,16 @@ type RegisterValue<Value = unknown> = Readonly<{
      * unchanged.
      */
     setValueWithInternalPath: (value: unknown, meta?: WriteMeta) => boolean;
+    /**
+     * Commit a value emitted by a third-party component bound through
+     * `v-register`'s compile-time v-model desugar. Writes the value (the
+     * component's typed model output, authoritative -- no coercion) AND marks
+     * the field interacted, since a v-model host has no DOM input listener to
+     * flip the sticky `interacted` bit. The injected `onUpdate:modelValue`
+     * handler is the only caller. Returns `true` when the write was accepted.
+     * @internal
+     */
+    setValueFromHost: (value: unknown) => boolean;
     /**
      * Mark this field as DOM-connected during SSR so a server-rendered
      * template that reads `form.fields.<path>.connected` doesn't
@@ -2450,6 +2468,34 @@ type RegisterValue<Value = unknown> = Readonly<{
      * @internal
      */
     markConnectedOptimistically: () => void;
+    /**
+     * Mark this field DOM-connected (`true`) or disconnected (`false`) for a
+     * `v-register` component host that binds value through the v-model desugar
+     * but exposes no single inner control to register -- a composite widget,
+     * or none found. The directive calls it on mount / unmount; distinct from
+     * the SSR-only `markConnectedOptimistically`.
+     * @internal
+     */
+    markHostConnected: (connected: boolean) => void;
+    /**
+     * Mark this field focused (`true`) or blurred (`false`) for a `v-register`
+     * component host with no single latched control -- a composite widget whose
+     * focus moves between inner segments, or a control-less one. The directive
+     * tracks focusin / focusout on the widget root and forwards here, so focus
+     * state and blur-validation still arm without an element-level focus
+     * listener. Carries this binding's instance meta (its `validateOn`).
+     * @internal
+     */
+    markFocused: (focused: boolean) => void;
+    /**
+     * `true` when an element already registered for this binding's path is
+     * contained within (or equal to) `hostElement`. The directive's
+     * component-host branch reads it to tell a `useRegister` wrapper (whose
+     * inner control self-registered) from a third-party component (which
+     * registered nothing), so the latch only runs for the latter.
+     * @internal
+     */
+    hasRegisteredDescendant: (hostElement: HTMLElement) => boolean;
     /**
      * Canonical, JSON-encoded path key for this binding (e.g.
      * `'["items",0,"name"]'`). Useful for stable Map / Set keys, log
@@ -3667,8 +3713,8 @@ type FormMeta<F = unknown> = FieldState<F> & {
      * `getDisplayState` predicates) but does NOT drive the library's
      * default `getDisplayState` heuristic. The reveal-on-submit story
      * runs entirely through `submissionAttempts`, which
-     * `wizard.handleSubmit` bumps on the active form at intermediate
-     * steps and on every form at the final step.
+     * `wizard.handleSubmit` bumps on every form (it always validates the
+     * whole step list).
      *
      * Distinct from `submissionAttempts`, which counts `handleSubmit`
      * passes only — wizard departures and form submissions are tracked
@@ -4385,6 +4431,12 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      * Pass `{ preventScroll: true }` if you're scrolling separately
      * (e.g. via `scrollToFirstError`) and don't want the browser to
      * fight the explicit scroll.
+     *
+     * Requests `focusVisible: true` so the UA paints a focus ring even
+     * though the move is programmatic. Honored where supported; on
+     * browsers without it, non-text controls focused after a pointer
+     * submit may show no ring, so you may still want an app-side
+     * indicator.
      */
     focusFirstError: (options?: {
         preventScroll?: boolean;

package/dist/shared/{attaform.DwCtxauq.mjs → attaform.k9V0py0s.mjs}

@@ -1,5 +1,5 @@
 import { NodeTypes, createCompoundExpression, createSimpleExpression, ElementTypes, processExpression } from '@vue/compiler-core';
-import { S as SSR_COMPONENT_HOST_MODIFIER } from './attaform.WvcckZMD.mjs';
+import { S as SSR_COMPONENT_HOST_MODIFIER, V as V_REGISTER_COMPILED_MODIFIER } from './attaform.Vp2-CWZB.mjs';
 
 function getSummarizedProps(node) {
   if (!("props" in node)) return [];
@@ -143,7 +143,7 @@ function extractMultipleFromSelectSummarizedProps(props) {
   const value = props[priorityIndex]?.value;
   return typeof value === "string" ? value.replace(/'|"/g, "") : value ?? "true";
 }
-const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
+const RECURSABLE_NODE_TYPES$1 = /* @__PURE__ */ new Set([
   NodeTypes.ELEMENT,
   NodeTypes.FOR,
   NodeTypes.IF,
@@ -180,7 +180,7 @@ const componentBridgeTransform = (node, context) => {
     let traverseSelectNode = function(_node, previousOptionExpressions2) {
       const isOption = _node.type === NodeTypes.ELEMENT && _node.tag === "option";
       if (!isOption) {
-        if (!RECURSABLE_NODE_TYPES.has(_node.type)) return;
+        if (!RECURSABLE_NODE_TYPES$1.has(_node.type)) return;
         const hasChildren = "children" in _node;
         if (!hasChildren) return;
         for (const child of _node.children) {
@@ -190,6 +190,7 @@ const componentBridgeTransform = (node, context) => {
         }
         return;
       }
+      hasSlottedOptions = true;
       const optionProps = getSummarizedProps(_node);
       const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
       let optionValueSummarizedProp;
@@ -231,13 +232,20 @@ const componentBridgeTransform = (node, context) => {
       return;
     const registerSummarizedProp = selectSummarizedProps[registerIndex];
     const selectLoc = node.loc;
+    let hasSlottedOptions = false;
     const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
     const previousOptionExpressions = typeof multipleExpression === "string" ? [[multipleExpression]] : [multipleExpression];
+    for (const child of node.children) {
+      traverseSelectNode(child, previousOptionExpressions);
+    }
     const isStaticallyNonMultiple = multipleExpression === "false";
+    const isComponentHost = isCustomComponent || isKebabCustomElement;
+    const isSelectLikeHost = isSelect || isComponentHost && hasSlottedOptions;
+    const isPlainComponentHost = isComponentHost && !hasSlottedOptions;
     const selectProps = node.props;
     snapshotProps(selectProps);
     removePropsByName(selectProps, ["value"]);
-    if (isStaticallyNonMultiple) {
+    if (isStaticallyNonMultiple && isSelectLikeHost) {
       const valuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
       const initExpression = createCompoundExpression([
         "(",
@@ -266,8 +274,78 @@ const componentBridgeTransform = (node, context) => {
       };
       node.props.push(valueProp);
     }
-    for (const child of node.children) {
-      traverseSelectNode(child, previousOptionExpressions);
+    if (isPlainComponentHost) {
+      removePropsByName(node.props, [
+        "model",
+        "modelValue",
+        "onUpdate:modelValue",
+        "update:modelValue"
+      ]);
+      const modelValuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
+      const modelInitExpression = createCompoundExpression([
+        "(",
+        ...modelValuePropExpArray,
+        ")?.innerRef?.value"
+      ]);
+      const modelSimpleExpression = createSimpleExpression(
+        flattenExpression(modelInitExpression),
+        false
+      );
+      let modelOutputExp;
+      try {
+        modelOutputExp = processExpression(modelSimpleExpression, {
+          ...context,
+          prefixIdentifiers: false
+        });
+      } catch (err) {
+        console.error(
+          "[attaform] component-bridge transform: processExpression failed for :modelValue; falling back to the unprocessed expression.",
+          err
+        );
+        modelOutputExp = modelSimpleExpression;
+      }
+      const modelValueProp = {
+        rawName: ":modelValue",
+        arg: createSimpleExpression("modelValue", true),
+        exp: modelOutputExp,
+        name: "bind",
+        modifiers: [],
+        type: NodeTypes.DIRECTIVE,
+        loc: selectLoc
+      };
+      node.props.push(modelValueProp);
+      const updateInitExpression = createCompoundExpression([
+        "$event => (",
+        ...modelValuePropExpArray,
+        ")?.setValueFromHost?.($event)"
+      ]);
+      const updateSimpleExpression = createSimpleExpression(
+        flattenExpression(updateInitExpression),
+        false
+      );
+      let updateOutputExp;
+      try {
+        updateOutputExp = processExpression(updateSimpleExpression, {
+          ...context,
+          prefixIdentifiers: false
+        });
+      } catch (err) {
+        console.error(
+          "[attaform] component-bridge transform: processExpression failed for onUpdate:modelValue; falling back to the unprocessed expression.",
+          err
+        );
+        updateOutputExp = updateSimpleExpression;
+      }
+      const updateModelValueProp = {
+        rawName: "@update:modelValue",
+        arg: createSimpleExpression("onUpdate:modelValue", true),
+        exp: updateOutputExp,
+        name: "bind",
+        modifiers: [],
+        type: NodeTypes.DIRECTIVE,
+        loc: selectLoc
+      };
+      node.props.push(updateModelValueProp);
     }
     if (isSelect) {
       return;
@@ -436,6 +514,102 @@ const inputTextAreaNodeTransform = (node) => {
   }
 };
 
+const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
+  NodeTypes.ELEMENT,
+  NodeTypes.FOR,
+  NodeTypes.IF,
+  NodeTypes.IF_BRANCH
+]);
+function findRedundantStateBinding(props, stateNames) {
+  for (const prop of props) {
+    if (prop.type === NodeTypes.ATTRIBUTE) {
+      if (stateNames.includes(prop.name)) return prop.name;
+      continue;
+    }
+    if (prop.name === "model") return "v-model";
+    if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && stateNames.includes(prop.arg.content)) {
+      return `:${prop.arg.content}`;
+    }
+  }
+  return null;
+}
+function classifyInput(props) {
+  let staticType = null;
+  for (const prop of props) {
+    if (prop.type === NodeTypes.ATTRIBUTE) {
+      if (prop.name === "type") staticType = prop.value?.content ?? null;
+      continue;
+    }
+    if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && prop.arg.content === "type") {
+      return "dynamic";
+    }
+  }
+  if (staticType === "checkbox") return "checkbox";
+  if (staticType === "radio") return "radio";
+  if (staticType === "file") return "file";
+  return "text";
+}
+function emitRedundantWarning(tag, binding) {
+  console.warn(
+    `[attaform] \`${binding}\` is redundant beside v-register on <${tag}>. v-register already drives this field's value, so keep v-register alone and drop \`${binding}\`. (An identity \`:value\` on a radio or <option> is expected and stays silent.)`
+  );
+}
+function walkOptionsForSelected(selectNode) {
+  const visit = (candidate) => {
+    if (candidate.type === NodeTypes.ELEMENT && candidate.tag === "option") {
+      const found = findRedundantStateBinding(candidate.props, ["selected"]);
+      if (found !== null) emitRedundantWarning("option", found);
+      return;
+    }
+    if (!RECURSABLE_NODE_TYPES.has(candidate.type)) return;
+    if (!("children" in candidate)) return;
+    for (const child of candidate.children) {
+      if (typeof child === "string" || typeof child === "symbol") continue;
+      if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
+      visit(child);
+    }
+  };
+  for (const child of selectNode.children) visit(child);
+}
+function warnIfRedundant(node) {
+  if (node.tagType !== ElementTypes.ELEMENT) return;
+  const tag = node.tag;
+  if (tag === "select") {
+    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    if (found2 !== null) emitRedundantWarning("select", found2);
+    walkOptionsForSelected(node);
+    return;
+  }
+  if (tag === "textarea") {
+    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    if (found2 !== null) emitRedundantWarning("textarea", found2);
+    return;
+  }
+  if (tag !== "input") return;
+  const kind = classifyInput(node.props);
+  if (kind === "dynamic" || kind === "file") return;
+  const stateNames = kind === "checkbox" || kind === "radio" ? ["checked"] : ["value"];
+  const found = findRedundantStateBinding(node.props, stateNames);
+  if (found !== null) emitRedundantWarning("input", found);
+}
+const redundantBindingWarnTransform = (node) => {
+  try {
+    if (node.type !== NodeTypes.ELEMENT) return;
+    const registerProp = node.props.find(
+      (prop) => prop.type === NodeTypes.DIRECTIVE && prop.name === "register"
+    );
+    if (registerProp === void 0) return;
+    const alreadyProcessed = registerProp.modifiers.some(
+      (modifier) => modifier.type === NodeTypes.SIMPLE_EXPRESSION && modifier.content === V_REGISTER_COMPILED_MODIFIER
+    );
+    if (alreadyProcessed) return;
+    warnIfRedundant(node);
+    registerProp.modifiers.push(createSimpleExpression(V_REGISTER_COMPILED_MODIFIER, true));
+  } catch (err) {
+    console.error("[attaform] redundant-binding warn transform failed, skipping:", err);
+  }
+};
+
 const HINT_MARKER = "__attaRv";
 const HINT_PREFIX = `((${HINT_MARKER}) => (${HINT_MARKER}?.markConnectedOptimistically?.(), ${HINT_MARKER}))(`;
 const HINT_SUFFIX = `)`;
@@ -568,5 +742,5 @@ function hasPreamble(element) {
   return false;
 }
 
-export { vRegisterPreambleTransform as a, componentBridgeTransform as c, inputTextAreaNodeTransform as i, vRegisterHintTransform as v };
-//# sourceMappingURL=attaform.DwCtxauq.mjs.map
+export { vRegisterPreambleTransform as a, componentBridgeTransform as c, inputTextAreaNodeTransform as i, redundantBindingWarnTransform as r, vRegisterHintTransform as v };
+//# sourceMappingURL=attaform.k9V0py0s.mjs.map