attaform 0.30.1 → 0.31.1

package/dist/shared/{attaform.ZYn2ahzJ.mjs → attaform.DBCbxlyk.mjs}

@@ -119,6 +119,20 @@ const NATIVE_FORM_TAGS = /* @__PURE__ */ new Set([
   "label",
   "button"
 ]);
+const HOST_MODIFIERS = ["lazy", "trim", "number"];
+function hostModifiersLiteral(registerDirective) {
+  const present = HOST_MODIFIERS.filter(
+    (name) => registerDirective?.modifiers.some((m) => m.content === name) === true
+  );
+  return present.length === 0 ? "{}" : `{ ${present.map((name) => `${name}: true`).join(", ")} }`;
+}
+function isInputListenerSlot(prop) {
+  if (prop.type !== NodeTypes.DIRECTIVE || prop.name !== "on" && prop.name !== "bind") {
+    return false;
+  }
+  if (prop.arg === void 0) return true;
+  return prop.arg.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === (prop.name === "on" ? "input" : "onInput");
+}
 function inferOptionValueFromChildren(node) {
   if (!("children" in node)) return null;
   const children = node.children;
@@ -275,6 +289,11 @@ const componentBridgeTransform = (node, context) => {
       node.props.push(valueProp);
     }
     if (isPlainComponentHost) {
+      const hostModifiers = hostModifiersLiteral(
+        node.props.find(
+          (p) => p.type === NodeTypes.DIRECTIVE && p.name === "register"
+        )
+      );
       removePropsByName(node.props, [
         "model",
         "modelValue",
@@ -317,7 +336,7 @@ const componentBridgeTransform = (node, context) => {
       const updateInitExpression = createCompoundExpression([
         "$event => (",
         ...modelValuePropExpArray,
-        ")?.setValueFromHost?.($event)"
+        `)?.setValueFromHost?.($event, ${hostModifiers})`
       ]);
       const updateSimpleExpression = createSimpleExpression(
         flattenExpression(updateInitExpression),
@@ -346,6 +365,45 @@ const componentBridgeTransform = (node, context) => {
         loc: selectLoc
       };
       node.props.push(updateModelValueProp);
+      const inputAlreadyInjected = node.props.some(
+        (p) => p.type === NodeTypes.DIRECTIVE && p.name === "bind" && p.arg?.type === NodeTypes.SIMPLE_EXPRESSION && p.arg.content === "onInput" && p.exp !== void 0 && flattenExpression(p.exp).includes("setValueFromHostInput")
+      );
+      if (!inputAlreadyInjected) {
+        const inputInitExpression = createCompoundExpression([
+          "$event => (",
+          ...modelValuePropExpArray,
+          `)?.setValueFromHostInput?.($event, ${hostModifiers})`
+        ]);
+        const inputSimpleExpression = createSimpleExpression(
+          flattenExpression(inputInitExpression),
+          false
+        );
+        let inputOutputExp;
+        try {
+          inputOutputExp = processExpression(inputSimpleExpression, {
+            ...context,
+            prefixIdentifiers: false
+          });
+        } catch (err) {
+          console.error(
+            "[attaform] component-bridge transform: processExpression failed for onInput; falling back to the unprocessed expression.",
+            err
+          );
+          inputOutputExp = inputSimpleExpression;
+        }
+        const inputProp = {
+          rawName: "@input",
+          arg: createSimpleExpression("onInput", true),
+          exp: inputOutputExp,
+          name: "bind",
+          modifiers: [],
+          type: NodeTypes.DIRECTIVE,
+          loc: selectLoc
+        };
+        const authorListenerIndex = node.props.findIndex(isInputListenerSlot);
+        if (authorListenerIndex === -1) node.props.push(inputProp);
+        else node.props.splice(authorListenerIndex, 0, inputProp);
+      }
     }
     const registerExprArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
     const hasAuthorDisabled = selectSummarizedProps.findIndex((p) => isExactKey(p.key, "disabled")) !== -1;

package/dist/shared/{attaform.L0kUn3vL.d.mts → attaform.DZOynI6c.d.mts}

@@ -1,5 +1,5 @@
 import { App } from 'vue';
-import { ao as RegisterModelDynamicCustomDirective } from './attaform.Br8EBn5B.mjs';
+import { an as RegisterModelDynamicCustomDirective } from './attaform.i13OEHJF.mjs';
 
 /**
  * The `v-register` directive. Bind a form field to a native input, select,

package/dist/shared/{attaform.B2iebkPA.mjs → attaform.KEfNRDot.mjs}

@@ -1,7 +1,7 @@
-import { a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
-import { u as useForm$2 } from './attaform.D_pt1gOj.mjs';
-import { u as useForm$1 } from './attaform.CO918TdU.mjs';
-import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.DRsANMok.mjs';
+import { a as InvalidUseFormConfigError } from './attaform.BhtAZysa.mjs';
+import { u as useForm$2 } from './attaform.u6jfHoed.mjs';
+import { u as useForm$1 } from './attaform.B5b-HmhH.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.j9xI_ObC.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;

package/dist/shared/attaform._1Zp3mDG.mjs

@@ -0,0 +1,96 @@
+function callConsumerFn(fn, fallback, site, detail) {
+  try {
+    return fn();
+  } catch (err) {
+    return fallback;
+  }
+}
+function readConsumerProp(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return void 0;
+  }
+}
+function consumerKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readConsumerIndex(arr, i) {
+  try {
+    return arr[i];
+  } catch {
+    return void 0;
+  }
+}
+function consumerSymbolKeys(obj) {
+  try {
+    return Object.getOwnPropertySymbols(obj);
+  } catch {
+    return [];
+  }
+}
+function consumerHas(obj, key) {
+  try {
+    return key in obj;
+  } catch {
+    return false;
+  }
+}
+
+function safeAssign(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+const SHADOWED_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
+function isShadowedKey(key) {
+  return SHADOWED_KEYS.has(key);
+}
+function safeOwnRead(target, key) {
+  if (isShadowedKey(key)) {
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc === void 0) return void 0;
+    return "value" in desc ? desc.value : readConsumerProp(target, key);
+  }
+  return readConsumerProp(target, key);
+}
+function safeOwnHas(target, key) {
+  try {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  } catch {
+    return false;
+  }
+}
+function spreadConsumerRecord(src) {
+  try {
+    return { ...src };
+  } catch {
+    const out = {};
+    for (const key of Object.keys(src)) {
+      safeAssign(out, key, readConsumerProp(src, key));
+    }
+    return out;
+  }
+}
+function copyConsumerArray(src) {
+  try {
+    return src.slice();
+  } catch {
+    const out = new Array(src.length);
+    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
+    return out;
+  }
+}
+
+export { safeOwnRead as a, readConsumerProp as b, consumerKeys as c, callConsumerFn as d, safeOwnHas as e, consumerHas as f, spreadConsumerRecord as g, copyConsumerArray as h, isShadowedKey as i, consumerSymbolKeys as j, readConsumerIndex as r, safeAssign as s };

package/dist/shared/{attaform.Br8EBn5B.d.mts → attaform.i13OEHJF.d.mts}

@@ -215,6 +215,25 @@ type OriginalsRecord = {
     readonly segments: Path;
     readonly value: unknown;
 };
+/** Every tracked array's identity tokens and baseline order, by array key. */
+type IdentityOrders = {
+    readonly tokens: ReadonlyMap<PathKey, readonly string[]>;
+    readonly baselines: ReadonlyMap<PathKey, readonly string[]>;
+};
+/**
+ * The per-element bookkeeping a history position puts back with its value.
+ * A typed array op moves each element's baseline with its identity and drops
+ * a removed element's, as it does the element's blank membership, so a value
+ * alone, restored by position, would compare each row against the baseline of
+ * whichever row sits there now. With them come the identity orders and the
+ * removed-baseline set those baselines are read against. Opaque to the history module, which keeps it and hands it back.
+ */
+type StructureSnapshot = {
+    readonly identity: IdentityOrders;
+    readonly originals: ReadonlyArray<readonly [PathKey, OriginalsRecord]>;
+    readonly originalBlank: ReadonlyArray<PathKey>;
+    readonly removed: ReadonlyArray<readonly [PathKey, Path]>;
+};
 
 /** Internal brand for the `Unset` type. Never exposed at runtime. */
 declare const _unsetBrand: unique symbol;
@@ -888,8 +907,6 @@ type SchemaParseErrorWithData<TData> = {
 };
 /** Settled schema-level verdict. Discriminate on `success`. */
 type SchemaParseResult<TData> = SchemaParseSuccess<TData> | SchemaParseErrorWithData<TData> | SchemaParseErrorWithoutData;
-/** Schema-level `getDefaultValues` verdict: defaults always come back. */
-type SchemaDefaultsResult<TData> = SchemaParseSuccess<TData> | SchemaParseErrorWithData<TData>;
 /** Settled validation result when the form or subtree parsed successfully. */
 type ValidationResponseSuccess<TData> = SchemaParseSuccess<TData> & {
     /** The form this verdict belongs to. Stamped by the store, not the schema. */
@@ -977,7 +994,31 @@ type GetDefaultValuesConfig<Form> = {
  * library.
  */
 type AbstractSchema<Form, GetValueFormType> = {
-    getDefaultValues(config: GetDefaultValuesConfig<Form>): SchemaDefaultsResult<Form>;
+    /**
+     * The form's starting value: the schema's defaults, with
+     * `config.constraints` merged over them and any shape the merge broke
+     * repaired. Derivation only. Nothing is validated here, so no
+     * refinement, check or transform runs; `validateSync` is the verdict.
+     */
+    getDefaultValues(config: GetDefaultValuesConfig<Form>): Form;
+    /**
+     * The schema's synchronous verdict on `data` as a whole form, as a
+     * list of failures: empty when the data passes.
+     *
+     * The runtime seeds the schema error channel with it whenever it
+     * establishes a baseline: on the starting value, the first time
+     * anything reads or writes the form's errors, and on `reset()`. A form
+     * starting from invalid defaults therefore reads invalid from its
+     * first render.
+     * A hydrating client never calls it, since the server's verdict
+     * arrives with the payload.
+     *
+     * Adapters MUST NOT throw: a refinement that throws, or a schema whose
+     * verdict resolves only through a Promise, returns `[]` and leaves the
+     * verdict to the async pass that `needsAsyncValidation` queues. An
+     * adapter with no synchronous parse returns `[]` unconditionally.
+     */
+    validateSync(data: unknown): ValidationError[];
     /**
      * The schema-prescribed default at `path`. The runtime uses it to
      * fill structural gaps, so every `setValue` write leaves the form
@@ -1325,8 +1366,8 @@ type AbstractSchema<Form, GetValueFormType> = {
     /**
      * Whether `validateAtPath` MAY have to run asynchronously to surface
      * every error this schema can produce. The runtime asks at
-     * construction: `false` means the construction-time sync seed is
-     * authoritative and no extra microtask is spent, `true` queues a
+     * construction: `false` means the synchronous verdict on the starting
+     * value is authoritative and no extra microtask is spent, `true` queues a
      * one-shot full-form async pass so async-only verdicts (refinements,
      * transforms or pipes that resolve only through a Promise) surface
      * without waiting for a user mutation.
@@ -1338,7 +1379,10 @@ type AbstractSchema<Form, GetValueFormType> = {
      * For a per-path query, compose with `getSchemasAtPath(path)`: each
      * candidate sub-schema exposes its own `needsAsyncValidation`, so
      * "does the cargo subtree contain async work?" is the union of the
-     * per-candidate answers, with no separate top-level overload.
+     * per-candidate answers, with no separate top-level overload. A root
+     * that answers `false` answers for every path, and the runtime then
+     * asks no sub-schema, so never answer `false` at the root of a tree
+     * where a sub-schema would answer `true`.
      */
     needsAsyncValidation?(): boolean;
     /**
@@ -1378,6 +1422,20 @@ type AbstractSchema<Form, GetValueFormType> = {
      * that disables variant reshape and stub correction for the form.
      */
     hasDiscriminatedUnions?(): boolean;
+    /**
+     * Whether `isPreprocessOrCoerceLeaf` can answer `true` at any path:
+     * the schema holds a preprocess-style normalizer or a coerce
+     * primitive somewhere. The store reads it once at construction.
+     * `false` lets it skip recording which paths the consumer authored,
+     * a set that is only read at such leaves.
+     *
+     * Optional, and an adapter that omits it is treated as holding one,
+     * which keeps that bookkeeping on. Never return `false` for a schema
+     * where `isPreprocessOrCoerceLeaf` answers `true` anywhere: verdicts
+     * at a path the consumer authored with `undefined` would then stay
+     * hidden.
+     */
+    hasPreprocessOrCoerce?(): boolean;
 };
 /**
  * A discriminated union as the adapter reports it: the discriminator
@@ -1583,10 +1641,13 @@ type WriteMeta = {
 type HistoryKernel = {
     readonly form: Ref<unknown>;
     readonly blankPaths: Set<PathKey>;
-    readonly errorCells: Map<PathKey, ErrorCell>;
+    readonly errorCells: () => Map<PathKey, ErrorCell>;
     onFormChange(listener: (next: unknown, meta?: WriteMeta) => void): () => void;
+    onReset(listener: () => void): () => void;
     applyFormReplacement(next: unknown): void;
     restoreErrorCells(entries: ReadonlyArray<readonly [PathKey, ErrorCell]>): void;
+    captureStructure(): StructureSnapshot;
+    restoreStructure(snapshot: StructureSnapshot): void;
 };
 /**
  * The live undo/redo runtime a {@link HistoryPlugin} attaches to one
@@ -2033,7 +2094,13 @@ type HandleSubmit<Form extends GenericForm> = (onSubmit: OnSubmit<Form>, onError
  * fields appear in friendlier shape on `FieldState`.
  */
 type MetaTrackerValue = {
-    /** ISO timestamp of the most recent write at this path. `null` if never written. */
+    /**
+     * ISO timestamp of the most recent write at this path or under it,
+     * counting the form's creation. A removal is a write too, so the stamp
+     * never moves backwards, and every write reads later than the one before
+     * it, whatever the device's clock says. `null` only for a path never
+     * written or no longer present.
+     */
     updatedAt: string | null;
     /** Value as it arrived, before any transforms. Distinguishes a parse-coerced read from raw user input. */
     rawValue: unknown;
@@ -2184,6 +2251,32 @@ type AttaformDomBinding = {
         path: Path;
         element: HTMLElement;
     } | null;
+    readonly hostChannel: HostChannel;
+};
+/**
+ * The write policy for a `v-register` component host, held on the DOM
+ * binding so it stays in the directive cluster's lazy graph. Applies the
+ * binding site's modifiers, runs register `transforms` and schema
+ * coercion, and buffers `.lazy` writes while focus is inside the host.
+ *
+ *   - `write` commits a value the host emitted through
+ *     `update:modelValue`.
+ *   - `writeInput` takes an `input` emit and commits it only when the
+ *     payload carries the live value as an own `value` property.
+ *   - `markEditing` records focus entering or leaving the host. Leaving
+ *     commits a buffered `.lazy` value, or the trimmed form under `.trim`.
+ *   - `holdsDraft` reports a buffered `.lazy` value that storage has not
+ *     moved past, the edit a re-render must leave on screen.
+ *   - `release` drops any buffered value when the host unmounts.
+ *
+ * @internal
+ */
+type HostChannel = {
+    readonly write: (rv: RegisterValue, value: unknown, modifiers: HostModifiers) => boolean;
+    readonly writeInput: (rv: RegisterValue, payload: unknown, modifiers: HostModifiers) => boolean;
+    readonly markEditing: (rv: RegisterValue, editing: boolean, modifiers: HostModifiers) => void;
+    readonly holdsDraft: (rv: RegisterValue) => boolean;
+    readonly release: (rv: RegisterValue) => void;
 };
 /**
  * Factory the directive and `useRegister` inject through
@@ -2244,16 +2337,39 @@ type RegisterValue<Value = unknown> = Readonly<{
     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 component's
-     * typed model output as authoritative, with 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. `true` when the
-     * write was accepted.
+     * `v-register`'s compile-time v-model desugar, and mark the field
+     * interacted, since a v-model host has no DOM input listener to flip
+     * the sticky `interacted` bit. The write takes the same path a native
+     * input's does: the binding site's `.number` / `.trim` / `.lazy`
+     * modifiers, then register `transforms`, then schema coercion. The
+     * injected `onUpdate:modelValue` handler is the caller, passing the
+     * modifiers as a static literal. `true` when the write was accepted
+     * or buffered.
+     *
+     * @internal
+     */
+    setValueFromHost: (value: unknown, modifiers: HostModifiers) => boolean;
+    /**
+     * Commit the live value from a component host's `input` emit. A
+     * payload that is a non-Event object owning a `value` property (the
+     * shape PrimeVue's InputNumber reports per keystroke) writes that
+     * value through `setValueFromHost`; anything else, a native `Event`
+     * reaching a fallthrough listener included, is ignored and returns
+     * `false`. The injected `onInput` handler is the only caller.
+     *
+     * @internal
+     */
+    setValueFromHostInput: (payload: unknown, modifiers: HostModifiers) => boolean;
+    /**
+     * The final step of a component-host write, after modifiers,
+     * transforms and coercion: an empty signal (`''`, `null` or
+     * `undefined`) the field's schema does not admit marks the field
+     * blank, and anything else writes through. Called by the host write
+     * channel.
      *
      * @internal
      */
-    setValueFromHost: (value: unknown) => boolean;
+    commitFromHost: (value: unknown) => boolean;
     /**
      * Mark this field DOM-connected during SSR, so a server-rendered
      * template reading `form.fields.<path>.connected` does not flicker on
@@ -2312,11 +2428,12 @@ type RegisterValue<Value = unknown> = Readonly<{
      * every later registration.
      *
      * Optional, so a hand-rolled RegisterValue owning its own element
-     * handling need not declare it.
+     * handling need not declare it. Returns the armed binding, which is how
+     * the directive reaches the host write channel.
      *
      * @internal
      */
-    ensureDomBinding?: (factory: DomBindingFactory) => void;
+    ensureDomBinding?: (factory: DomBindingFactory) => AttaformDomBinding;
     /**
      * Canonical JSON-encoded path key for this binding, such as
      * `'["items",0,"name"]'`. Useful for stable Map and Set keys, log
@@ -2576,9 +2693,10 @@ type CustomRegisterDirective<T, Modifiers extends string = string> = ObjectDirec
     /**
      * Snapshot of the last `value.innerRef.value` reference the
      * directive's DOM-sync (setSelected / setChecked / radio
-     * `el.checked = …`) was applied for. Used by every input
-     * directive's `updated` / `beforeUpdate` to skip the per-render
-     * DOM sync when the model is identity-unchanged, so a parent
+     * `el.checked = …` / text `el.value = …`) was applied for. Used by
+     * every input directive's `updated` / `beforeUpdate` to skip the
+     * per-render DOM sync when the model is identity-unchanged (for
+     * text, a focused `.lazy` edit is held through it), so a parent
      * re-render (a typed character in a sibling, an async-validation
      * tick, any reactive read) cannot clobber an in-progress user
      * interaction. Identity comparison is sound because every form
@@ -2604,16 +2722,18 @@ type CustomRegisterDirective<T, Modifiers extends string = string> = ObjectDirec
 }, RegisterValue | undefined, Modifiers, string>;
 /**
  * Modifier names supported by `v-register` on `<input type="text">`,
- * `<input type="number">`, and `<textarea>`. Mirrors Vue's
- * `v-model` modifier semantics on the same elements; combine freely
- * (`<input v-register.lazy.trim.number="..." />`).
+ * `<input type="number">`, `<textarea>`, and component hosts. Mirrors
+ * Vue's `v-model` modifier semantics on the same elements; combine
+ * freely (`<input v-register.lazy.trim.number="..." />`).
  */
 type RegisterTextModifier = 
 /**
  * Write on `change` (blur) instead of `input`. The reactive
  * model only updates after the user tabs/clicks out of the
  * field. IME composition handlers are skipped under `.lazy`, since
- * composition events do not gate writes.
+ * composition events do not gate writes. On a component host the
+ * last value emitted while focus is inside the host commits when
+ * focus leaves it.
  */
 'lazy'
 /**
@@ -2621,18 +2741,30 @@ type RegisterTextModifier =
  * the user's raw input (whitespace included) while they're
  * typing; on `change` (blur / commit) the value is trimmed
  * once and written back to both the model and the visible DOM.
- * Combine with `.lazy` to skip the mid-typing writes entirely.
+ * Combine with `.lazy` to skip the mid-typing writes entirely. On a
+ * component host the trimmed value commits when focus leaves the
+ * host.
  */
  | 'trim'
 /**
- * Cast the value with `parseFloat` before writing. A value that
- * does not parse as a number (`'abc'`) passes through unchanged,
- * and the slim-primitive gate then sees a string heading for a
- * numeric slot and rejects the write. Auto-applied for
- * `<input type="number">`, where an explicit `.number` is
- * redundant.
+ * Cast the value with `parseFloat` before writing. An empty field,
+ * or text that does not parse as a number (`'abc'`), marks the field
+ * blank instead of writing a string. On a component host the cast
+ * applies to string emits, and a value the component already typed
+ * passes through. Auto-applied for `<input type="number">`, where an
+ * explicit `.number` is redundant.
  */
  | 'number';
+/**
+ * The `v-register` modifiers a component host honours, carried from the
+ * binding site to the host write channel as a static literal that the
+ * compile-time bridge transform emits. Shaped like Vue's directive
+ * modifiers, so the directive passes a binding's modifiers to the channel
+ * unchanged.
+ *
+ * @internal
+ */
+type HostModifiers = Readonly<Partial<Record<RegisterTextModifier, boolean>>>;
 /**
  * v-register directive variant for `<input type="text">`,
  * `<input type="number">` and `<textarea>`. Supports the `.lazy`,
@@ -2855,6 +2987,13 @@ type FieldState<Value = unknown> = {
     readonly dirty: boolean;
     readonly focused: boolean | null;
     readonly blurred: boolean | null;
+    /**
+     * `true` once this field has been blurred, with or without an edit.
+     * Sticky thereafter, including through a value round trip; cleared by
+     * `form.reset()` / `form.resetField(path)`. Containers roll it up as
+     * a disjunction, and keep it after the descendant that set it is
+     * removed.
+     */
     readonly touched: boolean;
     /**
      * `true` once the user has issued at least one value edit on this
@@ -2866,7 +3005,8 @@ type FieldState<Value = unknown> = {
      * flips `touched` but never `interacted`. Set only by user input,
      * never by hydration or programmatic `setValue`; cleared by
      * `form.reset()` / `form.resetField(path)`. Containers roll it up as
-     * a disjunction (any descendant interacted).
+     * a disjunction (any descendant interacted), and keep it after the
+     * descendant that set it is removed.
      */
     readonly interacted: boolean;
     /**
@@ -2879,7 +3019,8 @@ type FieldState<Value = unknown> = {
      * visible through a re-focus to be fixed live. Set only by user
      * input/blur, never by hydration or programmatic writes; cleared by
      * `form.reset()` / `form.resetField(path)`. Containers roll it up as a
-     * disjunction.
+     * disjunction, and keep it after the descendant that set it is
+     * removed.
      */
     readonly blurredAfterInteraction: boolean;
     readonly connected: boolean;
@@ -2915,6 +3056,18 @@ type FieldState<Value = unknown> = {
      * `elements[0] ?? null`.
      */
     readonly elements: readonly HTMLElement[];
+    /**
+     * ISO timestamp of the most recent write at this path or anywhere
+     * under it, counting the form's creation. A removal is a write too, so
+     * a container's stamp moves forward when a row leaves and never moves
+     * backwards. A survivor keeps its own stamp when a removal or a reorder
+     * moves it to a new index, and a write that changes nothing stamps
+     * nothing. Every write that changes a value reads later than the one
+     * before it: two writes in one millisecond, or a write on a device whose
+     * clock runs behind the server that rendered the page, take one
+     * millisecond past the latest stamp the form holds. `null` only for a
+     * path never written or no longer present.
+     */
     readonly updatedAt: string | null;
     /**
      * Every `ValidationError` in this path's SUBTREE: the node's own
@@ -4252,7 +4405,9 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
      *   - the form value back to defaults;
      *   - the dirty baseline (so the next edit flips `dirty` correctly);
      *   - field errors;
-     *   - touched / focused / blurred per-field flags;
+     *   - the interaction history (`touched` / `interacted` /
+     *     `blurredAfterInteraction`) at every path, containers included;
+     *     `focused`, `blurred` and `connected` follow the DOM and stay;
      *   - submission state (`submitting` / `submissionAttempts` /
      *     `submitted` / `submitError`).
      *
@@ -4279,8 +4434,10 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
     reset: (nextDefaultValues?: DefaultValuesInput<Form>) => void;
     /**
      * Restore a single field (or a sub-tree like `'user'`) to its
-     * initial value. Clears errors and touched flags for the field
-     * and its descendants; leaves siblings and submission state alone.
+     * initial value. Clears errors and the interaction history
+     * (`touched` / `interacted` / `blurredAfterInteraction`) for the
+     * field and its descendants; leaves siblings, ancestors and
+     * submission state alone.
      *
      * No-op when the path doesn't exist on the form (e.g. a typo'd
      * dynamic key).
@@ -4549,5 +4706,5 @@ type UseFormReturnType<Form extends GenericForm, GetValueFormType extends Generi
     blankPaths: ComputedRef<BlankPathsView>;
 };
 
-export { ROOT_PATH as R, canonicalizePath as aj, isPathPrefix as ak, isUnset as al, parseDottedPath as am, unset as an, ROOT_PATH_KEY as z };
-export type { SchemaDefaultsResult as $, AbstractSchema as A, ReactiveValidationStatus as B, CustomDirectiveRegisterAssignerFn as C, DefaultValuesInput as D, ErrorInput as E, FormKey as F, GenericForm as G, HandleSubmit as H, IsTuple as I, JoinSegments as J, KeyofUnion as K, LiftedValueShape as L, MetaTrackerValue as M, NestedReadType as N, OnError as O, ParseOptions as P, RecordPath as Q, RecordValue as S, RegisterDirective as T, UseFormConfiguration as U, RegisterFlatPath as V, RegisterOptions as W, RegisterSelectModifier as X, RegisterTextModifier as Y, RegisterTransform as Z, RegisterValue as _, UseFormReturnType as a, SchemaParseErrorWithData as a0, SchemaParseErrorWithoutData as a1, SchemaParseResult as a2, SchemaParseSuccess as a3, Segment as a4, SetValueCallback as a5, SetValuePayload as a6, SettledValidationStatus as a7, SlimPrimitiveKind as a8, SubmitHandler as a9, Unset as aa, ValidateOn as ab, ValidateOnConfig as ac, ValidationError as ad, ValidationResponse as ae, ValidationResponseWithoutValue as af, ValueOfUnion as ag, WriteMeta as ah, WriteShape as ai, RegisterModelDynamicCustomDirective as ao, SchemaFactoryOptions as ap, AcceptableDefaults as aq, DisplayCtx as ar, GetDisplayState as as, DisplayMachine as at, FieldRecord as au, ErrorCell as av, OriginalsRecord as aw, AttaformDomBinding as ax, TransformAbortHolder as ay, ArrayItem as b, ArrayPath as c, DeepPartial as d, DefaultValuesShape as e, DisplayState as f, ErrorsProxyShape as g, FieldMetaPayload as h, FieldState as i, FieldStateMap as j, FieldStateMapEntry as k, FlatPath as l, FormErrorRecord as m, FormErrorsSurface as n, FormMeta as o, HistoryPlugin as p, IsUnion as q, Json as r, NestedType as s, OnSubmit as t, PartialFlatPath as u, Path as v, PathKey as w, PendingValidationStatus as x, Primitive as y };
+export { ROOT_PATH as R, canonicalizePath as ai, isPathPrefix as aj, isUnset as ak, parseDottedPath as al, unset as am, ROOT_PATH_KEY as z };
+export type { SchemaParseErrorWithData as $, AbstractSchema as A, ReactiveValidationStatus as B, CustomDirectiveRegisterAssignerFn as C, DefaultValuesInput as D, ErrorInput as E, FormKey as F, GenericForm as G, HandleSubmit as H, IsTuple as I, JoinSegments as J, KeyofUnion as K, LiftedValueShape as L, MetaTrackerValue as M, NestedReadType as N, OnError as O, ParseOptions as P, RecordPath as Q, RecordValue as S, RegisterDirective as T, UseFormConfiguration as U, RegisterFlatPath as V, RegisterOptions as W, RegisterSelectModifier as X, RegisterTextModifier as Y, RegisterTransform as Z, RegisterValue as _, UseFormReturnType as a, SchemaParseErrorWithoutData as a0, SchemaParseResult as a1, SchemaParseSuccess as a2, Segment as a3, SetValueCallback as a4, SetValuePayload as a5, SettledValidationStatus as a6, SlimPrimitiveKind as a7, SubmitHandler as a8, Unset as a9, ValidateOn as aa, ValidateOnConfig as ab, ValidationError as ac, ValidationResponse as ad, ValidationResponseWithoutValue as ae, ValueOfUnion as af, WriteMeta as ag, WriteShape as ah, RegisterModelDynamicCustomDirective as an, SchemaFactoryOptions as ao, AcceptableDefaults as ap, DisplayCtx as aq, GetDisplayState as ar, DisplayMachine as as, FieldRecord as at, ErrorCell as au, OriginalsRecord as av, StructureSnapshot as aw, AttaformDomBinding as ax, TransformAbortHolder as ay, ArrayItem as b, ArrayPath as c, DeepPartial as d, DefaultValuesShape as e, DisplayState as f, ErrorsProxyShape as g, FieldMetaPayload as h, FieldState as i, FieldStateMap as j, FieldStateMapEntry as k, FlatPath as l, FormErrorRecord as m, FormErrorsSurface as n, FormMeta as o, HistoryPlugin as p, IsUnion as q, Json as r, NestedType as s, OnSubmit as t, PartialFlatPath as u, Path as v, PathKey as w, PendingValidationStatus as x, Primitive as y };