attaform 0.30.1 → 0.31.1

package/dist/{dev/shared/attaform-dev.CZz4GYZ6.mjs → shared/attaform.BPSqtU7a.mjs}

@@ -1,4 +1,5 @@
-import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform-dev.zlvDr0WB.mjs';
+import { s as safeAssign, a as safeOwnRead, r as readConsumerIndex, c as consumerKeys, b as readConsumerProp } from './attaform._1Zp3mDG.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.BhtAZysa.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -9,11 +10,6 @@ const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
   const { value, source, min, defaultValue } = config;
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    {
-      console.warn(
-        `[attaform] ${source} must be a non-negative finite integer; got ${String(value)}. Falling back to ${String(defaultValue)}.`
-      );
-    }
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -26,124 +22,6 @@ function pickDefined(bag) {
   return out;
 }
 
-const reported = /* @__PURE__ */ new Set() ;
-function reportConsumerThrow(site, detail, err) {
-  const key = detail === void 0 ? site : `${site}|${detail}`;
-  if (reported === null || reported.has(key)) return;
-  reported.add(key);
-  const at = detail === void 0 ? "" : ` at \`${detail}\``;
-  const advice = {
-    "default-factory": "a `.default(() => ...)` factory threw. Attaform used `undefined` for that field's initial value.",
-    "catch-factory": "a `.catch(() => ...)` fallback threw. Attaform used `undefined` for that value.",
-    "lazy-getter": "a `z.lazy(() => ...)` factory threw. Attaform stopped descending at that node, so paths below it will not resolve.",
-    "wizard-slot": `a function step slot threw${at}. Attaform dropped that step from the compiled list; the rest of the flow still navigates.`,
-    "wizard-lazy-slot": `a \`lazy()\` step resolver threw${at}. Attaform dropped that step from the compiled list until the resolver's own dependencies change.`,
-    "wizard-progress": "a `useWizard({ progress })` override threw. Attaform fell back to its own valid-step ratio.",
-    "wizard-restore": "a `useWizard({ restore })` callback threw. Attaform read no step from it, so the wizard stays where it is.",
-    "wizard-persist": "a `useWizard({ persist })` callback threw. Attaform navigated anyway, so the step is live but unrecorded.",
-    "wizard-default-statuses": "a `useWizard({ defaultStatuses })` factory threw or rejected. Attaform seeded no statuses, the same as omitting the option."
-  };
-  console.error(
-    `[attaform] ${advice[site]} Attaform has nowhere to surface this, so it must not throw; wrap your own try/catch if the failure is recoverable. Original error:`,
-    err
-  );
-}
-function callConsumerFn(fn, fallback, site, detail) {
-  try {
-    return fn();
-  } catch (err) {
-    reportConsumerThrow(site, detail, 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;
-  }
-}
-
 function isDescendable(value) {
   if (value === null || typeof value !== "object") return false;
   if (Array.isArray(value)) return true;
@@ -151,6 +29,9 @@ function isDescendable(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
+function isBarePatch(patch) {
+  return patch.kind === "added" ? isDescendable(patch.newValue) : patch.kind === "removed" && isDescendable(patch.oldValue);
+}
 function appendSegment(prefix, segment) {
   const next = new Array(prefix.length + 1);
   for (let i = 0; i < prefix.length; i++) {
@@ -165,11 +46,11 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   const oldIsDescendable = isDescendable(oldValue);
   const newIsDescendable = isDescendable(newValue);
   if (oldValue === void 0 && newIsDescendable) {
-    walkNewDescendable(newValue, prefix, visit);
+    walkDescendable(newValue, prefix, visit, true);
     return;
   }
   if (oldIsDescendable && newValue === void 0) {
-    walkOldDescendable(oldValue, prefix, visit);
+    walkDescendable(oldValue, prefix, visit, false);
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
@@ -219,50 +100,51 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
   }
   visit({ kind: "changed", path: prefix, oldValue, newValue });
 }
-function walkNewDescendable(newValue, prefix, visit) {
-  if (Array.isArray(newValue)) {
-    for (let i = 0; i < newValue.length; i++) {
-      diffAndApply(void 0, readConsumerIndex(newValue, i), appendSegment(prefix, i), visit);
+function walkDescendable(value, prefix, visit, arrived) {
+  let reported = false;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      diffSlot(readConsumerIndex(value, i), appendSegment(prefix, i), visit, arrived);
     }
-  } else if (newValue instanceof Map) {
-    for (const [key, entry] of newValue) {
-      diffAndApply(void 0, entry, appendSegment(prefix, key), visit);
+    reported = value.length > 0;
+  } else if (value instanceof Map) {
+    for (const [key, entry] of value) {
+      diffSlot(entry, appendSegment(prefix, key), visit, arrived);
     }
+    reported = value.size > 0;
   } else {
-    const rec = newValue;
+    const rec = value;
     for (const k of consumerKeys(rec)) {
-      diffAndApply(void 0, readConsumerProp(rec, k), appendSegment(prefix, k), visit);
+      const entry = readConsumerProp(rec, k);
+      if (entry === void 0) continue;
+      reported = true;
+      if (arrived) diffAndApply(void 0, entry, appendSegment(prefix, k), visit);
+      else diffAndApply(entry, void 0, appendSegment(prefix, k), visit);
     }
   }
+  if (!reported) visit(presencePatch(arrived, prefix, value));
 }
-function walkOldDescendable(oldValue, prefix, visit) {
-  if (Array.isArray(oldValue)) {
-    for (let i = 0; i < oldValue.length; i++) {
-      diffAndApply(readConsumerIndex(oldValue, i), void 0, appendSegment(prefix, i), visit);
-    }
-  } else if (oldValue instanceof Map) {
-    for (const [key, entry] of oldValue) {
-      diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
-    }
-  } else {
-    const rec = oldValue;
-    for (const k of consumerKeys(rec)) {
-      diffAndApply(readConsumerProp(rec, k), void 0, appendSegment(prefix, k), visit);
-    }
-  }
+function diffSlot(entry, path, visit, arrived) {
+  if (entry === void 0) visit(presencePatch(arrived, path, entry));
+  else if (arrived) diffAndApply(void 0, entry, path, visit);
+  else diffAndApply(entry, void 0, path, visit);
+}
+function presencePatch(arrived, path, value) {
+  return arrived ? { kind: "added", path, newValue: value } : { kind: "removed", path, oldValue: value };
 }
 function diffMapsLockstep(oldMap, newMap, prefix, visit) {
   for (const [key, entry] of newMap) {
-    diffAndApply(oldMap.get(key), entry, appendSegment(prefix, key), visit);
+    const path = appendSegment(prefix, key);
+    if (oldMap.has(key)) diffAndApply(oldMap.get(key), entry, path, visit);
+    else diffSlot(entry, path, visit, true);
   }
   for (const [key, entry] of oldMap) {
-    if (newMap.has(key)) continue;
-    diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+    if (!newMap.has(key)) diffSlot(entry, appendSegment(prefix, key), visit, false);
   }
 }
 function diffArraysLockstep(oldArr, newArr, prefix, visit) {
-  const max = Math.max(oldArr.length, newArr.length);
-  for (let i = 0; i < max; i++) {
+  const min = Math.min(oldArr.length, newArr.length);
+  for (let i = 0; i < min; i++) {
     diffAndApply(
       readConsumerIndex(oldArr, i),
       readConsumerIndex(newArr, i),
@@ -270,6 +152,12 @@ function diffArraysLockstep(oldArr, newArr, prefix, visit) {
       visit
     );
   }
+  for (let i = min; i < newArr.length; i++) {
+    diffSlot(readConsumerIndex(newArr, i), appendSegment(prefix, i), visit, true);
+  }
+  for (let i = min; i < oldArr.length; i++) {
+    diffSlot(readConsumerIndex(oldArr, i), appendSegment(prefix, i), visit, false);
+  }
 }
 function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
   const seen = /* @__PURE__ */ new Set();
@@ -383,4 +271,4 @@ function structuralSnapshot(value) {
   return out;
 }
 
-export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerFn as c, safeOwnHas as d, consumerHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, reportConsumerThrow as t, ANONYMOUS_WIZARD_KEY_PREFIX as u };
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as a, isDescendable as b, applyChangedKeys as c, diffAndApply as d, DEFAULT_MAX_RECURSION_DEPTH as e, ANONYMOUS_WIZARD_KEY_PREFIX as f, isBarePatch as i, normalizeNumericOption as n, pickDefined as p, structuralSnapshot as s };

package/dist/shared/{attaform.CdZIEf7_.mjs → attaform.BhtAZysa.mjs}

@@ -114,7 +114,8 @@ const canonicalStringCache = /* @__PURE__ */ new Map();
 const PATHKEY_TO_SEGMENTS_MAX = 4096;
 const pathKeyToSegments = /* @__PURE__ */ new Map();
 function rememberSegmentsForPathKey(key, segments) {
-  if (!pathKeyToSegments.has(key) && pathKeyToSegments.size >= PATHKEY_TO_SEGMENTS_MAX) {
+  if (pathKeyToSegments.has(key)) return;
+  if (pathKeyToSegments.size >= PATHKEY_TO_SEGMENTS_MAX) {
     const oldest = pathKeyToSegments.keys().next().value;
     if (oldest !== void 0) pathKeyToSegments.delete(oldest);
   }
@@ -156,7 +157,7 @@ function canonicalizePath(input) {
   return keyForSegments(input);
 }
 function keyForSegments(input) {
-  const segments = Array.from(input).map(normalizeSegment);
+  const segments = input.map(normalizeSegment);
   const key = JSON.stringify(segments);
   rememberSegmentsForPathKey(key, segments);
   return { segments, key };

package/dist/shared/{attaform.BcQwgWaq.d.mts → attaform.CYlF4P6X.d.mts}

@@ -1,4 +1,4 @@
-import { G as GenericForm, F as FormKey, a as UseFormReturnType, _ as RegisterValue, v as Path, w as PathKey, ar as DisplayCtx, as as GetDisplayState, at as DisplayMachine, au as FieldRecord, av as ErrorCell, ad as ValidationError, aw as OriginalsRecord, A as AbstractSchema, ah as WriteMeta, d as DeepPartial, ai as WriteShape, ax as AttaformDomBinding, ay as TransformAbortHolder } from './attaform.Br8EBn5B.mjs';
+import { G as GenericForm, F as FormKey, a as UseFormReturnType, _ as RegisterValue, v as Path, w as PathKey, aq as DisplayCtx, ar as GetDisplayState, as as DisplayMachine, at as FieldRecord, au as ErrorCell, ac as ValidationError, av as OriginalsRecord, A as AbstractSchema, ag as WriteMeta, d as DeepPartial, ah as WriteShape, aw as StructureSnapshot, ax as AttaformDomBinding, ay as TransformAbortHolder } from './attaform.i13OEHJF.mjs';
 import { Ref, ComputedRef, ShallowRef, App, InjectionKey, Plugin } from 'vue';
 
 /** Options accepted by `injectForm` in place of a bare key string. */
@@ -48,6 +48,10 @@ type InjectFormInput = {
  * Pass the `Form` generic explicitly, since Vue's provide/inject erases
  * generics. The form stays alive for this component's lifetime and is
  * cleaned up once every consumer has unmounted.
+ *
+ * Components whose nearest `useForm`-calling ancestor is the same one get
+ * the same form object for the same form: `injectForm('cart')` in two of
+ * its descendants returns one form, with one set of field caches.
  */
 declare function injectForm<Form extends GenericForm, GetValueFormType extends GenericForm = Form>(input?: FormKey | InjectFormInput): UseFormReturnType<Form, GetValueFormType> | null;
 
@@ -135,6 +139,10 @@ type UseRegisterOptions = {
  * `.value` unwrap. Reads inside a `computed` or `watchEffect` re-run
  * when the parent rebinds to a different path.
  *
+ * Modifiers on the parent's binding apply at the inner control, so
+ * `<MyInput v-register.trim="form.register('email')" />` trims there,
+ * together with any the wrapper writes on its own `v-register`.
+ *
  * When no parent bound, every field reads `undefined`, so reach for
  * `rv?.path`. `v-register="rv"` is still safe. A wrapper that is meant
  * to render both with and without a form declares it with
@@ -159,9 +167,10 @@ type DynamicPathSweep = {
      * `PathKey` of a path the form no longer has, and deletes whatever it
      * files under that path. A cache keying by more than the path (a
      * shape sigil, say) deletes every variant; a key it never held is a
-     * no-op.
+     * no-op. Returns the release, which a registrant that does not live
+     * as long as the form must call.
      */
-    readonly onEvict: (evict: (key: PathKey) => void) => void;
+    readonly onEvict: (evict: (key: PathKey) => void) => () => void;
 };
 
 /**
@@ -277,6 +286,13 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     readonly pathSweep: DynamicPathSweep;
     readonly formKey: FormKey;
     readonly form: Ref<F>;
+    /**
+     * Per-path field records: one per leaf from construction, and one per
+     * container, the root (`[]`) included, once a directive binds to it or a
+     * write takes leaves away beneath it. A container's own record holds the
+     * stamp of that write and the interaction history of the descendants it
+     * took; see `stampContainers` and `foldInteractionHistory`.
+     */
     readonly fields: Map<PathKey, FieldRecord>;
     /**
      * The tagged error store: one cell per error-bearing path, each segregating
@@ -290,8 +306,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * mutated so Vue's per-key Map tracking fires for either side. Derived blank
      * entries are not stored here; they synthesize at read
      * (`derivedBlankErrors`).
+     *
+     * A method, not a property, because it is also the gate on the
+     * construction seed: the first call runs it (see `createErrorCells`). A
+     * getter on the store object would gate a property read the same way,
+     * but V8 builds an object literal holding an accessor in dictionary mode,
+     * and every kernel read of the store would then pay a hash lookup.
      */
-    readonly errorCells: Map<PathKey, ErrorCell>;
+    readonly errorCells: () => Map<PathKey, ErrorCell>;
     /**
      * Reactively-derived "No value supplied" errors: a pure function of
      * `(blankPaths, schema.isRequiredAtPath)` with no writers and no clears.
@@ -492,10 +514,15 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * side, because no errors at frame 1 means "not checked yet", not "checked
      * and clean".
      *
-     * The window it closes: where the slim default-derivation parse strips
-     * refinements (`.refine`, `.superRefine`, async validators) the slim parse
-     * passes, no construction errors land, and the queued microtask has not run,
-     * so frame 1 would paint the form valid a tick before the real verdict.
+     * The window it closes: a schema with async work gets no verdict from the
+     * construction parse (v4 skips it for an async refine or transform; v3 skips
+     * it for an async transform and mounts clean when it throws over an async
+     * refine), so no construction errors land, and until the queued async pass
+     * runs, frame 1 would paint the form valid a tick before the real verdict.
+     * A sync-only schema's construction parse seeds its verdict synchronously,
+     * before the first read of its errors returns, so its gate starts open. v3
+     * reports every `.refine` as async, so a v3 schema with a sync refine
+     * starts gated and seeded.
      *
      * `reset()` restores it to the same construction-time seed, so the post-reset
      * window gates exactly like the post-mount one.
@@ -621,6 +648,19 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * empty is skipped.
      */
     restoreErrorCells(entries: ReadonlyArray<readonly [PathKey, ErrorCell]>): void;
+    /**
+     * The per-element bookkeeping as it stands, for a history position to put
+     * back with its value (see `StructureSnapshot`). The entries are copied,
+     * and the records they hold are never mutated in place, so the snapshot
+     * stays detached from the live store.
+     */
+    captureStructure(): StructureSnapshot;
+    /**
+     * Put a `captureStructure()` back, before the value it was taken with is
+     * restored, so the write that restores it compares each row against its
+     * own baseline. Every reading it can change is woken.
+     */
+    restoreStructure(snapshot: StructureSnapshot): void;
     /**
      * Merged read of the cell at `path`, in schema -> blank -> user order:
      * structural validation first, the synthesized blank entry between, user
@@ -709,18 +749,19 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * insert or removal) against its construction / reset baseline. The
      * structural half of `dirty`: per-element baselines travel with their
      * element across a mutation, so a positional value comparison alone cannot
-     * see the shape change.
+     * see the shape change. `key` is the canonical key of `path`.
      */
-    hasStructuralChangeUnder(path: Path): boolean;
+    hasStructuralChangeUnder(path: Path, key: PathKey): boolean;
     /**
-     * Whether a baseline-present container under `path` was replaced wholesale
-     * by a non-container (`setValue('profile', undefined)` and the like) and is
-     * still absent. The other half of removal-driven `dirty`: every leaf in such
-     * a subtree vanishes at once, so neither the present-leaf walk nor the array
-     * tracker sees the loss. Self-filters by current liveness, so a refilled
-     * path stops counting.
+     * Whether a path under `path` that held a real baseline value was removed
+     * and is still absent: a dropped key, an emptied container, a row a
+     * wholesale write took away. The other half of removal-driven `dirty`: the
+     * present-leaf walk never visits an absent leaf, and the array tracker
+     * follows only array lengths and orders. A path a later write brought back
+     * stops counting, and the present-leaf walk judges it instead. `key` is the
+     * canonical key of `path`.
      */
-    hasRemovedSubtreeUnder(path: Path): boolean;
+    hasRemovedSubtreeUnder(path: Path, key: PathKey): boolean;
     getFieldRecord(path: Path): FieldRecord | undefined;
     /**
      * Cancel every in-flight field-level validation run: clear the timers of

package/dist/shared/{attaform.WiGdIqgx.mjs → attaform.CdA9bfRv.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CdZIEf7_.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.BhtAZysa.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {
@@ -168,8 +168,8 @@ function renderAttaformState(app) {
         // The wire shape stays two per-source arrays; the tagged store
         // splits at the boundary and the client replays each side into
         // its cell half.
-        schemaErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
-        userErrors: [...state.errorCells.entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
+        schemaErrors: [...state.errorCells().entries()].filter(([, cell]) => cell.schema.length > 0).map(([key2, cell]) => [key2, cell.schema]),
+        userErrors: [...state.errorCells().entries()].filter(([, cell]) => cell.user.length > 0).map(([key2, cell]) => [key2, cell.user]),
         fields: Array.from(state.fields.entries()),
         ...transientList.length > 0 ? { blankPaths: transientList } : {}
       }