attaform 0.21.2 → 0.23.0

package/dist/chunks/wire-persistence.cjs

@@ -1,396 +0,0 @@
-'use strict';
-
-const vue = require('vue');
-const injectWizard = require('../shared/attaform.D2ZuIOCf.cjs');
-const paths = require('../shared/attaform.B5LNzqQh.cjs');
-
-const PERSISTED_ENVELOPE_VERSION = 6;
-function readPersistedPayload(value) {
-  if (value === null || value === void 0 || typeof value !== "object") return null;
-  const envelope = value;
-  if (typeof envelope.v !== "number") return null;
-  if (envelope.v !== PERSISTED_ENVELOPE_VERSION) {
-    warnVersionMismatch(envelope.v);
-    return null;
-  }
-  if (envelope.data === void 0 || typeof envelope.data !== "object") return null;
-  return envelope;
-}
-const warnedVersions = paths.__DEV__ ? /* @__PURE__ */ new Set() : null;
-function warnVersionMismatch(observedVersion) {
-  if (warnedVersions === null) return;
-  if (warnedVersions.has(observedVersion)) return;
-  warnedVersions.add(observedVersion);
-  console.warn(
-    `[attaform] Dropping persisted draft \u2014 envelope v=${observedVersion}, but this version of the library expects v=${PERSISTED_ENVELOPE_VERSION}. The persisted shape changed across releases; older drafts can't be restored. New drafts saved this session will use the current envelope.`
-  );
-}
-function buildPersistedPayload(form, include, schemaErrors, userErrors, blankPaths) {
-  let transientList;
-  if (blankPaths !== void 0 && blankPaths.size > 0) {
-    transientList = [...blankPaths];
-  }
-  if (include === "form") {
-    if (transientList === void 0) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } };
-    return {
-      v: PERSISTED_ENVELOPE_VERSION,
-      data: { form, blankPaths: transientList }
-    };
-  }
-  return {
-    v: PERSISTED_ENVELOPE_VERSION,
-    data: {
-      form,
-      schemaErrors: [...schemaErrors.entries()].map(([k, v]) => [k, [...v]]),
-      userErrors: [...userErrors.entries()].map(([k, v]) => [k, [...v]]),
-      ...transientList !== void 0 ? { blankPaths: transientList } : {}
-    }
-  };
-}
-function createDebouncedWriter(write, debounceMs) {
-  let timer = null;
-  let pending = null;
-  let writeGeneration = 0;
-  function runWrite() {
-    const gen = ++writeGeneration;
-    pending = write().finally(() => {
-      if (writeGeneration === gen) pending = null;
-    });
-  }
-  function schedule() {
-    if (timer !== null) clearTimeout(timer);
-    if (debounceMs === 0) {
-      runWrite();
-      return;
-    }
-    timer = setTimeout(() => {
-      timer = null;
-      runWrite();
-    }, debounceMs);
-  }
-  async function flush() {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-      runWrite();
-    }
-    while (pending !== null) {
-      const awaited = pending;
-      await awaited;
-      if (pending === awaited) break;
-    }
-  }
-  function cancel() {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  }
-  return { schedule, flush, cancel };
-}
-function pluckPaths(form, pathKeys) {
-  let sparse = void 0;
-  for (const pathKey of pathKeys) {
-    const segments = paths.segmentsForPathKey(pathKey);
-    if (segments === null) continue;
-    const value = injectWizard.getAtPath(form, segments);
-    if (value === void 0) continue;
-    sparse = injectWizard.setAtPath(sparse ?? {}, segments, value);
-  }
-  return sparse ?? {};
-}
-function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath) {
-  const acknowledgedSensitive = [];
-  for (const key of optedInPaths) {
-    const segs = paths.segmentsForPathKey(key);
-    if (segs !== null && isSensitivePath(segs)) acknowledgedSensitive.push(segs);
-  }
-  const coveredByAcknowledged = (path) => acknowledgedSensitive.some((prefix) => paths.isPathPrefix(prefix, path));
-  const walk = (path, value) => {
-    if (path.length > 0 && isSensitivePath(path) && !coveredByAcknowledged(path)) {
-      return void 0;
-    }
-    if (value === null || typeof value !== "object") return value;
-    if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item));
-    if (!injectWizard.isPlainRecord(value)) return value;
-    const out = {};
-    for (const key of Object.keys(value)) {
-      const walked = walk([...path, key], value[key]);
-      if (walked !== void 0) injectWizard.safeAssign(out, key, walked);
-    }
-    return out;
-  };
-  return walk([], form);
-}
-function filterErrorsByPaths(errors, pathKeys) {
-  const out = /* @__PURE__ */ new Map();
-  for (const [key, value] of errors) {
-    if (pathKeys.has(key)) out.set(key, value);
-  }
-  return out;
-}
-
-function wirePersistence(state, config, adapterPromise, fingerprintToken) {
-  const base = injectWizard.resolveStorageKeyBase(config, state.formKey);
-  const key = `${base}:${fingerprintToken}`;
-  const debounceMs = injectWizard.normalizeNumericOption({
-    value: config.debounceMs ?? injectWizard.DEFAULT_PERSISTENCE_DEBOUNCE_MS,
-    source: "useForm.persist.debounceMs",
-    allowInfinity: false,
-    min: 0,
-    defaultValue: injectWizard.DEFAULT_PERSISTENCE_DEBOUNCE_MS
-  });
-  const include = config.include ?? "form";
-  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true;
-  let disposed = false;
-  const isDisposed = () => disposed;
-  let inFlightFinalFlush = null;
-  let pendingOptedInPaths = null;
-  const writer = createDebouncedWriter(async () => {
-    const optedInPaths = pendingOptedInPaths ?? new Set(state.persistOptIns.optedInPaths());
-    pendingOptedInPaths = null;
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    if (optedInPaths.size === 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const rawForm = vue.toRaw(state.form.value);
-    const filteredForm = stripUnacknowledgedSensitiveLeaves(
-      pluckPaths(rawForm, optedInPaths),
-      optedInPaths,
-      state.isSensitivePath
-    );
-    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths);
-    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths);
-    const filteredTransientEmpty = /* @__PURE__ */ new Set();
-    for (const tk of state.blankPaths) {
-      if (optedInPaths.has(tk)) filteredTransientEmpty.add(tk);
-    }
-    const payload = buildPersistedPayload(
-      filteredForm,
-      include,
-      filteredSchemaErrors,
-      filteredUserErrors,
-      filteredTransientEmpty
-    );
-    await adapter.setItem(key, payload);
-  }, debounceMs);
-  const unsubscribeChange = state.onFormChange((_next, meta) => {
-    if (isDisposed() || inFlightFinalFlush !== null) return;
-    if (meta?.crossTab === true) return;
-    if (meta?.persist !== true) return;
-    pendingOptedInPaths = new Set(state.persistOptIns.optedInPaths());
-    writer.schedule();
-  });
-  const unsubscribeSuccess = clearOnSubmitSuccess ? state.onSubmitSuccess(() => {
-    if (isDisposed()) return;
-    void (async () => {
-      await writer.flush();
-      if (isDisposed()) return;
-      const adapter = await adapterPromise;
-      if (isDisposed()) return;
-      await adapter.removeItem(key);
-    })();
-  }) : () => void 0;
-  const handlePageHide = () => {
-    if (isDisposed()) return;
-    void writer.flush();
-  };
-  if (typeof window !== "undefined") {
-    window.addEventListener("pagehide", handlePageHide);
-  }
-  void (async () => {
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    void injectWizard.cleanupOrphanKeys(adapter, base, key);
-    try {
-      const raw = await adapter.getItem(key);
-      const payload = readPersistedPayload(raw);
-      if (payload === null) {
-        if (raw !== null && raw !== void 0) {
-          await adapter.removeItem(key);
-        }
-        return;
-      }
-      if (isDisposed()) return;
-      const merged = injectWizard.mergeSparseHydration(
-        vue.toRaw(state.form.value),
-        payload.data.form,
-        state.schema
-      );
-      state.applyFormReplacement(merged, { hydration: true });
-      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form);
-      for (const k of persistedLeafPaths) {
-        state.blankPaths.delete(k);
-        state.originalBlankPaths.delete(k);
-      }
-      for (const k of payload.data.blankPaths ?? []) {
-        state.blankPaths.add(k);
-        state.originalBlankPaths.add(k);
-      }
-      if (include === "form+errors") {
-        if (payload.data.schemaErrors !== void 0) {
-          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs);
-          state.setAllSchemaErrors(flat);
-        }
-        if (payload.data.userErrors !== void 0) {
-          const flat = payload.data.userErrors.flatMap(([, errs]) => errs);
-          state.setAllUserErrors(flat);
-        }
-      }
-      state.scheduleFieldValidation(
-        [],
-        true
-        /* immediate */
-      );
-    } catch {
-    }
-  })();
-  async function writePathImmediately(path) {
-    if (isDisposed()) return;
-    await writer.flush();
-    if (isDisposed()) return;
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    const value = injectWizard.getAtPath(vue.toRaw(state.form.value), path);
-    const nextForm = injectWizard.setAtPath(existing?.data.form ?? {}, path, value);
-    const { key: pathKey } = paths.canonicalizePath(path);
-    const transientSet = new Set(
-      (existing?.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    for (const liveKey of state.blankPaths) {
-      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {
-        transientSet.add(liveKey);
-      }
-    }
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
-    }
-    const schemaMap = new Map(existing?.data.schemaErrors ?? []);
-    const userMap = new Map(existing?.data.userErrors ?? []);
-    const currentSchema = state.schemaErrors.get(pathKey);
-    const currentUser = state.userErrors.get(pathKey);
-    if (currentSchema !== void 0 && currentSchema.length > 0) {
-      schemaMap.set(pathKey, [...currentSchema]);
-    } else {
-      schemaMap.delete(pathKey);
-    }
-    if (currentUser !== void 0 && currentUser.length > 0) {
-      userMap.set(pathKey, [...currentUser]);
-    } else {
-      userMap.delete(pathKey);
-    }
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
-  }
-  async function clearPersistedDraft(path) {
-    if (isDisposed()) return;
-    await writer.flush();
-    if (isDisposed()) return;
-    const adapter = await adapterPromise;
-    if (isDisposed()) return;
-    if (path === void 0) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const raw = await adapter.getItem(key);
-    const existing = readPersistedPayload(raw);
-    if (existing === null) return;
-    const nextForm = injectWizard.deleteAtPath(existing.data.form, path);
-    if (isEmptyContainer(nextForm)) {
-      await adapter.removeItem(key);
-      return;
-    }
-    const { key: pathKey } = paths.canonicalizePath(path);
-    const transientSet = new Set(
-      (existing.data.blankPaths ?? []).filter(
-        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)
-      )
-    );
-    if (include === "form") {
-      await adapter.setItem(
-        key,
-        buildPersistedPayload(nextForm, "form", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), transientSet)
-      );
-      return;
-    }
-    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey);
-    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey);
-    const schemaMap = new Map(schemaErrors.map(([k, v]) => [k, [...v]]));
-    const userMap = new Map(userErrors.map(([k, v]) => [k, [...v]]));
-    await adapter.setItem(
-      key,
-      buildPersistedPayload(nextForm, "form+errors", schemaMap, userMap, transientSet)
-    );
-  }
-  function awaitPendingWrites() {
-    if (inFlightFinalFlush !== null) return inFlightFinalFlush;
-    if (isDisposed()) return Promise.resolve();
-    return writer.flush().catch(() => void 0);
-  }
-  function dispose() {
-    if (isDisposed() || inFlightFinalFlush !== null) return;
-    unsubscribeChange();
-    unsubscribeSuccess();
-    if (typeof window !== "undefined") {
-      window.removeEventListener("pagehide", handlePageHide);
-    }
-    inFlightFinalFlush = writer.flush().catch(() => void 0).finally(() => {
-      disposed = true;
-      inFlightFinalFlush = null;
-    });
-  }
-  return {
-    writePathImmediately,
-    clearPersistedDraft,
-    awaitPendingWrites,
-    dispose
-  };
-}
-function isEmptyContainer(value) {
-  if (value === void 0 || value === null) return true;
-  if (Array.isArray(value)) return value.length === 0;
-  if (injectWizard.isPlainRecord(value)) return Object.keys(value).length === 0;
-  return false;
-}
-function collectPersistedLeafPaths(form) {
-  const out = [];
-  walk(form, []);
-  return out;
-  function walk(node, prefix) {
-    if (Array.isArray(node)) {
-      for (let i = 0; i < node.length; i++) {
-        walk(node[i], [...prefix, i]);
-      }
-      return;
-    }
-    if (injectWizard.isPlainRecord(node)) {
-      for (const key of Object.keys(node)) {
-        walk(node[key], [...prefix, key]);
-      }
-      return;
-    }
-    if (prefix.length === 0) return;
-    out.push(paths.canonicalizePath(prefix).key);
-  }
-}
-function isDescendantPathKey(candidate, ancestor) {
-  if (candidate.length <= ancestor.length) return false;
-  if (!ancestor.endsWith("]")) return false;
-  const childPrefix = `${ancestor.slice(0, -1)},`;
-  return candidate.startsWith(childPrefix);
-}
-
-exports.wirePersistence = wirePersistence;
-//# sourceMappingURL=wire-persistence.cjs.map

package/dist/chunks/wire-persistence.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"wire-persistence.cjs","sources":["../../src/runtime/core/persistence/payload.ts","../../src/runtime/core/persistence/wire-persistence.ts"],"sourcesContent":["import type { ValidationError } from '../../types/types-api'\nimport { __DEV__ } from '../dev'\nimport { isPathPrefix, segmentsForPathKey, type Path, type PathKey } from '../paths'\nimport { getAtPath, isPlainRecord, setAtPath } from '../path-walker'\nimport { safeAssign } from '../safe-assign'\n\n/**\n * Persisted payload envelope.\n *\n * `v` is a attaform-INTERNAL storage-format version — bumped only when the\n * library's persisted payload schema itself changes (e.g. adding a new\n * field, restructuring `data`). It is NOT consumer-controlled.\n * Schema-driven invalidation uses the storage key's `:${fingerprint}`\n * suffix instead, so consumers don't need to manage versioning at all.\n *\n * `data` mirrors the SSR `SerializedFormData` shape so one deserialiser\n * handles both.\n *\n * Errors are stored source-segregated (matching FormStore's split):\n *   - `schemaErrors` is validation-owned; cleared by reset / submit-success.\n *   - `userErrors` is consumer-owned (written via setFieldErrors* APIs);\n *     persists across schema revalidation and successful submits.\n */\nexport type PersistedPayload<Form> = {\n  readonly v: number\n  readonly data: {\n    readonly form: Form\n    readonly schemaErrors?: ReadonlyArray<readonly [string, ValidationError[]]>\n    readonly userErrors?: ReadonlyArray<readonly [string, ValidationError[]]>\n    /**\n     * Canonical `PathKey` JSON entries (`'[\"profile\",\"bio\"]'`) for the\n     * paths that were in the form's `blankPaths` set at serialisation\n     * time. Optional — forms with no blank paths skip the field.\n     * Replayed into the reactive Set on the next mount so an accidental\n     * refresh preserves the user's \"displayed empty\" state across\n     * sessions. Introduced in envelope v=3.\n     *\n     * The encoding restored the JSON-array shape at v=6 (after a v=5\n     * dotted-string detour) so literal-dot record keys\n     * (`record[\"foo.bar\"]` vs `record.foo.bar`) and integer-looking\n     * record keys (`record[\"1\"]` vs `record[1]`) survive the round-trip\n     * unambiguously — the PathKey carries segment kind, dotted\n     * notation does not.\n     */\n    readonly blankPaths?: ReadonlyArray<PathKey>\n  }\n}\n\n/**\n * Current attaform-internal envelope version. Bumped only when the library\n * changes the persisted payload's structural shape — readers reject\n * envelopes with a different `v`. Schema-content invalidation is\n * handled at the storage key level (the `:${fingerprint}` suffix), so\n * consumers shouldn't see this number.\n *\n * v=3: adds `data.blankPaths` for round-tripping the\n * blank UI state across persistence + SSR. v=2 envelopes\n * are dropped with a one-time dev-warn (commit 6 of the unset feature).\n *\n * v=4: `ValidationError` gained a required `code` field. Persisted\n * `schemaErrors` / `userErrors` now include `code`; v=3 payloads are\n * dropped with a one-time dev-warn.\n *\n * v=5: `data.blankPaths` switched from canonical `PathKey` JSON\n * strings (`'[\"profile\",\"bio\"]'`) to dotted public-path strings\n * (`'profile.bio'`), matching the path notation everywhere else in\n * the public API. v=4 payloads are dropped with a one-time dev-warn.\n *\n * v=6: `data.blankPaths` switched BACK to the canonical `PathKey` JSON\n * shape (`'[\"profile\",\"bio\"]'`). The dotted notation collapses literal-\n * dot record keys (`record[\"foo.bar\"]` vs. `record.foo.bar`) and\n * integer-looking record keys (`record[\"1\"]` vs. `record[1]`) onto\n * the same wire shape, silently flipping the blank-mark onto a sibling\n * slot on hydrate. The JSON-array carries segment kind, so the\n * distinction round-trips losslessly. v=5 payloads are dropped with a\n * one-time dev-warn.\n */\nexport const PERSISTED_ENVELOPE_VERSION = 6\n\n/**\n * `value` is expected to be a raw `PersistedPayload` (parsed JSON or\n * structured-cloned object). Returns `null` if the shape doesn't match\n * — the caller falls back to schema defaults.\n *\n * The attaform-internal envelope `v` must match `PERSISTED_ENVELOPE_VERSION`;\n * mismatches (older library versions' payloads) are dropped. Schema\n * change detection lives at the storage-key level via the fingerprint\n * suffix.\n */\nexport function readPersistedPayload<Form>(value: unknown): PersistedPayload<Form> | null {\n  if (value === null || value === undefined || typeof value !== 'object') return null\n  const envelope = value as Partial<PersistedPayload<Form>>\n  if (typeof envelope.v !== 'number') return null\n  if (envelope.v !== PERSISTED_ENVELOPE_VERSION) {\n    warnVersionMismatch(envelope.v)\n    return null\n  }\n  if (envelope.data === undefined || typeof envelope.data !== 'object') return null\n  return envelope as PersistedPayload<Form>\n}\n\n/**\n * Tracks envelope versions we've already warned about during this\n * session. The reader hits this for every form mount that finds\n * stale persisted state, so a page with N saved drafts at an old\n * version would otherwise produce N warnings of the same content.\n * Module-scoped Set survives the test-suite hot-reload cycle but\n * resets on each fresh page load — exactly the dedup window we want.\n *\n * `null` in production so the Set allocation tree-shakes out.\n */\nconst warnedVersions: Set<number> | null = __DEV__ ? new Set<number>() : null\n\nfunction warnVersionMismatch(observedVersion: number): void {\n  if (warnedVersions === null) return\n  if (warnedVersions.has(observedVersion)) return\n  warnedVersions.add(observedVersion)\n  console.warn(\n    `[attaform] Dropping persisted draft — envelope v=${observedVersion}, ` +\n      `but this version of the library expects v=${PERSISTED_ENVELOPE_VERSION}. ` +\n      `The persisted shape changed across releases; older drafts can't be restored. ` +\n      `New drafts saved this session will use the current envelope.`\n  )\n}\n\nexport function buildPersistedPayload<Form>(\n  form: Form,\n  include: 'form' | 'form+errors',\n  schemaErrors: ReadonlyMap<string, ValidationError[]>,\n  userErrors: ReadonlyMap<string, ValidationError[]>,\n  blankPaths?: ReadonlySet<string>\n): PersistedPayload<Form> {\n  // The blank list is part of the form's restorable UI state — its\n  // visibility doesn't depend on the `include` mode (which only governs\n  // whether errors come along for the ride). Skip the field when the\n  // set is empty so v=6 round-trips with unchanged minimal payload\n  // size for forms that never go empty. The PathKey JSON shape (a\n  // JSON-array string) goes through to disk verbatim so segment kind\n  // survives the round-trip — see [[PASS2-8]] and the v=6 docblock\n  // on `PERSISTED_ENVELOPE_VERSION`.\n  let transientList: ReadonlyArray<PathKey> | undefined\n  if (blankPaths !== undefined && blankPaths.size > 0) {\n    transientList = [...blankPaths] as PathKey[]\n  }\n\n  if (include === 'form') {\n    if (transientList === undefined) return { v: PERSISTED_ENVELOPE_VERSION, data: { form } }\n    return {\n      v: PERSISTED_ENVELOPE_VERSION,\n      data: { form, blankPaths: transientList },\n    }\n  }\n  return {\n    v: PERSISTED_ENVELOPE_VERSION,\n    data: {\n      form,\n      schemaErrors: [...schemaErrors.entries()].map(([k, v]) => [k, [...v]] as const),\n      userErrors: [...userErrors.entries()].map(([k, v]) => [k, [...v]] as const),\n      ...(transientList !== undefined ? { blankPaths: transientList } : {}),\n    },\n  }\n}\n\n/**\n * Tiny debounce utility. Returns a `{ schedule, flush, cancel }`\n * triple — `schedule` delays a single pending write, `flush` runs it\n * immediately, `cancel` drops it. Unlike a library `debounce`, this\n * one awaits the underlying async write inside `flush` so callers\n * can await full completion on consumer teardown.\n *\n * `debounceMs: 0` is the off switch — `schedule()` fires the write\n * synchronously rather than queueing through `setTimeout(fn, 0)`\n * (which is a macrotask the browser clamps to ~4 ms anyway).\n */\nexport function createDebouncedWriter(\n  write: () => Promise<void>,\n  debounceMs: number\n): {\n  schedule(): void\n  flush(): Promise<void>\n  cancel(): void\n} {\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let pending: Promise<void> | null = null\n  // Per-write generation counter (PASS2-S2). Each `runWrite` call\n  // captures its generation; the inline `.finally` only nulls the\n  // shared `pending` when its capture still matches the live counter.\n  // Without this guard, an older write's settle silently nullified\n  // `pending` even when a newer write had replaced it, and any\n  // `flush()` awaiting the OLD pending then resolved before the\n  // newer write settled — an early drain signal even though no\n  // bytes were lost (each write is a full idempotent snapshot).\n  let writeGeneration = 0\n\n  function runWrite(): void {\n    const gen = ++writeGeneration\n    pending = write().finally(() => {\n      if (writeGeneration === gen) pending = null\n    })\n  }\n\n  function schedule(): void {\n    if (timer !== null) clearTimeout(timer)\n    // `debounceMs: 0` is the off switch — fire the write synchronously\n    // rather than punting through `setTimeout(fn, 0)` (which queues a\n    // macrotask and the browser clamps to ~4 ms anyway).\n    if (debounceMs === 0) {\n      runWrite()\n      return\n    }\n    timer = setTimeout(() => {\n      timer = null\n      runWrite()\n    }, debounceMs)\n  }\n\n  async function flush(): Promise<void> {\n    if (timer !== null) {\n      clearTimeout(timer)\n      timer = null\n      runWrite()\n    }\n    // Drain-loop: if a new `schedule()` lands while we're awaiting an\n    // older `pending`, the latest pending might be a different promise\n    // by the time the older one settles. Re-read `pending` after the\n    // await and keep looping until it goes null (or stabilises on the\n    // same promise across an await tick — guards against an infinite\n    // loop if a sync arm immediately re-schedules during the await).\n    while (pending !== null) {\n      const awaited = pending\n      await awaited\n      if (pending === awaited) break\n    }\n  }\n\n  function cancel(): void {\n    if (timer !== null) {\n      clearTimeout(timer)\n      timer = null\n    }\n  }\n\n  return { schedule, flush, cancel }\n}\n\n/**\n * Build a sparse object containing only the values at `pathKeys` from\n * `form`. Each PathKey is the canonical JSON-array form\n * (`'[\"profile\",\"name\"]'`) emitted by `canonicalizePath`. Paths whose\n * value is `undefined` in the source (e.g. an optional schema field\n * the user never touched) are skipped — the caller's\n * `mergeSparseHydration` re-fills from schema defaults on read.\n *\n * The returned object structurally-shares with the source: a path that\n * names a container (e.g. `'contacts'` resolving to a whole array) is\n * copied by reference into the sparse output. Per-leaf opt-ins\n * (`'contacts.0.name'`) construct intermediate containers via\n * `setAtPath`.\n */\nexport function pluckPaths(form: unknown, pathKeys: Iterable<PathKey>): unknown {\n  let sparse: unknown = undefined\n  for (const pathKey of pathKeys) {\n    // PathKeys arrive from the opt-in registry (canonical) — cache hit\n    // every iteration. The null branch covers persistence payloads\n    // round-tripped from disk that were corrupted before reaching the\n    // restoration code.\n    const segments = segmentsForPathKey(pathKey)\n    if (segments === null) continue\n    const value = getAtPath(form, segments)\n    if (value === undefined) continue\n    sparse = setAtPath(sparse ?? {}, segments, value)\n  }\n  return sparse ?? {}\n}\n\n/**\n * Strip sensitive-named leaves from an already-plucked persisted form\n * unless their sensitivity was acknowledged, then return a new object\n * (the input is not mutated). A container opt-in\n * (`register('payment', { persist: true })`) copies its whole subtree\n * via `pluckPaths`, so nested `cvv` / `card_number` leaves would\n * otherwise reach storage in cleartext even though they were never\n * individually acknowledged.\n *\n * A sensitive path is kept only when an opted-in path that COVERS it\n * (the leaf itself, or an ancestor container) is itself sensitive.\n * Because the persist opt-in gate (`allowSensitivePersist`) only admits\n * a sensitive path when `acknowledgeSensitive: true` was set, an opted-in\n * sensitive path is, by construction, an acknowledged one — so this\n * keeps a directly-acknowledged leaf AND the subtree of an acknowledged\n * sensitive container, while shedding the unacknowledged secrets a\n * non-sensitive container opt-in dragged along.\n *\n * Mirrors multi-tab's `stripSensitivePathsDeep`, but keyed off the\n * persist opt-in set rather than stripping every sensitive path.\n */\nexport function stripUnacknowledgedSensitiveLeaves(\n  form: unknown,\n  optedInPaths: ReadonlySet<PathKey>,\n  isSensitivePath: (path: Path) => boolean\n): unknown {\n  // Opted-in paths that are themselves sensitive could only reach the\n  // set by being acknowledged; a sensitive value survives the scrub iff\n  // one of these covers it.\n  const acknowledgedSensitive: Path[] = []\n  for (const key of optedInPaths) {\n    const segs = segmentsForPathKey(key)\n    if (segs !== null && isSensitivePath(segs as Path)) acknowledgedSensitive.push(segs as Path)\n  }\n  const coveredByAcknowledged = (path: Path): boolean =>\n    acknowledgedSensitive.some((prefix) => isPathPrefix(prefix, path))\n\n  const walk = (path: Path, value: unknown): unknown => {\n    if (path.length > 0 && isSensitivePath(path) && !coveredByAcknowledged(path)) {\n      return undefined // strip this leaf / subtree\n    }\n    if (value === null || typeof value !== 'object') return value\n    if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item))\n    if (!isPlainRecord(value)) return value\n    // Scrub container carries `Object.prototype` plus `safeAssign`\n    // for the per-key write so a hostile persisted payload landing a\n    // literal `__proto__` key is written as an own data property, not\n    // through the inherited setter. The sensitive-leaf scrub feeds\n    // back into the persisted payload; shape stays consistent with\n    // what `mergeDeep` produces on the way back in.\n    const out: Record<string, unknown> = {}\n    for (const key of Object.keys(value as Record<string, unknown>)) {\n      const walked = walk([...path, key], (value as Record<string, unknown>)[key])\n      if (walked !== undefined) safeAssign(out, key, walked)\n    }\n    return out\n  }\n  return walk([], form)\n}\n\n/**\n * Restrict a `(PathKey → ValidationError[])` map to entries whose key\n * appears in `pathKeys`. Used by the persistence writer to drop errors\n * on non-opted-in paths from the persisted envelope — a persisted\n * error without a persisted value would dangle on rehydration (the\n * form would resurrect with no value but a complaint about it).\n */\nexport function filterErrorsByPaths(\n  errors: ReadonlyMap<string, ValidationError[]>,\n  pathKeys: ReadonlySet<PathKey>\n): Map<string, ValidationError[]> {\n  const out = new Map<string, ValidationError[]>()\n  for (const [key, value] of errors) {\n    if (pathKeys.has(key as PathKey)) out.set(key, value)\n  }\n  return out\n}\n","import { toRaw } from 'vue'\nimport type { FormStorage, PersistConfigOptions, ValidationError } from '../../types/types-api'\nimport type { GenericForm } from '../../types/types-core'\nimport type { FormStore } from '../create-form-store'\nimport { DEFAULT_PERSISTENCE_DEBOUNCE_MS, normalizeNumericOption } from '../defaults'\nimport { canonicalizePath, type Path, type PathKey } from '../paths'\nimport { deleteAtPath, getAtPath, isPlainRecord, setAtPath } from '../path-walker'\nimport {\n  buildPersistedPayload,\n  createDebouncedWriter,\n  filterErrorsByPaths,\n  pluckPaths,\n  readPersistedPayload,\n  stripUnacknowledgedSensitiveLeaves,\n} from './payload'\nimport {\n  cleanupOrphanKeys,\n  mergeSparseHydration,\n  resolveStorageKeyBase,\n  type PersistenceModule,\n} from '../persistence'\n\n/**\n * Wire persistence to a fresh FormStore:\n *\n *   1. Resolve the storage adapter (dynamic-imported — `'local'` never\n *      pulls IDB code; tree-shakes cleanly).\n *   2. Async-read any persisted payload and apply it via\n *      `applyFormReplacement`. First render shows schema defaults\n *      (the \"flash of default state\" — documented tradeoff for\n *      async backends).\n *   3. Subscribe a debounced writer to `onFormChange`; every mutation\n *      schedules a write.\n *   4. Subscribe a `removeItem` on submit-success (when\n *      `clearOnSubmitSuccess` is not explicitly false).\n *   5. Return a disposer that flushes any pending write, cancels\n *      the debounce, and removes subscribers. Called on consumer\n *      teardown.\n */\nexport function wirePersistence<F extends GenericForm>(\n  state: FormStore<F, GenericForm>,\n  config: PersistConfigOptions,\n  adapterPromise: Promise<FormStorage>,\n  fingerprintToken: string\n): PersistenceModule {\n  // `fingerprintToken` is the schema's structural fingerprint, hashed to a\n  // fixed-size token by the caller. Baking it into the storage key makes\n  // any structural schema change (added / removed / renamed field, type\n  // swap) look up a fresh key, so the old draft becomes an orphan cleaned\n  // up in this same mount by `cleanupOrphanKeys` below (no manual version\n  // protocol). The caller hashes the raw fingerprint (a 200+ char\n  // stringified shape that would otherwise bloat the key and leak the\n  // schema's structure into client storage) and owns the fallback for the\n  // adapters whose `fingerprint()` rejects, so persistence never crashes a\n  // consumer's mount.\n  const base = resolveStorageKeyBase(config, state.formKey)\n  const key = `${base}:${fingerprintToken}`\n  // Sanitise the persistence debounce — same rules as field validation:\n  // `NaN` would fire synchronously, `Infinity` would stall the event\n  // loop for ~24.8 days then wrap. Both fall back to the library default.\n  const debounceMs = normalizeNumericOption({\n    value: config.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS,\n    source: 'useForm.persist.debounceMs',\n    allowInfinity: false,\n    min: 0,\n    defaultValue: DEFAULT_PERSISTENCE_DEBOUNCE_MS,\n  })\n  const include = config.include ?? 'form'\n  const clearOnSubmitSuccess = config.clearOnSubmitSuccess ?? true\n\n  // Single shared adapter promise — both the hydration path and the\n  // write/clear paths await it. Injected by the caller, which kicks off\n  // the adapter's dynamic import in parallel with the dynamic import of\n  // this module, so the persisted-draft read isn't serialised behind\n  // the chunk load (the flash-of-defaults window stays the same as when\n  // persistence shipped eagerly). Sharing it also avoids a race where an\n  // early write (fast debounceMs) would see `adapter === null` and skip\n  // silently because the dynamic-import hadn't resolved yet.\n  // Routed through `isDisposed()` so each read is a function call,\n  // not a direct variable / property access. TS's control-flow\n  // analysis would narrow either `let disposed = false` or\n  // `isDisposed()` to literal `false` after the first early-\n  // return in a closure (every subsequent check in the same closure\n  // then trips `no-unnecessary-condition` as \"always falsy\"), because\n  // the flag's only `true` write lives in the `dispose()` finally\n  // callback flow analysis can't reach. A function call is opaque to\n  // the narrower — the type returns `boolean` at every site, which\n  // is the truth (`disposed` flips asynchronously across awaits).\n  let disposed = false\n  const isDisposed = (): boolean => disposed\n  // Tracks the in-flight final flush kicked off by `dispose()`. Returned\n  // by `awaitPendingWrites` so the registry can drain pending storage\n  // writes before evicting the FormStore — without this, the last\n  // debounced keystroke is silently dropped on unmount.\n  let inFlightFinalFlush: Promise<void> | null = null\n  // Snapshot of opt-in paths captured at SCHEDULE time. Vue's unmount\n  // lifecycle runs directive `beforeUnmount` (which clears per-element\n  // opt-ins) BEFORE the effect-scope dispose that triggers our drain.\n  // Without a snapshot, a write flushed during the drain sees zero\n  // opt-ins and wipes the storage entry. The snapshot lets the eventual\n  // write reflect the moment-in-time opt-ins as the user typed.\n  let pendingOptedInPaths: Set<PathKey> | null = null\n\n  const writer = createDebouncedWriter(async () => {\n    // No bail at entry: this closure runs from two paths — the\n    // debounce timer firing (which already gated on `disposed` via the\n    // schedule call) and the final flush from `dispose()`. The final\n    // flush's invocation order (flush BEFORE disposed flips) lets this\n    // write complete; the post-await guards below catch the rare case\n    // where adapter resolution is slow enough to overlap with the\n    // disposed flip.\n    //\n    // Use the schedule-time snapshot if present (handles the unmount\n    // race where beforeUnmount has cleared the live registry). Falls\n    // back to the live registry for any non-listener-triggered path.\n    const optedInPaths = pendingOptedInPaths ?? new Set<PathKey>(state.persistOptIns.optedInPaths())\n    pendingOptedInPaths = null\n    const adapter = await adapterPromise\n    if (isDisposed()) return\n    // Sparse-payload reshape: the persisted form contains only paths\n    // that were opted in via `register('foo', { persist: true })`. If\n    // every opt-in has been torn down, wipe the entry rather than\n    // write a hollow envelope (matches the per-element security model\n    // — no opt-ins → nothing to persist).\n    if (optedInPaths.size === 0) {\n      await adapter.removeItem(key)\n      return\n    }\n    // Unwrap the reactive form to a plain object before handing it to\n    // the adapter — IDB's `structuredClone` can't serialise Vue\n    // proxies (DATA_CLONE_ERR), and local/session stringify the\n    // proxy's own-enumerable keys anyway.\n    const rawForm = toRaw(state.form.value)\n    // Shed sensitive leaves a container opt-in dragged in that weren't\n    // individually acknowledged — they must never reach storage in\n    // cleartext (SEC-1). Directly- or container-acknowledged secrets are\n    // kept; the opt-in gate guarantees a sensitive opted-in path was\n    // acknowledged.\n    const filteredForm = stripUnacknowledgedSensitiveLeaves(\n      pluckPaths(rawForm, optedInPaths),\n      optedInPaths,\n      state.isSensitivePath as (path: Path) => boolean\n    ) as F\n    // Build the envelope with the attaform-internal envelope version baked\n    // in by `buildPersistedPayload`. Consumers no longer manage `v` —\n    // schema-content invalidation lives at the storage-key level via\n    // the fingerprint suffix.\n    const filteredSchemaErrors = filterErrorsByPaths(state.schemaErrors, optedInPaths)\n    const filteredUserErrors = filterErrorsByPaths(state.userErrors, optedInPaths)\n    // Blank paths are part of the restorable UI state, so\n    // they ride the same opt-in gate as form values: only persist\n    // the entries whose paths are also opted in for persistence.\n    const filteredTransientEmpty = new Set<string>()\n    for (const tk of state.blankPaths) {\n      if (optedInPaths.has(tk as PathKey)) filteredTransientEmpty.add(tk)\n    }\n    const payload = buildPersistedPayload<F>(\n      filteredForm,\n      include,\n      filteredSchemaErrors,\n      filteredUserErrors,\n      filteredTransientEmpty\n    )\n    await adapter.setItem(key, payload)\n  }, debounceMs)\n\n  const unsubscribeChange = state.onFormChange((_next, meta) => {\n    if (isDisposed() || inFlightFinalFlush !== null) return\n    // Cross-tab apply: a sibling tab already wrote this value to its\n    // own persistence layer; double-persisting from the receiving\n    // tab would be wasted I/O. The multi-tab sync module sets\n    // `persist: false` for this reason, which the next check already\n    // catches — but adding the explicit `crossTab` early return makes\n    // the intent legible at the listener boundary.\n    if (meta?.crossTab === true) return\n    // Per-element opt-in: only writes whose source declared `persist: true`\n    // reach the storage adapter. Programmatic `form.setValue`, history\n    // undo without opt-ins, devtools edits to non-opted paths, and\n    // `reset()` all bypass this gate by passing no meta (or `persist:\n    // false`).\n    if (meta?.persist !== true) return\n    // Snapshot opt-in paths NOW — Vue's unmount fires directive\n    // beforeUnmount (which calls persistOptIns.removeAllFor) BEFORE\n    // the scope-dispose that drives our drain. Capturing at schedule\n    // time means the eventual write sees the opt-ins as they were\n    // when the user typed, not as they were stripped.\n    pendingOptedInPaths = new Set<PathKey>(state.persistOptIns.optedInPaths())\n    writer.schedule()\n  })\n\n  const unsubscribeSuccess = clearOnSubmitSuccess\n    ? state.onSubmitSuccess(() => {\n        if (isDisposed()) return\n        // Flush any pending/in-flight write BEFORE removing — otherwise\n        // a timer that fires between submit and removeItem re-persists\n        // the now-stale state. `flush()` awaits the in-flight promise\n        // if one exists; if there's only a timer, it fires it\n        // immediately and awaits. After that, removeItem wins.\n        void (async () => {\n          await writer.flush()\n          if (isDisposed()) return\n          const adapter = await adapterPromise\n          if (isDisposed()) return\n          await adapter.removeItem(key)\n        })()\n      })\n    : () => undefined\n\n  // Tab-close / bfcache-eviction flush (PASS2-13). The debounced\n  // writer holds the last ≤debounceMs of edits before commit; without\n  // a synchronous trigger, those keystrokes vanish when the user\n  // closes the tab inside the debounce window. `pagehide` is the\n  // modern recommendation — fires on bfcache eviction (where\n  // `beforeunload` doesn't, since the page is preserved) AND on\n  // tab-close. Sync-storage adapters (localStorage, sessionStorage)\n  // commit inside the same task before the browser kills the JS\n  // context; IDB transactions are best-effort.\n  //\n  // SSR guard: `window` is undefined during server rendering. The\n  // listener attaches client-side only; SSR mounts complete their\n  // own dispose path before the response flushes.\n  const handlePageHide = (): void => {\n    if (isDisposed()) return\n    void writer.flush()\n  }\n  if (typeof window !== 'undefined') {\n    window.addEventListener('pagehide', handlePageHide)\n  }\n\n  // Async setup: resolve the adapter, then read back the persisted\n  // payload. If the caller unmounts before this finishes, `disposed`\n  // is true — the restore is skipped.\n  void (async () => {\n    const adapter = await adapterPromise\n    if (isDisposed()) return\n    // Orphan cleanup: delete any attaform-managed key under the same base\n    // whose fingerprint suffix doesn't match the current schema. Runs\n    // once per mount, fire-and-forget. Bounded cost: typically 0-1\n    // orphans per form.\n    void cleanupOrphanKeys(adapter, base, key)\n    try {\n      const raw = await adapter.getItem(key)\n      const payload = readPersistedPayload<F>(raw)\n      if (payload === null) {\n        // Truly-absent entries are a no-op. A non-null raw that didn't\n        // parse is a stale payload — wrong attaform envelope version, or\n        // malformed shape — wipe so the next mount reads cleanly.\n        if (raw !== null && raw !== undefined) {\n          await adapter.removeItem(key)\n        }\n        return\n      }\n      if (isDisposed()) return\n      // Sparse-aware replacement: the persisted form may contain only\n      // a subset of paths (the ones opted into persistence on the\n      // previous mount). Merge over the current form (which carries\n      // schema defaults at this point — wirePersistence runs before\n      // any user mutation could have happened) so non-persisted paths\n      // keep their schema defaults.\n      const merged = mergeSparseHydration(\n        toRaw(state.form.value) as F,\n        payload.data.form,\n        state.schema as unknown as Parameters<typeof mergeSparseHydration>[2]\n      )\n      // `hydration: true` tells listeners (notably the history module)\n      // that this replacement is the baseline, not a user mutation —\n      // history wipes its stacks and reseeds with the post-hydration\n      // snapshot so `undo()` can't reach the transient pre-hydration\n      // default the form briefly held between mount and hydrate.\n      state.applyFormReplacement(merged, { hydration: true })\n      // payload. Persistence is per-element opt-in, so the persisted\n      // payload only covers paths within the opt-in scope (the leaf\n      // paths populated in `payload.data.form`). Construction-time\n      // auto-marks for paths OUTSIDE that scope must survive —\n      // without this, a non-opted-in numeric field's slim default\n      // (`0`) would lose its blank mark on hydrate and surface as\n      // `'0'` in its <input> instead of empty.\n      //\n      // Within the opt-in scope, the persisted state IS the truth: a\n      // persisted path that's no longer blank (the user\n      // typed) clears the construction-time mark, and a persisted\n      // path that IS blank (still slim default) re-asserts.\n      const persistedLeafPaths = collectPersistedLeafPaths(payload.data.form)\n      for (const k of persistedLeafPaths) {\n        state.blankPaths.delete(k)\n        state.originalBlankPaths.delete(k)\n      }\n      for (const k of payload.data.blankPaths ?? []) {\n        // v=6 stores blankPaths in the canonical `PathKey` JSON shape,\n        // matching the in-memory representation. No conversion needed\n        // at the I/O boundary — see the v=6 docblock on\n        // `PERSISTED_ENVELOPE_VERSION`.\n        state.blankPaths.add(k)\n        state.originalBlankPaths.add(k)\n      }\n      if (include === 'form+errors') {\n        // Each store rebuilds independently from its persisted entries.\n        // Consumers who bumped `version` already had their payload\n        // rejected above.\n        if (payload.data.schemaErrors !== undefined) {\n          const flat = payload.data.schemaErrors.flatMap(([, errs]) => errs)\n          state.setAllSchemaErrors(flat)\n        }\n        if (payload.data.userErrors !== undefined) {\n          const flat = payload.data.userErrors.flatMap(([, errs]) => errs)\n          state.setAllUserErrors(flat)\n        }\n      }\n      // Post-hydration revalidation: the construction-time seed ran\n      // against the empty default, so its errors describe a stale\n      // value. Async-only verdicts additionally never fire at\n      // construction (the sync seed contract can't surface them;\n      // schemas with async refinements / transforms / pipes degrade\n      // to success there). A full async run at the root path wipes\n      // `schemaErrors` and re-stamps with the authoritative result\n      // for the rehydrated value — sync errors get refreshed, async\n      // verdicts fire, the form lands in the state the persisted\n      // value actually deserves.\n      state.scheduleFieldValidation([], true /* immediate */)\n    } catch {\n      // Adapter IO errors shouldn't surface; storage adapters are\n      // \"best-effort\" and already log their own warnings.\n    }\n  })()\n\n  // Note: a \"configured but no fields opted in\" check used to live here\n  // (microtask-deferred warn). Removed — having the persist capability\n  // configured without spending it on a register() call is a valid\n  // dormant state (scaffolding, A/B'd opt-ins, future-flagged fields).\n  // The library shouldn't lecture the consumer for not exercising every\n  // configured option. Eager throws only fire on actual contradictions\n  // (no-key + persist; register-with-persist + no useForm-persist).\n\n  /**\n   * Imperative one-shot write. Read-merge-write strategy: flush any\n   * pending debounced write first (so it can't overwrite our update),\n   * read the existing payload, set the path's current value, optionally\n   * merge in this path's errors, and write back. Preserves untouched\n   * paths in storage.\n   */\n  async function writePathImmediately(path: Path): Promise<void> {\n    if (isDisposed()) return\n    await writer.flush()\n    if (isDisposed()) return\n    const adapter = await adapterPromise\n    if (isDisposed()) return\n    const raw = await adapter.getItem(key)\n    const existing = readPersistedPayload<F>(raw)\n    const value = getAtPath(toRaw(state.form.value), path)\n    const nextForm = setAtPath(existing?.data.form ?? {}, path, value) as F\n    // Refresh this path's blank entry — and any descendants\n    // — while preserving entries for OTHER paths the previous mount\n    // persisted. Non-leaf writes (`writePathImmediately('user')`)\n    // overwrite the entire subtree, so any disk entries below the\n    // write path are dropped first; the live in-memory set then\n    // contributes whatever marks are still active under that subtree.\n    const { key: pathKey } = canonicalizePath(path)\n    const transientSet = new Set<string>(\n      (existing?.data.blankPaths ?? []).filter(\n        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)\n      )\n    )\n    for (const liveKey of state.blankPaths) {\n      if (liveKey === pathKey || isDescendantPathKey(liveKey, pathKey)) {\n        transientSet.add(liveKey)\n      }\n    }\n    if (include === 'form') {\n      await adapter.setItem(\n        key,\n        buildPersistedPayload<F>(nextForm, 'form', new Map(), new Map(), transientSet)\n      )\n      return\n    }\n    // include === 'form+errors': preserve the rest of the persisted\n    // error map and refresh the entry for this path's canonical key.\n    const schemaMap = new Map<string, ValidationError[]>(existing?.data.schemaErrors ?? [])\n    const userMap = new Map<string, ValidationError[]>(existing?.data.userErrors ?? [])\n    const currentSchema = state.schemaErrors.get(pathKey)\n    const currentUser = state.userErrors.get(pathKey)\n    if (currentSchema !== undefined && currentSchema.length > 0) {\n      schemaMap.set(pathKey, [...currentSchema])\n    } else {\n      schemaMap.delete(pathKey)\n    }\n    if (currentUser !== undefined && currentUser.length > 0) {\n      userMap.set(pathKey, [...currentUser])\n    } else {\n      userMap.delete(pathKey)\n    }\n    await adapter.setItem(\n      key,\n      buildPersistedPayload<F>(nextForm, 'form+errors', schemaMap, userMap, transientSet)\n    )\n  }\n\n  /**\n   * Wipe the persisted entry. Without `path`, removes the whole key.\n   * With `path`, deletes only that subpath (and any matching error\n   * entries) and writes back; the entry is removed entirely if the\n   * resulting form value is empty.\n   */\n  async function clearPersistedDraft(path?: Path): Promise<void> {\n    if (isDisposed()) return\n    await writer.flush()\n    if (isDisposed()) return\n    const adapter = await adapterPromise\n    if (isDisposed()) return\n    if (path === undefined) {\n      await adapter.removeItem(key)\n      return\n    }\n    const raw = await adapter.getItem(key)\n    const existing = readPersistedPayload<F>(raw)\n    if (existing === null) return\n    const nextForm = deleteAtPath(existing.data.form, path) as F\n    if (isEmptyContainer(nextForm)) {\n      await adapter.removeItem(key)\n      return\n    }\n    const { key: pathKey } = canonicalizePath(path)\n    // Drop the cleared path AND every descendant from the persisted\n    // blank list so a later mount doesn't restore an\n    // \"empty\" UI state for a path that no longer has any value\n    // behind it. Non-leaf clears (`clearPersistedDraft('user')`)\n    // wipe the whole user.* subtree.\n    const transientSet = new Set(\n      (existing.data.blankPaths ?? []).filter(\n        (k) => k !== pathKey && !isDescendantPathKey(k, pathKey)\n      )\n    )\n    if (include === 'form') {\n      await adapter.setItem(\n        key,\n        buildPersistedPayload<F>(nextForm, 'form', new Map(), new Map(), transientSet)\n      )\n      return\n    }\n    const schemaErrors = (existing.data.schemaErrors ?? []).filter(([k]) => k !== pathKey)\n    const userErrors = (existing.data.userErrors ?? []).filter(([k]) => k !== pathKey)\n    const schemaMap = new Map<string, ValidationError[]>(schemaErrors.map(([k, v]) => [k, [...v]]))\n    const userMap = new Map<string, ValidationError[]>(userErrors.map(([k, v]) => [k, [...v]]))\n    await adapter.setItem(\n      key,\n      buildPersistedPayload<F>(nextForm, 'form+errors', schemaMap, userMap, transientSet)\n    )\n  }\n\n  function awaitPendingWrites(): Promise<void> {\n    // If dispose() already kicked off the final flush, return THAT\n    // promise so the registry awaits the same drain instead of\n    // scheduling a parallel one.\n    if (inFlightFinalFlush !== null) return inFlightFinalFlush\n    if (isDisposed()) return Promise.resolve()\n    return writer.flush().catch(() => undefined)\n  }\n\n  function dispose(): void {\n    if (isDisposed() || inFlightFinalFlush !== null) return\n    unsubscribeChange()\n    unsubscribeSuccess()\n    if (typeof window !== 'undefined') {\n      window.removeEventListener('pagehide', handlePageHide)\n    }\n    // CRITICAL: flush BEFORE flipping `disposed`. The previous order\n    // (set disposed=true, then call writer.flush()) caused the writer\n    // closure to bail immediately, silently dropping the last\n    // keystroke whenever a component unmounted within the debounce\n    // window. Now we kick off the flush, then flip `disposed` only\n    // after the in-flight write finishes.\n    inFlightFinalFlush = writer\n      .flush()\n      .catch(() => undefined)\n      .finally(() => {\n        disposed = true\n        inFlightFinalFlush = null\n      })\n    // Fire-and-forget — `awaitPendingWrites` exposes the promise for\n    // callers that need to drain (the registry on consumer-eviction;\n    // SSR shutdown).\n    void inFlightFinalFlush\n  }\n\n  return {\n    writePathImmediately,\n    clearPersistedDraft,\n    awaitPendingWrites,\n    dispose,\n  }\n}\n\n/**\n * Treat `null`, `undefined`, `[]`, and `{}` as \"nothing left to keep.\"\n * Used by `clearPersistedDraft(path)` to decide whether to wipe the\n * entire entry instead of writing a hollow envelope back.\n */\nfunction isEmptyContainer(value: unknown): boolean {\n  if (value === undefined || value === null) return true\n  if (Array.isArray(value)) return value.length === 0\n  if (isPlainRecord(value)) return Object.keys(value).length === 0\n  return false\n}\n\n/**\n * Walk a sparse persisted form and collect the canonical PathKey of\n * every leaf. \"Leaf\" = anything that isn't a plain object or array\n * (so primitives, null, deserialized Dates / strings all count). The\n * persisted form's leaves correspond 1:1 with the per-element opt-in\n * scope at the time persistence wrote, which the hydration path uses\n * to bound which blank entries to overwrite.\n */\nfunction collectPersistedLeafPaths(form: unknown): PathKey[] {\n  const out: PathKey[] = []\n  walk(form, [])\n  return out\n\n  function walk(node: unknown, prefix: Path): void {\n    if (Array.isArray(node)) {\n      for (let i = 0; i < node.length; i++) {\n        walk(node[i], [...prefix, i])\n      }\n      return\n    }\n    if (isPlainRecord(node)) {\n      for (const key of Object.keys(node)) {\n        walk((node as Record<string, unknown>)[key], [...prefix, key])\n      }\n      return\n    }\n    if (prefix.length === 0) return // root scalar — no path to canonicalize\n    out.push(canonicalizePath(prefix).key)\n  }\n}\n\n/**\n * `true` when `candidate` names a strict descendant of `ancestor` in\n * canonical PathKey form (`JSON.stringify(segments)`).\n *\n * `'[\"user\"]'` is the ancestor; `'[\"user\",\"age\"]'` and\n * `'[\"user\",\"address\",\"line1\"]'` are descendants. A pure prefix match\n * isn't enough — `'[\"userId\"]'` shares the `'[\"user'` prefix with\n * `'[\"user\"]'` but is not a descendant. The check anchors on the\n * comma that separates the parent's last segment from its first\n * child segment.\n */\nfunction isDescendantPathKey(candidate: string, ancestor: string): boolean {\n  if (candidate.length <= ancestor.length) return false\n  if (!ancestor.endsWith(']')) return false\n  const childPrefix = `${ancestor.slice(0, -1)},`\n  return candidate.startsWith(childPrefix)\n}\n"],"names":["__DEV__","segmentsForPathKey","getAtPath","setAtPath","isPathPrefix","isPlainRecord","safeAssign","resolveStorageKeyBase","normalizeNumericOption","DEFAULT_PERSISTENCE_DEBOUNCE_MS","toRaw","cleanupOrphanKeys","mergeSparseHydration","canonicalizePath","deleteAtPath"],"mappings":"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"}