attaform 0.30.0 → 0.31.0

package/dist/shared/{attaform.B3resMQ1.mjs → attaform.DxKQsqFZ.mjs}

@@ -1,9 +1,347 @@
-import { reactive, markRaw, effectScope, watch, nextTick } from 'vue';
+import { toRaw, reactive, markRaw, effectScope, watch, nextTick } from 'vue';
 import { i as isRegisterValue, a as isTransforming, S as SSR_COMPONENT_HOST_MODIFIER, R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
 import { e as canonicalizePath } from './attaform.CdZIEf7_.mjs';
 
+function activeElementOf(node) {
+  const rootNode = node.getRootNode();
+  return rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
+}
+
 const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 
+const isArray = Array.isArray;
+function isFunction(value) {
+  return typeof value === "function";
+}
+function toTypeString(value) {
+  return Object.prototype.toString.call(value);
+}
+function isSet(value) {
+  return toTypeString(value) === "[object Set]";
+}
+function isDate(value) {
+  return toTypeString(value) === "[object Date]";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function looseToNumber(val) {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+}
+function looseCompareArrays(a, b) {
+  if (a.length !== b.length) return false;
+  let equal = true;
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i]);
+  }
+  return equal;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  const aValidType = isDate(a);
+  const bValidType = isDate(b);
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+  }
+  const aSymbol = isSymbol(a);
+  const bSymbol = isSymbol(b);
+  if (aSymbol || bSymbol) return a === b;
+  const aIsArray = isArray(a);
+  const bIsArray = isArray(b);
+  if (aIsArray || bIsArray) {
+    return aIsArray && bIsArray ? looseCompareArrays(a, b) : false;
+  }
+  const aIsObject = isObject(a);
+  const bIsObject = isObject(b);
+  if (aIsObject !== bIsObject) return false;
+  if (aIsObject && bIsObject) {
+    const keysA = Object.keys(a);
+    if (keysA.length !== Object.keys(b).length) return false;
+    for (const key of keysA) {
+      const hasA = Object.prototype.hasOwnProperty.call(a, key);
+      const hasB = Object.prototype.hasOwnProperty.call(b, key);
+      if (!hasA || !hasB || !looseEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return String(a) === String(b);
+}
+function looseIndexOf(arr, val) {
+  return arr.findIndex((item) => looseEqual(item, val));
+}
+function invokeArrayFns(fns, ...args) {
+  for (let i = 0; i < fns.length; i++) {
+    const fn = fns[i];
+    if (fn) fn(...args);
+  }
+}
+
+const assignKey = /* @__PURE__ */ Symbol.for("attaform:assign-key");
+const DEFAULT_ASSIGNER_TAG = /* @__PURE__ */ Symbol.for("attaform:default-assigner-tag");
+function isDefaultAssigner(fn) {
+  return typeof fn === "function" && fn[DEFAULT_ASSIGNER_TAG] === true;
+}
+const CONSUMER_WRAPPED_TAG = /* @__PURE__ */ 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);
+      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) {
+  {
+    console.error("[attaform] AF14 attaform.dev/e/af14");
+  }
+}
+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)) {
+    el[assignKey] = makeNoopAssigner();
+    return;
+  }
+  el[assignKey] = getModelAssigner(el, vnode, value);
+}
+
+const inherited = /* @__PURE__ */ new WeakMap();
+function recordInheritedModifiers(rv, modifiers) {
+  const lazy = modifiers.lazy === true;
+  const trim = modifiers.trim === true;
+  const number = modifiers.number === true;
+  if ((lazy || trim || number) && typeof rv === "object" && rv !== null) {
+    inherited.set(toRaw(rv), { lazy, trim, number });
+  }
+}
+function withInheritedModifiers(rv, own) {
+  const found = typeof rv === "object" && rv !== null ? inherited.get(toRaw(rv)) : void 0;
+  return found === void 0 ? own : { ...found, ...own };
+}
+
+function commit(rv, raw, modifiers) {
+  let value = raw;
+  if (modifiers.number === true && typeof value === "string") {
+    const cast = looseToNumber(value);
+    if (typeof cast !== "number") return rv.markBlank();
+    if (!Number.isFinite(cast)) return false;
+    value = cast;
+  }
+  if (value == null || value === "" && !rv.acceptsString) return rv.commitFromHost(value);
+  return wrapWithTransforms(value, rv, (coerced) => rv.commitFromHost(coerced), void 0) !== false;
+}
+function createHostChannel() {
+  const editing = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const heldDraft = (rv) => {
+    const draft = pending.get(rv.path);
+    return draft?.basis === rv.innerRef.value ? draft : void 0;
+  };
+  return {
+    write(rv, value, ownModifiers) {
+      const modifiers = withInheritedModifiers(rv, ownModifiers);
+      if (modifiers.lazy === true && editing.has(rv.path)) {
+        pending.set(rv.path, { value, basis: rv.innerRef.value });
+        return true;
+      }
+      return commit(rv, value, modifiers);
+    },
+    writeInput(rv, payload, modifiers) {
+      if (typeof payload !== "object" || payload === null || payload instanceof Event || !("value" in payload) || !Object.hasOwn(payload, "value")) {
+        return false;
+      }
+      return rv.setValueFromHost(payload.value, modifiers);
+    },
+    markEditing(rv, isEditing, modifiers) {
+      if (isEditing) {
+        editing.add(rv.path);
+        return;
+      }
+      editing.delete(rv.path);
+      const draft = heldDraft(rv);
+      if (pending.delete(rv.path)) {
+        if (draft !== void 0) {
+          const buffered = draft.value;
+          commit(
+            rv,
+            modifiers.trim === true && typeof buffered === "string" ? buffered.trim() : buffered,
+            modifiers
+          );
+        }
+        return;
+      }
+      if (modifiers.trim === true) {
+        const current = rv.innerRef.value;
+        if (typeof current === "string" && current !== current.trim()) {
+          commit(rv, current.trim(), modifiers);
+        }
+      }
+    },
+    holdsDraft: (rv) => heldDraft(rv) !== void 0,
+    release(rv) {
+      editing.delete(rv.path);
+      pending.delete(rv.path);
+    }
+  };
+}
+
 const attaformListenersSymbol = /* @__PURE__ */ Symbol.for("attaform:focus-listeners");
 const HOST_FOCUS_TARGET_SELECTOR = [
   'input:not([type="hidden"])',
@@ -33,9 +371,7 @@ function attachFocusListeners(kernel, segments, element, instanceMeta) {
   element.addEventListener("focus", handleFocus);
   element.addEventListener("blur", handleBlur);
   target[attaformListenersSymbol] = { handleFocus, handleBlur };
-  const rootNode = element.getRootNode();
-  const activeElement = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
-  if (activeElement === element) {
+  if (activeElementOf(element) === element) {
     kernel.markFocused(segments, true, focusMeta);
   }
 }
@@ -101,124 +437,54 @@ function createDomBinding(kernel) {
     }
   }
   function rebuildSortedRegistrations() {
-    const flat = [];
-    for (const [, record] of elements) {
-      for (const el of record.elements) {
-        flat.push({
-          path: record.path,
-          element: el,
-          host: false,
-          formInstanceId: elementToFormInstance.get(el) ?? ""
-        });
-      }
-    }
-    for (const [key, target] of hostTargets) {
-      if (elements.has(key)) continue;
-      flat.push({
-        path: target.path,
-        element: target.hostRoot,
-        host: true,
-        formInstanceId: target.formInstanceId
-      });
-    }
-    flat.sort(
-      (a, b) => a.element.compareDocumentPosition(b.element) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1
-    );
-    return flat;
-  }
-  function getFirstErrorElement(formInstanceId) {
-    sortedRegistrationsCache ?? (sortedRegistrationsCache = rebuildSortedRegistrations());
-    for (const entry of sortedRegistrationsCache) {
-      if (entry.formInstanceId !== formInstanceId) continue;
-      if (!entry.element.isConnected) continue;
-      if (entry.element.offsetParent === null) continue;
-      if (kernel.getErrorsForPath(entry.path).length === 0) continue;
-      const element = entry.host ? resolveHostFocusTarget(entry.element) : entry.element;
-      return { path: entry.path, element };
-    }
-    return null;
-  }
-  return {
-    elements,
-    attach,
-    detach,
-    markHostConnected,
-    getFirstErrorElement
-  };
-}
-function armDomBinding(value) {
-  value.ensureDomBinding?.(createDomBinding);
-}
-
-const isArray = Array.isArray;
-function isFunction(value) {
-  return typeof value === "function";
-}
-function toTypeString(value) {
-  return Object.prototype.toString.call(value);
-}
-function isSet(value) {
-  return toTypeString(value) === "[object Set]";
-}
-function isDate(value) {
-  return toTypeString(value) === "[object Date]";
-}
-function isSymbol(value) {
-  return typeof value === "symbol";
-}
-function isObject(value) {
-  return value !== null && typeof value === "object";
-}
-function looseToNumber(val) {
-  const n = parseFloat(val);
-  return isNaN(n) ? val : n;
-}
-function looseCompareArrays(a, b) {
-  if (a.length !== b.length) return false;
-  let equal = true;
-  for (let i = 0; equal && i < a.length; i++) {
-    equal = looseEqual(a[i], b[i]);
-  }
-  return equal;
-}
-function looseEqual(a, b) {
-  if (a === b) return true;
-  const aValidType = isDate(a);
-  const bValidType = isDate(b);
-  if (aValidType || bValidType) {
-    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
-  }
-  const aSymbol = isSymbol(a);
-  const bSymbol = isSymbol(b);
-  if (aSymbol || bSymbol) return a === b;
-  const aIsArray = isArray(a);
-  const bIsArray = isArray(b);
-  if (aIsArray || bIsArray) {
-    return aIsArray && bIsArray ? looseCompareArrays(a, b) : false;
+    const flat = [];
+    for (const [, record] of elements) {
+      for (const el of record.elements) {
+        flat.push({
+          path: record.path,
+          element: el,
+          host: false,
+          formInstanceId: elementToFormInstance.get(el) ?? ""
+        });
+      }
+    }
+    for (const [key, target] of hostTargets) {
+      if (elements.has(key)) continue;
+      flat.push({
+        path: target.path,
+        element: target.hostRoot,
+        host: true,
+        formInstanceId: target.formInstanceId
+      });
+    }
+    flat.sort(
+      (a, b) => a.element.compareDocumentPosition(b.element) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1
+    );
+    return flat;
   }
-  const aIsObject = isObject(a);
-  const bIsObject = isObject(b);
-  if (aIsObject !== bIsObject) return false;
-  if (aIsObject && bIsObject) {
-    const keysA = Object.keys(a);
-    if (keysA.length !== Object.keys(b).length) return false;
-    for (const key of keysA) {
-      const hasA = Object.prototype.hasOwnProperty.call(a, key);
-      const hasB = Object.prototype.hasOwnProperty.call(b, key);
-      if (!hasA || !hasB || !looseEqual(a[key], b[key])) return false;
+  function getFirstErrorElement(formInstanceId) {
+    sortedRegistrationsCache ?? (sortedRegistrationsCache = rebuildSortedRegistrations());
+    for (const entry of sortedRegistrationsCache) {
+      if (entry.formInstanceId !== formInstanceId) continue;
+      if (!entry.element.isConnected) continue;
+      if (entry.element.offsetParent === null) continue;
+      if (kernel.getErrorsForPath(entry.path).length === 0) continue;
+      const element = entry.host ? resolveHostFocusTarget(entry.element) : entry.element;
+      return { path: entry.path, element };
     }
-    return true;
+    return null;
   }
-  return String(a) === String(b);
-}
-function looseIndexOf(arr, val) {
-  return arr.findIndex((item) => looseEqual(item, val));
+  return {
+    elements,
+    attach,
+    detach,
+    markHostConnected,
+    getFirstErrorElement,
+    hostChannel: createHostChannel()
+  };
 }
-function invokeArrayFns(fns, ...args) {
-  for (let i = 0; i < fns.length; i++) {
-    const fn = fns[i];
-    if (fn) fn(...args);
-  }
+function armDomBinding(value) {
+  return value.ensureDomBinding?.(createDomBinding);
 }
 
 const MANAGED_ARIA_ATTRS = [
@@ -369,188 +635,6 @@ function isRegisterValueLike(val) {
   return typeof val === "object" && val !== null && "markInteracted" in val && typeof val.markInteracted === "function";
 }
 
-const assignKey = /* @__PURE__ */ Symbol.for("attaform:assign-key");
-const DEFAULT_ASSIGNER_TAG = /* @__PURE__ */ Symbol.for("attaform:default-assigner-tag");
-function isDefaultAssigner(fn) {
-  return typeof fn === "function" && fn[DEFAULT_ASSIGNER_TAG] === true;
-}
-const CONSUMER_WRAPPED_TAG = /* @__PURE__ */ 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);
-      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) {
-  {
-    console.error("[attaform] AF14 attaform.dev/e/af14");
-  }
-}
-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)) {
-    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;
@@ -642,11 +726,6 @@ function syncElementRegistration(el, value, oldValue) {
 }
 
 const valueSyncScopeKey = /* @__PURE__ */ 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 = effectScope(true);
@@ -655,7 +734,7 @@ function setupValueSync(el, source, apply, options = {}) {
       source,
       () => {
         if (el.composing === true) return;
-        if (skipWhileFocused && isElementFocused(el)) return;
+        if (skipWhileFocused && activeElementOf(el) === el) return;
         apply();
       },
       { flush: "post" }
@@ -714,6 +793,28 @@ function onCompositionEnd(e) {
     target.dispatchEvent(new Event("input"));
   }
 }
+const heldDrafts = /* @__PURE__ */ new WeakMap();
+function holdDraft(owner, control, stale) {
+  heldDrafts.set(owner, {
+    control,
+    text: control.value,
+    stale,
+    start: control.selectionStart,
+    end: control.selectionEnd
+  });
+}
+function restoreDraft(owner) {
+  const held = heldDrafts.get(owner);
+  if (held === void 0) return;
+  heldDrafts.delete(owner);
+  const { control, text, stale, start, end } = held;
+  if (control.value !== stale || stale === text) return;
+  control.value = text;
+  if (start !== null && end !== null) control.setSelectionRange(start, end);
+}
+function textControl(node) {
+  return node instanceof HTMLInputElement || node instanceof HTMLTextAreaElement ? node : null;
+}
 const vRegisterText = {
   created(el, { value, modifiers: { lazy, trim, number } }, vnode) {
     const castToNumberAtCreated = number === true || vnode.props?.["type"] === "number";
@@ -836,12 +937,14 @@ const vRegisterText = {
   mounted(el, { value }) {
     if (!isRegisterValue(value)) return;
     el.value = value.displayValue.value;
+    el._lastAppliedModel = value.innerRef.value;
     setupValueSync(
       el,
       value.displayValue,
       () => {
         const next = value.displayValue.value;
         if (el.value !== next) el.value = next;
+        el._lastAppliedModel = value.innerRef.value;
       },
       { skipWhileFocused: true }
     );
@@ -850,17 +953,16 @@ const vRegisterText = {
     setAssignFunction(el, vnode, value);
     if (el.composing === true) return;
     if (!isRegisterValue(value)) return;
+    const model = value.innerRef.value;
+    const modelMoved = model !== el._lastAppliedModel || !isRegisterValue(oldValue) || oldValue.path !== value.path;
+    el._lastAppliedModel = model;
     const target = value.displayValue.value;
     if (el.value === target) {
       return;
     }
-    const rootNode = el.getRootNode();
-    const activeElement = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
-    if (activeElement === el && el.type !== "range") {
-      if (lazy === true && value.innerRef.value === oldValue) {
-        return;
-      }
-      if (trim === true && el.value.trim() === target) {
+    if (activeElementOf(el) === el && el.type !== "range") {
+      if (lazy === true && !modelMoved || trim === true && el.value.trim() === target) {
+        holdDraft(el, el, target);
         return;
       }
     }
@@ -931,20 +1033,15 @@ const vRegisterCheckbox = {
       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`
-  // gated on `originalValue === oldValue`, comparing a primitive
-  // scalar against the wrapper RegisterValue object — always !==,
-  // so the guard was a silent no-op. Array / Set branches lacked
-  // any guard. The per-render re-apply mirrors the just-fixed
-  // `vRegisterSelect` shape: a sibling's reactive write triggers
-  // `beforeUpdate` mid-click, `setChecked` re-applies the prior
-  // model state, and the in-flight user toggle is clobbered before
-  // the browser fires `change`. Identity comparison on
-  // `innerRef.value` is sound for the same reason as multi-select —
-  // every form write produces a fresh value at the path (new
-  // primitives; new array/Set references along the spine), so
-  // reference equality tracks "did the model move" exactly.
+  // Skip the DOM sync when the model is identity-unchanged since the last
+  // application. Without the guard, a sibling's reactive write triggers
+  // `beforeUpdate` mid-click, `setChecked` re-applies the prior model state,
+  // and the in-flight toggle is clobbered before the browser fires `change`.
+  // Compare `innerRef.value` by identity: every form write produces a fresh
+  // value at the path, new primitives and new array or Set references along
+  // the spine, so reference equality tracks "did the model move" exactly. The
+  // guard must NOT compare against `oldValue`, which is the previous binding's
+  // wrapper RegisterValue and never equals a model scalar.
   beforeUpdate(el, binding, vnode) {
     setAssignFunction(el, vnode, binding.value);
     if (!isRegisterValue(binding.value)) return;
@@ -994,13 +1091,11 @@ const vRegisterRadio = {
       }
     });
   },
-  // Initial checked-state sync runs in `mounted`, NOT `created` —
-  // Vue's directive lifecycle fires `created` BEFORE the element's
-  // attributes are patched (`type`, `value`, `_value` etc. aren't on
-  // the element yet), so `getValue(el)` would return `undefined` and
-  // every radio in a group would mount unchecked regardless of the
-  // model. Checkbox already uses `mounted: setChecked` for the same
-  // reason.
+  // The initial checked sync runs in `mounted`, NOT `created`: Vue fires
+  // `created` before the element's attributes are patched, so `type`, `value`
+  // and `_value` are absent, `getValue(el)` returns undefined, and every radio
+  // in a group mounts unchecked whatever the model says. Checkbox uses
+  // `mounted` for the same reason.
   mounted(el, { value }) {
     if (!isRegisterValue(value)) return;
     el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
@@ -1010,15 +1105,12 @@ const vRegisterRadio = {
       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
-  // !== oldValue`, comparing a primitive scalar against the previous
-  // binding's wrapper RegisterValue object — always !==, so the
-  // guard was a silent no-op and `el.checked = …` re-applied on
-  // every parent re-render. Same shape as the just-fixed
-  // `vRegisterSelect` and `setChecked` bugs: a sibling's reactive
-  // write triggers `beforeUpdate` mid-click and writes back the
-  // prior model state, clobbering the in-flight selection.
+  // Skip the DOM sync when the model is identity-unchanged since the last
+  // application, tracked on `_lastAppliedModel`. Comparing against `oldValue`
+  // instead compares a primitive scalar to the previous binding's wrapper
+  // RegisterValue, never equal, so `el.checked` re-applies on every parent
+  // re-render and a sibling's reactive write clobbers an in-flight selection
+  // mid-click.
   beforeUpdate(el, { value }, vnode) {
     if (!isRegisterValue(value)) return;
     setAssignFunction(el, vnode, value);
@@ -1077,22 +1169,20 @@ const vRegisterSelect = {
   beforeUpdate(el, binding, vnode) {
     setAssignFunction(el, vnode, binding.value);
   },
-  // Skip the DOM sync when the model is identity-unchanged from the
-  // last application. Parent re-renders fire `updated` whether or not
-  // the bound model actually moved (a typed character in a sibling,
-  // an async-validation tick, any reactive read elsewhere on the
-  // page). Without this guard, every such render unconditionally re-
-  // applies `setSelected` against the prior model, which on a
-  // `<select multiple>` clobbers any in-progress user selection
-  // between mousedown and the browser's change-event decision — the
-  // browser then sees no net change, never fires `change`, and the
-  // model never updates. Identity comparison is sound: every form
-  // write produces a new array/Set reference at the path (the diff-
-  // apply replacement of `form.value` rolls forward fresh structures
-  // along the spine), so reference equality on `innerRef.value`
-  // tracks "did the model move" exactly. The `_assigning` gate stays
-  // — it short-circuits the immediate post-write render where the
-  // DOM is already in sync from the user's click.
+  // Skip the DOM sync when the model is identity-unchanged since the last
+  // application. A parent re-render fires `updated` whether or not the bound
+  // model moved: a typed character in a sibling, an async-validation tick, any
+  // reactive read elsewhere on the page. Re-applying `setSelected` against the
+  // prior model on each of those clobbers an in-progress `<select multiple>`
+  // selection between mousedown and the browser's change decision, after which
+  // the browser sees no net change, never fires `change`, and the model never
+  // updates.
+  //
+  // Identity comparison is sound: every form write produces a new array or Set
+  // reference at the path, the replacement of `form.value` rolling fresh
+  // structures forward along the spine. The `_assigning` gate stays as well,
+  // short-circuiting the immediate post-write render where the DOM is already
+  // in sync from the user's click.
   updated(el, { value }) {
     if (el._assigning === true) return;
     if (!isRegisterValue(value)) return;
@@ -1229,6 +1319,29 @@ function observeForLateHostControl(el, rv) {
   observer.observe(el, { childList: true, subtree: true });
   hostHealObservers.set(el, observer);
 }
+const hostEdits = /* @__PURE__ */ new WeakMap();
+function trackHostEdits(el, rv, modifiers) {
+  if (modifiers.lazy !== true && modifiers.trim !== true) return;
+  if (!INTERACTIVE_TAG_NAMES.has(el.tagName) && rv.hasRegisteredDescendant(el)) return;
+  const channel = armDomBinding(rv)?.hostChannel;
+  if (channel === void 0) return;
+  const edits = { channel, rv, base: void 0 };
+  const edge = (editing) => (event) => {
+    if (editing && !channel.holdsDraft(rv)) edits.base = textControl(event.target)?.value;
+    const other = event.relatedTarget;
+    if (other instanceof Node && el.contains(other)) return;
+    channel.markEditing(rv, editing, modifiers);
+  };
+  addTrackedListener(el, "focus", edge(true), { capture: true });
+  addTrackedListener(el, "blur", edge(false), { capture: true });
+  hostEdits.set(el, edits);
+}
+function holdHostDraft(el) {
+  const edits = hostEdits.get(el);
+  if (edits?.base === void 0 || !edits.channel.holdsDraft(edits.rv)) return;
+  const control = textControl(activeElementOf(el));
+  if (control !== null && el.contains(control)) holdDraft(el, control, edits.base);
+}
 function activateComponentHost(el, rv) {
   if (rv.hasRegisteredDescendant(el)) return;
   el[REGISTER_OWNER_MARKER] = true;
@@ -1243,25 +1356,34 @@ function activateComponentHost(el, rv) {
   setupNoLatchHost(el, rv);
   scheduleHostSelfHeal(el, rv);
 }
+function inheritModifiers(binding) {
+  const modifiers = withInheritedModifiers(binding.value, binding.modifiers);
+  return modifiers === binding.modifiers ? binding : { ...binding, modifiers };
+}
 const vRegisterDynamic = {
-  created(el, binding, vnode) {
+  created(el, ownBinding, vnode) {
+    const binding = inheritModifiers(ownBinding);
     if (isRegisterValue(binding.value)) armDomBinding(binding.value);
     callModelHook(el, binding, vnode, null, "created");
     if (isRegisterValue(binding.value)) setupAria(el, binding.value, vnode);
   },
-  mounted(el, binding, vnode) {
+  mounted(el, ownBinding, vnode) {
+    const binding = inheritModifiers(ownBinding);
     callModelHook(el, binding, vnode, null, "mounted");
     if (isRegisterValue(binding.value) && INTERACTIVE_TAG_NAMES.has(el.tagName) && binding.modifiers[SSR_COMPONENT_HOST_MODIFIER] !== true && vnode.props?.["disabled"] === void 0) {
       setupDisabledSync(el, binding.value.disabled);
     }
     if (binding.modifiers[SSR_COMPONENT_HOST_MODIFIER] === true && isRegisterValue(binding.value)) {
+      trackHostEdits(el, binding.value, binding.modifiers);
       activateComponentHost(el, binding.value);
     }
   },
-  beforeUpdate(el, binding, vnode, prevVNode) {
+  beforeUpdate(el, ownBinding, vnode, prevVNode) {
+    const binding = inheritModifiers(ownBinding);
     if (isRegisterValue(binding.value)) armDomBinding(binding.value);
     syncElementRegistration(el, binding.value, binding.oldValue);
     callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+    holdHostDraft(el);
     const ariaEl = el;
     const value = binding.value;
     if (!isRegisterValue(value) || value.ariaDisplayState === void 0) {
@@ -1279,13 +1401,17 @@ const vRegisterDynamic = {
     }
   },
   updated(el, binding, vnode, prevVNode) {
-    callModelHook(el, binding, vnode, prevVNode, "updated");
+    callModelHook(el, inheritModifiers(binding), vnode, prevVNode, "updated");
+    restoreDraft(el);
   },
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
     teardownAria(el);
     teardownValueSync(el);
     teardownDisabledSync(el);
+    const edits = hostEdits.get(el);
+    edits?.channel.release(edits.rv);
+    hostEdits.delete(el);
     if (!isRegisterValue(value)) return;
     value.deregisterElement(el);
     if (componentHostLatch.has(el)) {
@@ -1306,13 +1432,12 @@ const vRegisterDynamic = {
     delete el._syncFromStorage;
     delete el[assignKey];
   },
-  // The lifecycle hooks above don't run on the server (Vue skips
-  // directive lifecycle during SSR), so emit the same aria attributes
-  // here from the SSR-time gated display state. Honors authored attrs
-  // (vnode-level lockout), touches no DOM, and shares
-  // `resolveAriaValue` with the client path. Ids are SSR-stable
-  // (formInstanceId derives from Vue's useId), so a server-rendered
-  // describedby matches the client after hydration.
+  // Vue skips directive lifecycle during SSR, so the hooks above never run on
+  // the server and the same aria attributes are emitted here from the SSR-time
+  // gated display state. Honours authored attrs through the vnode-level
+  // lockout, touches no DOM, and shares `resolveAriaValue` with the client
+  // path. Ids are SSR-stable, `formInstanceId` deriving from Vue's `useId`, so
+  // a server-rendered describedby matches the client after hydration.
   getSSRProps(binding, vnode) {
     const rv = binding.value;
     if (!isRegisterValue(rv)) return void 0;
@@ -1377,4 +1502,4 @@ function installVRegister(app) {
   }
 }
 
-export { assignKey as a, vRegisterFile as b, armDomBinding as c, installVRegister as i, vRegister as v };
+export { assignKey as a, vRegisterFile as b, armDomBinding as c, installVRegister as i, recordInheritedModifiers as r, vRegister as v, withInheritedModifiers as w };