attaform 0.21.0 → 0.21.2

package/dist/shared/{attaform.BA3vRDos.cjs → attaform.B5LNzqQh.cjs}

@@ -24,6 +24,11 @@ class InvalidUseFormConfigError extends AttaformError {
 }
 class SubmitErrorHandlerError extends AttaformError {
 }
+function toError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" && value.length > 0 ? value : `Submit callback threw a non-Error value (${typeof value})`;
+  return new Error(message, { cause: value });
+}
 class RegistryNotInstalledError extends AttaformError {
   constructor() {
     super(
@@ -277,125 +282,20 @@ function invokeArrayFns(fns, ...args) {
   }
 }
 
-function captureUserCallSite() {
-  const raw = new Error().stack;
-  if (typeof raw !== "string") return void 0;
-  const lines = raw.split("\n");
-  for (let i = 1; i < lines.length; i++) {
-    const frame = lines[i];
-    if (frame === void 0) continue;
-    if (/attaform[/-]forms?/i.test(frame)) continue;
-    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
-    const trimmed = frame.trim();
-    if (trimmed.length === 0) continue;
-    return shortenSourceFrame(trimmed);
-  }
-  return void 0;
-}
-function shortenSourceFrame(frame) {
-  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
-  if (match === null) return frame;
-  const [, urlOrPath, line] = match;
-  if (urlOrPath === void 0 || line === void 0) return frame;
-  let path = urlOrPath;
-  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
-  path = path.replace(/^_nuxt\//, "");
-  path = path.replace(/^\//, "");
-  return `(${path}:${line})`;
-}
-
+const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
 const REGISTER_OWNER_MARKER = Symbol.for("attaform:register-owner-marker");
-const warnedNoParentRV = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
-let warnedOutsideSetup = false;
-function makeRegisterValueProxy(capturedRegisterValue) {
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (prop === "__v_isRef") return true;
-      if (prop === "value") return capturedRegisterValue.value;
-      const v = capturedRegisterValue.value;
-      if (v === void 0) return void 0;
-      return Reflect.get(v, prop);
-    },
-    has(_target, prop) {
-      if (prop === "__v_isRef" || prop === "value") return true;
-      const v = capturedRegisterValue.value;
-      if (v === void 0) return false;
-      return Reflect.has(v, prop);
-    },
-    ownKeys(_target) {
-      const v = capturedRegisterValue.value;
-      if (v === void 0) return [];
-      return Reflect.ownKeys(v);
-    },
-    getOwnPropertyDescriptor(_target, prop) {
-      const v = capturedRegisterValue.value;
-      if (v === void 0) return void 0;
-      const desc = Reflect.getOwnPropertyDescriptor(v, prop);
-      if (desc !== void 0) {
-        desc.configurable = true;
-      }
-      return desc;
-    }
-  });
-}
-function useRegister() {
-  const instance = vue.getCurrentInstance();
-  if (instance === null) {
-    warnOutsideSetup();
-    return makeRegisterValueProxy(vue.shallowRef(void 0));
-  }
-  ensureAttaformInstalled(instance.appContext.app);
-  const capturedRegisterValue = vue.shallowRef(void 0);
-  const refreshAndStripBridgeAttrs = () => {
-    const rawAttrs = instance.attrs;
-    if ("registerValue" in rawAttrs) {
-      capturedRegisterValue.value = rawAttrs["registerValue"];
-      delete rawAttrs["registerValue"];
-    } else {
-      const dirs = instance.vnode.dirs;
-      if (dirs !== null && dirs !== void 0) {
-        for (const dir of dirs) {
-          const marked = dir.dir?.[V_REGISTER_MARKER];
-          if (marked === true) {
-            capturedRegisterValue.value = dir.value;
-            break;
-          }
-        }
-      }
-    }
-    if ("value" in rawAttrs) delete rawAttrs["value"];
-  };
-  refreshAndStripBridgeAttrs();
-  vue.onBeforeMount(refreshAndStripBridgeAttrs);
-  vue.onBeforeUpdate(refreshAndStripBridgeAttrs);
-  vue.onMounted(() => {
-    const el = instance.vnode.el;
-    if (el !== null && el !== void 0 && typeof el === "object") {
-      el[REGISTER_OWNER_MARKER] = true;
-    }
-    if (capturedRegisterValue.value === void 0) {
-      warnNoParentRV(instance);
-    }
-  });
-  return makeRegisterValueProxy(capturedRegisterValue);
-}
-function warnOutsideSetup() {
-  if (!__DEV__) return;
-  if (warnedOutsideSetup) return;
-  warnedOutsideSetup = true;
-  const frame = captureUserCallSite();
-  console.warn(
-    `[attaform] useRegister() called outside a component setup; returning an unbound RegisterValue proxy. Fix: call it inside <script setup> or a setup() function \u2014 not from an event handler or async callback.` + (frame !== void 0 ? ` ${frame}` : "")
-  );
+function isRegisterValue(val) {
+  if (typeof val !== "object" || val === null) return false;
+  if (!("innerRef" in val)) return false;
+  if (!vue.isRef(val.innerRef)) return false;
+  if (!("registerElement" in val)) return false;
+  if (typeof val.registerElement !== "function") return false;
+  if (!("setValueWithInternalPath" in val)) return false;
+  if (typeof val.setValueWithInternalPath !== "function") return false;
+  return true;
 }
-function warnNoParentRV(instance) {
-  if (!__DEV__ || warnedNoParentRV === null) return;
-  if (warnedNoParentRV.has(instance)) return;
-  warnedNoParentRV.add(instance);
-  const frame = captureUserCallSite();
-  console.warn(
-    `[attaform] useRegister: no parent registerValue prop; RegisterValue fields will read as undefined. Pass v-register on the parent: \`<YourComponent v-register="form.register('field')" />\`.` + (frame !== void 0 ? ` ${frame}` : "")
-  );
+function isTransforming(value) {
+  return isRegisterValue(value) && value.transforming;
 }
 
 const MANAGED_ARIA_ATTRS = [
@@ -506,6 +406,199 @@ function isRegisterValueLike(val) {
   return typeof val === "object" && val !== null && "markInteracted" in val && typeof val.markInteracted === "function";
 }
 
+const assignKey = Symbol.for("attaform:assign-key");
+const DEFAULT_ASSIGNER_TAG = Symbol.for("attaform:default-assigner-tag");
+function isDefaultAssigner(fn) {
+  return typeof fn === "function" && fn[DEFAULT_ASSIGNER_TAG] === true;
+}
+const CONSUMER_WRAPPED_TAG = Symbol.for("attaform:consumer-wrapped-assigner");
+function isConsumerWrapped(fn) {
+  return typeof fn === "function" && fn[CONSUMER_WRAPPED_TAG] === true;
+}
+function fireAssigner(el, registerValue, value) {
+  const fn = el[assignKey];
+  if (fn === void 0) return void 0;
+  if (isDefaultAssigner(fn) || isConsumerWrapped(fn)) {
+    return fn(value);
+  }
+  if (!isRegisterValue(registerValue)) {
+    return fn(value, void 0);
+  }
+  return wrapWithTransforms(
+    value,
+    registerValue,
+    (coerced) => fn(coerced, registerValue),
+    void 0
+  );
+}
+function isThenable(x) {
+  return x !== null && (typeof x === "object" || typeof x === "function") && typeof x.then === "function";
+}
+function makeTransformContext() {
+  const holder = { controller: null, aborted: false };
+  const ctx = {
+    get signal() {
+      if (holder.controller === null) {
+        holder.controller = new AbortController();
+        if (holder.aborted) holder.controller.abort();
+      }
+      return holder.controller.signal;
+    }
+  };
+  return { ctx, holder };
+}
+function runTransforms(initial, registerValue) {
+  const transforms = registerValue.transforms;
+  if (transforms === void 0 || transforms.length === 0) {
+    return { kind: "sync", ok: true, value: initial };
+  }
+  const { ctx, holder } = makeTransformContext();
+  let v = initial;
+  for (let i = 0; i < transforms.length; i++) {
+    const fn = transforms[i];
+    let out;
+    try {
+      out = fn(v, ctx);
+    } catch (err) {
+      logTransformFailure(registerValue.path, i, fn, err);
+      return { kind: "sync", ok: false };
+    }
+    if (isThenable(out)) {
+      const rest = transforms.slice(i + 1);
+      const seed = out;
+      const run = () => rest.reduce(
+        (acc, next) => acc.then((value) => next(value, ctx)),
+        Promise.resolve(seed)
+      );
+      return { kind: "async", run, holder };
+    }
+    v = out;
+  }
+  return { kind: "sync", ok: true, value: v };
+}
+function kickoffAsyncTransform(rv, holder, run, commit, syncDom) {
+  const token = rv.beginTransform(holder);
+  void run().then(
+    (value) => {
+      const live = rv.isCurrentTransform(token);
+      rv.endTransform(token);
+      if (!live) return;
+      const coerced = applyCoerce(value, rv);
+      const wrote = commit(coerced);
+      if (wrote === false) rv.setTransformError(transformGateRejectedError(rv.path));
+      else syncDom?.();
+    },
+    (err) => {
+      if (rv.isCurrentTransform(token)) rv.setTransformError(toTransformError(err));
+      rv.endTransform(token);
+    }
+  );
+}
+function logTransformFailure(path, index, fn, err) {
+  if (__DEV__) {
+    const namePart = fn.name !== "" ? `, '${fn.name}'` : "";
+    console.error(
+      `[attaform] transform threw for path '${path}' (index ${index}${namePart}) \u2014 write aborted. Transforms must not throw; wrap your own try/catch if the throw is recoverable. Original error:`,
+      err
+    );
+  } else {
+    console.error(
+      `[attaform] transform error \u2014 write aborted (set NODE_ENV=development for details).`
+    );
+  }
+}
+function applyCoerce(value, registerValue) {
+  return registerValue.coerce !== void 0 ? registerValue.coerce(value) : value;
+}
+function wrapWithTransforms(value, registerValue, commit, syncDom) {
+  const r = runTransforms(value, registerValue);
+  if (r.kind === "async") {
+    kickoffAsyncTransform(registerValue, r.holder, r.run, commit, syncDom);
+    return true;
+  }
+  if (!r.ok) return false;
+  const coerced = applyCoerce(r.value, registerValue);
+  return commit(coerced);
+}
+function toTransformError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" && value.length > 0 ? value : `Transform rejected with a non-Error value (${typeof value})`;
+  return new Error(message, { cause: value });
+}
+function transformGateRejectedError(path) {
+  return new Error(
+    `[attaform] transform result for path '${path}' was rejected by the field's type gate (the resolved value did not fit the schema slot).`
+  );
+}
+const getModelAssigner = (el, vnode, registerValue) => {
+  const fn = vnode.props?.["onUpdate:registerValue"] ?? vnode.props?.["on:update:registerValue"];
+  if (isArray(fn)) {
+    const fnArr = fn.filter((x) => isFunction(x));
+    const wrapped = (value) => {
+      return wrapWithTransforms(
+        value,
+        registerValue,
+        (coerced) => {
+          invokeArrayFns(fnArr, coerced, registerValue);
+          return void 0;
+        },
+        void 0
+      );
+    };
+    wrapped[CONSUMER_WRAPPED_TAG] = true;
+    return wrapped;
+  }
+  if (isFunction(fn)) {
+    const handler = fn;
+    const wrapped = (value) => {
+      return wrapWithTransforms(
+        value,
+        registerValue,
+        (coerced) => handler(coerced, registerValue),
+        void 0
+      );
+    };
+    wrapped[CONSUMER_WRAPPED_TAG] = true;
+    return wrapped;
+  }
+  const defaultAssigner = (value) => {
+    if (value === void 0 && registerValue.acceptsUndefined) {
+      return registerValue.setValueWithInternalPath(void 0);
+    }
+    return wrapWithTransforms(
+      value,
+      registerValue,
+      (coerced) => registerValue.setValueWithInternalPath(coerced),
+      el._syncFromStorage
+    );
+  };
+  defaultAssigner[DEFAULT_ASSIGNER_TAG] = true;
+  return defaultAssigner;
+};
+function makeNoopAssigner() {
+  const noop = (_) => void 0;
+  noop[DEFAULT_ASSIGNER_TAG] = true;
+  return noop;
+}
+function setAssignFunction(el, vnode, value) {
+  const current = el[assignKey];
+  if (current !== void 0 && !isDefaultAssigner(current) && !isConsumerWrapped(current)) {
+    return;
+  }
+  if (value === void 0) {
+    el[assignKey] = makeNoopAssigner();
+    return;
+  }
+  if (!isRegisterValue(value)) {
+    vue.warn(
+      `v-register expected a RegisterValue, got '${typeof value}'. Bind to form.register('field') \u2014 not the field's ref, value, or path string.`
+    );
+    el[assignKey] = makeNoopAssigner();
+    return;
+  }
+  el[assignKey] = getModelAssigner(el, vnode, value);
+}
+
 function isBlankFileValue(value) {
   if (value === null || value === void 0) return true;
   if (Array.isArray(value) && value.length === 0) return true;
@@ -513,6 +606,11 @@ function isBlankFileValue(value) {
     return true;
   return false;
 }
+function isMultipleInput(el, vnode) {
+  if (el.multiple) return true;
+  const authored = vnode.props?.["multiple"];
+  return authored === true || authored === "";
+}
 function readFilesFromInput(el) {
   const files = el.files;
   if (el.multiple) {
@@ -538,21 +636,25 @@ function maybeWarnPersistedFile(value) {
 }
 const fileScopeKey = Symbol.for("attaform:file-scope");
 const vRegisterFile = {
-  created(el, { value }) {
+  created(el, { value }, vnode) {
     if (!isRegisterValue(value)) return;
     const input = el;
     value.registerElement(input);
+    setAssignFunction(input, vnode, value);
     maybeWarnPersistedFile(value);
     const currentRaw = value.innerRef.value;
     if (isBlankFileValue(currentRaw)) {
-      const blankShape = input.multiple ? [] : null;
+      const blankShape = isMultipleInput(input, vnode) ? [] : null;
       value.setValueWithInternalPath(blankShape, { blank: true });
     }
     addTrackedListener(input, "change", () => {
       noteInteraction(value);
       const next = readFilesFromInput(input);
-      const blank = isBlankFileValue(next);
-      value.setValueWithInternalPath(next, blank ? { blank: true } : void 0);
+      if (isBlankFileValue(next)) {
+        value.setValueWithInternalPath(next, { blank: true });
+        return;
+      }
+      fireAssigner(input, value, next);
     });
     const scope = vue.effectScope(true);
     scope.run(() => {
@@ -572,7 +674,7 @@ const vRegisterFile = {
     if (!isRegisterValue(value)) return;
     const input = el;
     const currentRaw = value.innerRef.value;
-    if (isBlankFileValue(currentRaw)) {
+    if (isBlankFileValue(currentRaw) && !isTransforming(value)) {
       value.setValueWithInternalPath(currentRaw, { blank: true });
       if (input.value !== "") input.value = "";
     }
@@ -841,136 +943,48 @@ function syncElementRegistration(el, value, oldValue) {
   }
 }
 
+const valueSyncScopeKey = Symbol.for("attaform:value-sync-scope");
+function isElementFocused(el) {
+  const rootNode = el.getRootNode();
+  const activeElement = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
+  return activeElement === el;
+}
+function setupValueSync(el, source, apply, options = {}) {
+  const skipWhileFocused = options.skipWhileFocused === true;
+  const scope = vue.effectScope(true);
+  scope.run(() => {
+    vue.watch(
+      source,
+      () => {
+        if (el.composing === true) return;
+        if (skipWhileFocused && isElementFocused(el)) return;
+        apply();
+      },
+      { flush: "post" }
+    );
+  });
+  el[valueSyncScopeKey] = () => scope.stop();
+}
+function teardownValueSync(el) {
+  const carrier = el;
+  const stop = carrier[valueSyncScopeKey];
+  if (stop === void 0) return;
+  stop();
+  delete carrier[valueSyncScopeKey];
+}
+
 const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 
-const assignKey = Symbol.for("attaform:assign-key");
-function isRegisterValue(val) {
-  if (typeof val !== "object" || val === null) return false;
-  if (!("innerRef" in val)) return false;
-  if (!vue.isRef(val.innerRef)) return false;
-  if (!("registerElement" in val)) return false;
-  if (typeof val.registerElement !== "function") return false;
-  if (!("setValueWithInternalPath" in val)) return false;
-  if (typeof val.setValueWithInternalPath !== "function") return false;
-  return true;
-}
 function writeLastTypedForm(rv, next) {
   rv.lastTypedForm.value = next;
 }
-const DEFAULT_ASSIGNER_TAG = Symbol.for("attaform:default-assigner-tag");
-function isDefaultAssigner(fn) {
-  return typeof fn === "function" && fn[DEFAULT_ASSIGNER_TAG] === true;
-}
-const CONSUMER_WRAPPED_TAG = Symbol.for("attaform:consumer-wrapped-assigner");
-function isConsumerWrapped(fn) {
-  return typeof fn === "function" && fn[CONSUMER_WRAPPED_TAG] === true;
-}
-function fireAssigner(el, registerValue, value) {
-  const fn = el[assignKey];
-  if (fn === void 0) return void 0;
-  if (isDefaultAssigner(fn) || isConsumerWrapped(fn)) {
-    return fn(value);
-  }
-  if (!isRegisterValue(registerValue)) {
-    return fn(value, void 0);
-  }
-  const r = runTransforms(value, registerValue);
-  if (!r.ok) return false;
-  const coerced = applyCoerce(r.value, registerValue);
-  return fn(coerced, registerValue);
-}
 function shouldBailListener(el) {
   if (INTERACTIVE_TAG_NAMES.has(el.tagName)) return false;
   return isDefaultAssigner(el[assignKey]);
 }
-function runTransforms(initial, registerValue) {
-  const transforms = registerValue.transforms;
-  if (transforms === void 0 || transforms.length === 0) {
-    return { ok: true, value: initial };
-  }
-  let v = initial;
-  for (let i = 0; i < transforms.length; i++) {
-    const fn = transforms[i];
-    try {
-      v = fn(v);
-    } catch (err) {
-      logTransformFailure(registerValue.path, i, fn, err);
-      return { ok: false };
-    }
-  }
-  if (v instanceof Promise) {
-    logTransformAsync(registerValue.path);
-    return { ok: false };
-  }
-  return { ok: true, value: v };
-}
-function logTransformFailure(path, index, fn, err) {
-  if (__DEV__) {
-    const namePart = fn.name !== "" ? `, '${fn.name}'` : "";
-    console.error(
-      `[attaform] transform threw for path '${path}' (index ${index}${namePart}) \u2014 write aborted. Transforms must not throw; wrap your own try/catch if the throw is recoverable. Original error:`,
-      err
-    );
-  } else {
-    console.error(
-      `[attaform] transform error \u2014 write aborted (set NODE_ENV=development for details).`
-    );
-  }
-}
-function applyCoerce(value, registerValue) {
-  return registerValue.coerce !== void 0 ? registerValue.coerce(value) : value;
-}
 function applyElementCoerce(value, registerValue) {
   return registerValue.coerceElement !== void 0 ? registerValue.coerceElement(value) : value;
 }
-function logTransformAsync(path) {
-  if (__DEV__) {
-    console.error(
-      `[attaform] transform pipeline for path '${path}' returned a Promise \u2014 transforms must be sync. Use async field validation for canonicalize-before-write patterns. Write aborted.`
-    );
-  } else {
-    console.error(
-      `[attaform] transform error \u2014 write aborted (set NODE_ENV=development for details).`
-    );
-  }
-}
-const getModelAssigner = (vnode, registerValue) => {
-  const fn = vnode.props?.["onUpdate:registerValue"] ?? vnode.props?.["on:update:registerValue"];
-  if (isArray(fn)) {
-    const fnArr = fn.filter((x) => isFunction(x));
-    const wrapped = (value) => {
-      const r = runTransforms(value, registerValue);
-      if (!r.ok) return false;
-      const coerced = applyCoerce(r.value, registerValue);
-      invokeArrayFns(fnArr, coerced, registerValue);
-      return void 0;
-    };
-    wrapped[CONSUMER_WRAPPED_TAG] = true;
-    return wrapped;
-  }
-  if (isFunction(fn)) {
-    const handler = fn;
-    const wrapped = (value) => {
-      const r = runTransforms(value, registerValue);
-      if (!r.ok) return false;
-      const coerced = applyCoerce(r.value, registerValue);
-      return handler(coerced, registerValue);
-    };
-    wrapped[CONSUMER_WRAPPED_TAG] = true;
-    return wrapped;
-  }
-  const defaultAssigner = (value) => {
-    if (value === void 0 && registerValue.acceptsUndefined) {
-      return registerValue.setValueWithInternalPath(void 0);
-    }
-    const r = runTransforms(value, registerValue);
-    if (!r.ok) return false;
-    const coerced = applyCoerce(r.value, registerValue);
-    return registerValue.setValueWithInternalPath(coerced);
-  };
-  defaultAssigner[DEFAULT_ASSIGNER_TAG] = true;
-  return defaultAssigner;
-};
 function onCompositionStart(e) {
   const target = e.target;
   if (!target) return;
@@ -983,29 +997,6 @@ function onCompositionEnd(e) {
     target.dispatchEvent(new Event("input"));
   }
 }
-function makeNoopAssigner() {
-  const noop = (_) => void 0;
-  noop[DEFAULT_ASSIGNER_TAG] = true;
-  return noop;
-}
-function setAssignFunction(el, vnode, value) {
-  const current = el[assignKey];
-  if (current !== void 0 && !isDefaultAssigner(current) && !isConsumerWrapped(current)) {
-    return;
-  }
-  if (value === void 0) {
-    el[assignKey] = makeNoopAssigner();
-    return;
-  }
-  if (!isRegisterValue(value)) {
-    vue.warn(
-      `v-register expected a RegisterValue, got '${typeof value}'. Bind to form.register('field') \u2014 not the field's ref, value, or path string.`
-    );
-    el[assignKey] = makeNoopAssigner();
-    return;
-  }
-  el[assignKey] = getModelAssigner(vnode, value);
-}
 const vRegisterText = {
   created(el, { value, modifiers: { lazy, trim, number } }, vnode) {
     const castToNumberAtCreated = number === true || vnode.props?.["type"] === "number";
@@ -1014,6 +1005,13 @@ const vRegisterText = {
       value.registerElement(el);
       setAssignFunction(el, vnode, value);
     }
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      const storage = value.innerRef.value;
+      const display = storage == null ? "" : String(storage);
+      if (el.value !== display) el.value = display;
+      if (liveCastToNumber()) writeLastTypedForm(value, null);
+    };
     addTrackedListener(el, lazy === true ? "change" : "input", (e) => {
       if (shouldBailListener(el)) return;
       const target = e.target;
@@ -1061,7 +1059,7 @@ const vRegisterText = {
       }
       const commit = domValue === "" && isRegisterValue(value) && value.acceptsUndefined ? void 0 : domValue;
       fireAssigner(el, value, commit);
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         const storage = value.innerRef.value;
         if (storage !== domValue) {
           const display = storage == null ? "" : String(storage);
@@ -1121,6 +1119,15 @@ const vRegisterText = {
   mounted(el, { value }) {
     if (!isRegisterValue(value)) return;
     el.value = value.displayValue.value;
+    setupValueSync(
+      el,
+      value.displayValue,
+      () => {
+        const next = value.displayValue.value;
+        if (el.value !== next) el.value = next;
+      },
+      { skipWhileFocused: true }
+    );
   },
   beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim } }, vnode) {
     setAssignFunction(el, vnode, value);
@@ -1150,6 +1157,11 @@ const vRegisterCheckbox = {
     if (!isRegisterValue(value)) return;
     value.registerElement(el);
     setAssignFunction(el, vnode, value);
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      setChecked(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    };
     addTrackedListener(el, "change", () => {
       if (shouldBailListener(el)) return;
       noteInteraction(value);
@@ -1192,7 +1204,7 @@ const vRegisterCheckbox = {
       } else {
         fireAssigner(el, value, getCheckboxValue(el, checked));
       }
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         setChecked(el, value);
         el._lastAppliedModel = value.innerRef.value;
       }
@@ -1201,7 +1213,12 @@ const vRegisterCheckbox = {
   // set initial checked on mount to wait for true-value/false-value
   mounted(el, { value }) {
     setChecked(el, value);
-    if (isRegisterValue(value)) el._lastAppliedModel = value.innerRef.value;
+    if (!isRegisterValue(value)) return;
+    el._lastAppliedModel = value.innerRef.value;
+    setupValueSync(el, value.innerRef, () => {
+      setChecked(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    });
   },
   // Skip the DOM sync when the model is identity-unchanged from the
   // last application. Pre-fix the scalar branch in `setChecked`
@@ -1247,11 +1264,18 @@ const vRegisterRadio = {
     if (!isRegisterValue(value)) return;
     value.registerElement(el);
     setAssignFunction(el, vnode, value);
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      const currentModel = value.innerRef.value;
+      const target = looseEqual(currentModel, applyCoerce(getValue(el), value));
+      if (el.checked !== target) el.checked = target;
+      el._lastAppliedModel = currentModel;
+    };
     addTrackedListener(el, "change", () => {
       if (shouldBailListener(el)) return;
       noteInteraction(value);
       fireAssigner(el, value, getValue(el));
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         const currentModel = value.innerRef.value;
         const target = looseEqual(currentModel, applyCoerce(getValue(el), value));
         if (el.checked !== target) el.checked = target;
@@ -1270,6 +1294,10 @@ const vRegisterRadio = {
     if (!isRegisterValue(value)) return;
     el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
     el._lastAppliedModel = value.innerRef.value;
+    setupValueSync(el, value.innerRef, () => {
+      el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
+      el._lastAppliedModel = value.innerRef.value;
+    });
   },
   // Skip the DOM sync when the model is identity-unchanged from the
   // last application. Pre-fix the guard read `value.innerRef.value
@@ -1295,6 +1323,11 @@ const vRegisterSelect = {
   created(el, { value, modifiers: { number } }, vnode) {
     if (!isRegisterValue(value)) return;
     value.registerElement(el);
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      setSelected(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    };
     addTrackedListener(el, "change", () => {
       if (shouldBailListener(el)) return;
       noteInteraction(value);
@@ -1311,7 +1344,7 @@ const vRegisterSelect = {
           el._assigning = false;
         });
       }
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         setSelected(el, value);
         el._lastAppliedModel = value.innerRef.value;
       }
@@ -1322,7 +1355,13 @@ const vRegisterSelect = {
   // <option>s.
   mounted(el, { value }) {
     setSelected(el, value);
-    if (isRegisterValue(value)) el._lastAppliedModel = value.innerRef.value;
+    if (!isRegisterValue(value)) return;
+    el._lastAppliedModel = value.innerRef.value;
+    setupValueSync(el, value.innerRef, () => {
+      if (el._assigning === true) return;
+      setSelected(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    });
   },
   beforeUpdate(el, binding, vnode) {
     setAssignFunction(el, vnode, binding.value);
@@ -1420,6 +1459,9 @@ const vRegisterDynamic = {
     syncMultiTabOptOut(binding.value, void 0);
     callModelHook(el, binding, vnode, null, "created");
     if (isRegisterValue(binding.value)) setupAria(el, binding.value, vnode);
+  },
+  mounted(el, binding, vnode) {
+    callModelHook(el, binding, vnode, null, "mounted");
     if (__DEV__ && warnedUnsupportedElements !== null && !INTERACTIVE_TAG_NAMES.has(el.tagName) && !warnedUnsupportedElements.has(el)) {
       void vue.nextTick(() => {
         if (warnedUnsupportedElements.has(el)) return;
@@ -1435,9 +1477,6 @@ const vRegisterDynamic = {
       });
     }
   },
-  mounted(el, binding, vnode) {
-    callModelHook(el, binding, vnode, null, "mounted");
-  },
   beforeUpdate(el, binding, vnode, prevVNode) {
     syncPersistOptIn(el, binding.value, binding.oldValue, vnode.props?.["type"]);
     syncMultiTabOptOut(binding.value, binding.oldValue);
@@ -1465,6 +1504,7 @@ const vRegisterDynamic = {
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
     teardownAria(el);
+    teardownValueSync(el);
     if (isRegisterValue(value)) {
       value.persistOptIns.removeAllFor(getOrAssignElementId(el));
       value.unmarkNoSync?.();
@@ -1473,6 +1513,7 @@ const vRegisterDynamic = {
     value.deregisterElement(el);
     delete el.composing;
     delete el._assigning;
+    delete el._syncFromStorage;
     delete el[assignKey];
   },
   // The lifecycle hooks above don't run on the server (Vue skips
@@ -1485,7 +1526,11 @@ const vRegisterDynamic = {
   getSSRProps(binding, vnode) {
     const rv = binding.value;
     if (!isRegisterValue(rv)) return void 0;
-    return getSSRAriaProps(rv, vnode ?? null);
+    const realVnode = vnode ?? null;
+    const ariaProps = getSSRAriaProps(rv, realVnode);
+    const formStateProps = realVnode !== null ? getSSRFormStateProps(rv, realVnode) : void 0;
+    if (ariaProps === void 0 && formStateProps === void 0) return void 0;
+    return { ...ariaProps, ...formStateProps };
   }
 };
 function resolveDynamicModel(tagName, type) {
@@ -1497,12 +1542,38 @@ function resolveDynamicModel(tagName, type) {
   if (type === "radio") return vRegisterRadio;
   return vRegisterText;
 }
+function ssrCheckboxProps(rv, props) {
+  const model = rv.innerRef.value;
+  const optionValue = props?.["value"];
+  let checked;
+  if (isArray(model)) {
+    checked = looseIndexOf(model, applyElementCoerce(optionValue, rv)) > -1;
+  } else if (isSet(model)) {
+    checked = model.has(applyElementCoerce(optionValue, rv));
+  } else {
+    const trueValue = props !== null && "true-value" in props ? props["true-value"] : true;
+    checked = looseEqual(model, applyCoerce(trueValue, rv));
+  }
+  return checked ? { checked: "" } : void 0;
+}
+function getSSRFormStateProps(rv, vnode) {
+  if (typeof vnode.type !== "string") return void 0;
+  const props = vnode.props ?? null;
+  const variant = resolveDynamicModel(vnode.type.toUpperCase(), props?.["type"]);
+  if (variant === vRegisterFile || variant === vRegisterSelect) return void 0;
+  if (variant === vRegisterCheckbox) return ssrCheckboxProps(rv, props);
+  if (variant === vRegisterRadio) {
+    const matches = looseEqual(rv.innerRef.value, applyCoerce(props?.["value"], rv));
+    return matches ? { checked: "" } : void 0;
+  }
+  const value = rv.displayValue.value;
+  return value === "" ? void 0 : { value };
+}
 function callModelHook(el, binding, vnode, prevVNode, hook) {
   const modelToUse = resolveDynamicModel(el.tagName, vnode.props?.["type"]);
   const fn = modelToUse[hook];
   fn?.(el, binding, vnode, prevVNode);
 }
-const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
 const vRegister = vRegisterDynamic;
 vRegisterDynamic[V_REGISTER_MARKER] = true;
 
@@ -1658,16 +1729,17 @@ exports.INTERACTIVE_TAG_NAMES = INTERACTIVE_TAG_NAMES;
 exports.InvalidPathError = InvalidPathError;
 exports.InvalidUseFormConfigError = InvalidUseFormConfigError;
 exports.OutsideSetupError = OutsideSetupError;
+exports.REGISTER_OWNER_MARKER = REGISTER_OWNER_MARKER;
 exports.ROOT_PATH = ROOT_PATH;
 exports.ROOT_PATH_KEY = ROOT_PATH_KEY;
 exports.RegistryNotInstalledError = RegistryNotInstalledError;
 exports.ReservedFormKeyError = ReservedFormKeyError;
 exports.SubmitErrorHandlerError = SubmitErrorHandlerError;
+exports.V_REGISTER_MARKER = V_REGISTER_MARKER;
 exports.__DEV__ = __DEV__;
 exports.allowSensitivePersist = allowSensitivePersist;
 exports.assignKey = assignKey;
 exports.canonicalizePath = canonicalizePath;
-exports.captureUserCallSite = captureUserCallSite;
 exports.coerceToPathKey = coerceToPathKey;
 exports.createAttaform = createAttaform;
 exports.createIsSensitivePath = createIsSensitivePath;
@@ -1687,7 +1759,7 @@ exports.kFormInstanceId = kFormInstanceId;
 exports.parseDottedPath = parseDottedPath;
 exports.pathKeyToDotted = pathKeyToDotted;
 exports.segmentsForPathKey = segmentsForPathKey;
-exports.useRegister = useRegister;
+exports.toError = toError;
 exports.useRegistry = useRegistry;
 exports.vRegister = vRegister;
-//# sourceMappingURL=attaform.BA3vRDos.cjs.map
+//# sourceMappingURL=attaform.B5LNzqQh.cjs.map