@buoy-gg/shared-ui 7.0.33 → 7.0.34

package/lib/commonjs/utils/snapshotProviderKit.js

@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PREVIEW_ITEM_RENDER_BYTE_LIMIT = void 0;
+exports.classifyPreviewItem = classifyPreviewItem;
+exports.createRestoreScope = createRestoreScope;
+exports.emptyRestoreResult = emptyRestoreResult;
+exports.failedRestore = failedRestore;
+exports.skippedRestore = skippedRestore;
+exports.unionKeys = unionKeys;
+exports.wontApply = wontApply;
+var _objectDiff = require("../dataViewer/objectDiff.js");
+/**
+ * snapshotProviderKit — the parts of a Time Machine `StateSnapshotProvider`
+ * that are the same for every source.
+ *
+ * storage, redux, zustand, jotai and react-query each register a provider
+ * (see stateSnapshotRegistry.ts). What differs is how they read and write
+ * their source. What was copied five times is:
+ *
+ *  - the restore SCOPE gate: `excludeKeys` (touch all but these) and
+ *    `includeKeys` (touch only these), the "N item(s) excluded by you"
+ *    warning, and the empty `StateSnapshotRestoreResult`;
+ *  - the preview VERDICT ladder: removed → added → unchanged → too-large →
+ *    changed, with the 256 KB per-item render cap;
+ *  - the "won't apply" override: a difference restore cannot apply must say
+ *    so instead of rendering as a green change.
+ *
+ * The parts that stay per-tool are the ones that matter: redux verifies the
+ * jump by reference identity, zustand grafts action functions back, jotai
+ * leaves derived atoms to recompute, storage gates MMKV buffers and
+ * biometric keys, react-query diffs a comparable projection.
+ */
+
+/** Beyond this a preview item is "too-large": restore still applies it, the diff isn't drawn. */
+const PREVIEW_ITEM_RENDER_BYTE_LIMIT = exports.PREVIEW_ITEM_RENDER_BYTE_LIMIT = 256 * 1024;
+/**
+ * Both option lists use preview item keys, and both mean "leave everything
+ * else untouched in BOTH directions". `includeKeys` wins when present;
+ * `excludeKeys` still applies on top.
+ */
+function createRestoreScope(options) {
+  const excludedSet = new Set(options?.excludeKeys ?? []);
+  const includedSet = options?.includeKeys ? new Set(options.includeKeys) : null;
+  let excludedHits = 0;
+  const touch = key => !excludedSet.has(key) && (!includedSet || includedSet.has(key));
+  return {
+    touch,
+    allows(key) {
+      if (touch(key)) return true;
+      excludedHits += 1;
+      return false;
+    },
+    countExcluded(n) {
+      excludedHits += n;
+    },
+    get excludedHits() {
+      return excludedHits;
+    },
+    excludedWarning(noun) {
+      return excludedHits > 0 ? `${excludedHits} ${noun} excluded by you` : null;
+    }
+  };
+}
+
+/** A fresh, successful, empty result to accumulate into. */
+function emptyRestoreResult() {
+  return {
+    ok: true,
+    applied: 0,
+    skipped: [],
+    warnings: []
+  };
+}
+
+/** A failed result with one warning (an empty or unusable snapshot). */
+function failedRestore(warning) {
+  return {
+    ok: false,
+    applied: 0,
+    skipped: [],
+    warnings: [warning]
+  };
+}
+
+/** A failed result with one skipped item and its reason. */
+function skippedRestore(id, reason) {
+  return {
+    ok: false,
+    applied: 0,
+    skipped: [{
+      id,
+      reason
+    }],
+    warnings: []
+  };
+}
+/**
+ * The verdict ladder: removed → added → unchanged → too-large → changed.
+ * Callers layer source-specific verdicts (`wont-apply`, `recomputes`) on top
+ * with `wontApply()`.
+ */
+function classifyPreviewItem(input, options = {}) {
+  const {
+    key,
+    label,
+    oldValue,
+    newValue,
+    inOld,
+    inNew
+  } = input;
+  if (!inNew) return {
+    key,
+    label,
+    verdict: "removed",
+    oldValue
+  };
+  if (!inOld) return {
+    key,
+    label,
+    verdict: "added",
+    newValue
+  };
+  const equal = options.equal ?? _objectDiff.boundedDeepEqual;
+  if (equal(oldValue, newValue)) return {
+    key,
+    label,
+    verdict: "unchanged"
+  };
+  const tooLarge = options.tooLarge ?? (value => (0, _objectDiff.jsonLikelyLargerThan)(value, PREVIEW_ITEM_RENDER_BYTE_LIMIT));
+  if (tooLarge(oldValue) || tooLarge(newValue)) {
+    return {
+      key,
+      label,
+      verdict: "too-large",
+      reason: options.tooLargeReason ?? "value too large to render a diff — restore still applies it"
+    };
+  }
+  return {
+    key,
+    label,
+    verdict: "changed",
+    oldValue,
+    newValue
+  };
+}
+
+/**
+ * Mark an item as something restore cannot apply. An unchanged item is left
+ * alone — there is nothing to apply, so nothing is being refused.
+ */
+function wontApply(item, reason) {
+  if (item.verdict === "unchanged") return item;
+  return {
+    ...item,
+    verdict: "wont-apply",
+    reason
+  };
+}
+
+/** Every key present in either record, once. */
+function unionKeys(a, b) {
+  const keysOf = r => r === undefined ? [] : r instanceof Map ? Array.from(r.keys()) : Object.keys(r);
+  return new Set([...keysOf(a), ...keysOf(b)]);
+}

package/lib/commonjs/utils/stateTools.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.entityColor = entityColor;
+exports.formatValuePreview = formatValuePreview;
+exports.shallowDiffSummary = shallowDiffSummary;
+/**
+ * stateTools — helpers the state tools (redux / zustand / jotai) each carried
+ * a private copy of. Pure functions; no React, no RN.
+ */
+
+// ============================================
+// Entity color
+// ============================================
+
+/**
+ * Consistent color for a named entity (a zustand store, a jotai atom, a redux
+ * slice). Exact match on `known` wins, then a substring match, then a stable
+ * HSL hash of the name rendered as `#rrggbb` so the "color + alpha hex"
+ * pattern works everywhere.
+ */
+function entityColor(name, known = {}) {
+  const lower = name.toLowerCase();
+  if (known[lower]) return known[lower];
+  for (const [key, color] of Object.entries(known)) {
+    if (lower.includes(key)) return color;
+  }
+  const hash = name.split("").reduce((acc, char) => acc + char.charCodeAt(0), 0);
+  const hue = hash * 137 % 360;
+  const s = 0.7;
+  const l = 0.6;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (hue < 60) {
+    r = c;
+    g = x;
+  } else if (hue < 120) {
+    r = x;
+    g = c;
+  } else if (hue < 180) {
+    g = c;
+    b = x;
+  } else if (hue < 240) {
+    g = x;
+    b = c;
+  } else if (hue < 300) {
+    r = x;
+    b = c;
+  } else {
+    r = c;
+    b = x;
+  }
+  const toHex = v => Math.round((v + m) * 255).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+// ============================================
+// Value preview
+// ============================================
+
+/**
+ * One-line preview of an arbitrary value for a list row: strings quoted and
+ * truncated, arrays and objects stringified when short, otherwise collapsed
+ * to `[N items]` / `{ N keys }`. Never throws.
+ */
+function formatValuePreview(value, options = {}) {
+  const maxLength = options.maxLength ?? 40;
+  if (value === undefined) return options.undefinedLabel ?? "undefined";
+  if (value === null) return "null";
+  try {
+    if (typeof value === "function") return options.functionLabel ?? "(fn)";
+    if (typeof value === "string") {
+      return value.length > maxLength ? `"${value.slice(0, maxLength - 3)}..."` : `"${value}"`;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return String(value);
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "[]";
+      const preview = JSON.stringify(value);
+      return preview.length > maxLength ? `[${value.length} items]` : preview;
+    }
+    if (typeof value === "object") {
+      const keys = Object.keys(value);
+      if (keys.length === 0) return "{}";
+      const preview = JSON.stringify(value);
+      if (preview.length <= maxLength) return preview;
+      return `{ ${keys.length} keys }`;
+    }
+    return String(value).slice(0, maxLength);
+  } catch {
+    return "[complex]";
+  }
+}
+
+// ============================================
+// Shallow diff summary
+// ============================================
+
+/**
+ * Top-level, reference-equality diff between two states. Enough for a list
+ * row ("+1 ~2 keys"); the detail view runs the real tree diff.
+ *
+ * A state object that was REPLACED without any top-level value moving —
+ * exactly what zustand's persist middleware does when it rehydrates — is
+ * reported as `"nested change"` with no keys, never as one changed key with
+ * none named.
+ */
+function shallowDiffSummary(prev, next) {
+  if (prev === next) {
+    return {
+      summary: "no change",
+      changedKeys: [],
+      changedCount: 0
+    };
+  }
+  if (typeof prev !== "object" || typeof next !== "object" || prev === null || next === null) {
+    return {
+      summary: "changed",
+      changedKeys: [],
+      changedCount: 0
+    };
+  }
+  const prevRecord = prev;
+  const nextRecord = next;
+  const prevKeys = Object.keys(prevRecord);
+  const nextKeys = Object.keys(nextRecord);
+  const added = nextKeys.filter(k => !prevKeys.includes(k));
+  const removed = prevKeys.filter(k => !nextKeys.includes(k));
+  const changed = [];
+  for (const key of prevKeys) {
+    if (nextKeys.includes(key) && prevRecord[key] !== nextRecord[key]) {
+      changed.push(key);
+    }
+  }
+  const changedKeys = [...added, ...removed, ...changed];
+  const parts = [];
+  if (added.length > 0) parts.push(`+${added.length}`);
+  if (removed.length > 0) parts.push(`-${removed.length}`);
+  if (changed.length > 0) parts.push(`~${changed.length}`);
+  if (parts.length === 0) {
+    return {
+      summary: "nested change",
+      changedKeys: [],
+      changedCount: 0
+    };
+  }
+  const total = changedKeys.length;
+  return {
+    summary: `${parts.join(" ")} ${total === 1 ? "key" : "keys"}`,
+    changedKeys,
+    changedCount: total
+  };
+}

package/lib/module/JsModal.js

@@ -602,7 +602,6 @@ const JsModalComponent = ({
   // ============================================================================
   // REFS for values we need to track
   // ============================================================================
-  const isExternallyControlled = !!externalAnimatedHeight;
   const effectiveMaxHeight = maxHeight || SCREEN.height - insets.top;
 
   // Mode toggle handler
@@ -724,29 +723,57 @@ const JsModalComponent = ({
   // ============================================================================
   // EFFECT: Visibility Animations - All using native driver!
   // ============================================================================
+  const snapVisibility = shown => {
+    if (shown) {
+      if (mode === "bottomSheet") {
+        bottomSheetTranslateY.setValue(0);
+      } else {
+        floatingScale.setValue(1);
+        floatingPosition.setValue({
+          x: currentDimensionsRef.current.left,
+          y: currentDimensionsRef.current.top
+        });
+      }
+      visibilityProgress.setValue(1);
+    } else {
+      if (mode === "bottomSheet") {
+        bottomSheetTranslateY.setValue(SCREEN.height);
+      }
+      visibilityProgress.setValue(0);
+    }
+  };
+
+  /**
+   * Snap DURING RENDER when `visible` flips, not only in the effect below.
+   *
+   * These values drive the sheet's opacity/translate through the native
+   * driver. The React commit for a `visible` change carries whatever the
+   * JS-side values are at render time — the OLD, hidden ones when the snap
+   * only happens in the effect — and on Fabric that commit's mount can land
+   * on the main thread AFTER the effect's native `setValue`, overwriting it.
+   * The Animated node then says "shown" while the UIView sits at opacity 0,
+   * until some unrelated re-render commits the JS-side values again. That
+   * is how "restore tool A: nothing; restore tool B: A appears; hide B: now
+   * B appears" happened — every restore was one commit behind.
+   *
+   * Setting the values before the render's props are computed makes the
+   * commit and the native node agree, whichever lands last. `setValue` is
+   * idempotent, so a re-run render is harmless.
+   */
+  const snappedVisibleRef = useRef(null);
+  if (INSTANT_MODAL_ENTRANCE && snappedVisibleRef.current !== visible) {
+    snappedVisibleRef.current = visible;
+    snapVisibility(visible);
+  }
   useEffect(() => {
     // Visibility effect
     let openAnimation = null;
     let closeAnimation = null;
     if (INSTANT_MODAL_ENTRANCE) {
-      // Snap to the final state — no animation in either direction.
-      if (visible) {
-        if (mode === "bottomSheet") {
-          bottomSheetTranslateY.setValue(0);
-        } else {
-          floatingScale.setValue(1);
-          floatingPosition.setValue({
-            x: currentDimensionsRef.current.left,
-            y: currentDimensionsRef.current.top
-          });
-        }
-        visibilityProgress.setValue(1);
-      } else {
-        if (mode === "bottomSheet") {
-          bottomSheetTranslateY.setValue(SCREEN.height);
-        }
-        visibilityProgress.setValue(0);
-      }
+      // Snap to the final state — no animation in either direction. The
+      // render-phase snap above already did this for a `visible` flip; this
+      // re-applies it for a `mode` change while shown.
+      snapVisibility(visible);
       return;
     }
     if (visible) {
@@ -911,8 +938,15 @@ const JsModalComponent = ({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [benchMotion, visible]);
   const bottomSheetPanResponder = useMemo(() => PanResponder.create({
-    onStartShouldSetPanResponder: () => !isExternallyControlled && mode === "bottomSheet",
-    onMoveShouldSetPanResponder: (evt, gestureState) => !isExternallyControlled && mode === "bottomSheet" && Math.abs(gestureState.dy) > 3,
+    // An external `animatedHeight` used to disable this responder
+    // outright ("externally controlled"), which left Ask Buoy's sheet —
+    // the one host that passes one, for its peek animation — with a
+    // header that could not be dragged in bottom-sheet mode. The move
+    // and release handlers below already write every height into the
+    // external value, so the host and the finger share one number; the
+    // grab just has to stop whatever the host is animating first.
+    onStartShouldSetPanResponder: () => mode === "bottomSheet",
+    onMoveShouldSetPanResponder: (evt, gestureState) => mode === "bottomSheet" && Math.abs(gestureState.dy) > 3,
     onPanResponderTerminationRequest: () => false,
     onPanResponderGrant: evt => {
       setIsResizing(true);
@@ -924,6 +958,7 @@ const JsModalComponent = ({
       animatedBottomPosition.stopAnimation(val => {
         currentHeightRef.current = val;
       });
+      externalAnimatedHeight?.stopAnimation();
       bottomSheetTranslateY.stopAnimation();
     },
     onPanResponderMove: evt => {
@@ -970,7 +1005,7 @@ const JsModalComponent = ({
       setIsResizing(false);
       // snap back to the last stable height if you want; otherwise no-op
     }
-  }), [mode, isExternallyControlled, minHeight, effectiveMaxHeight, animatedBottomPosition, externalAnimatedHeight, bottomSheetTranslateY, visibilityProgress, onClose]);
+  }), [mode, minHeight, effectiveMaxHeight, animatedBottomPosition, externalAnimatedHeight, bottomSheetTranslateY, visibilityProgress, onClose]);
 
   // ============================================================================
   // CREATE RESIZE HANDLER: For 4-corner resize in floating mode (fixed geometry)

package/lib/module/hooks/index.js

@@ -1,7 +1,9 @@
 "use strict";
 
 export { useFilterManager } from "./useFilterManager.js";
-export { usePersistedState } from "./usePersistedState.js";
+export { usePersistedState, resetPersistedStateCache } from "./usePersistedState.js";
+export { useChangeLog, useSubscribedValue } from "./useChangeLog.js";
+export { useEventStoreEvents } from "./useEventStoreEvents.js";
 export { useSafeAreaInsets } from "./useSafeAreaInsets.js";
 export { getSafeAreaInsets } from "./useSafeAreaInsets.js";
 export { useDeviceInfo, getDeviceInfo, logDeviceInfo } from "./useDeviceInfo.js";

package/lib/module/hooks/safe-area-impl.js

@@ -3,7 +3,7 @@
 /**
  * Auto-generated safe area implementation
  * Detected: none
- * Generated at: 2026-09-02T23:25:39.783Z
+ * Generated at: 2026-09-04T01:21:28.486Z
  *
  * DO NOT EDIT - This file is generated by scripts/detect-safe-area.js
  *

package/lib/module/hooks/useChangeLog.js

@@ -0,0 +1,50 @@
+"use strict";
+
+/**
+ * React bindings for `ChangeLog` — what useReduxActions, useZustandStateChanges
+ * and useJotaiAtomChanges each re-derived: seed state from the log, subscribe
+ * for the lifetime of the component, hold a filter, memoize the filtered
+ * list, and expose clear / pause / lookup.
+ *
+ * Tool-specific stats and registries (stores, atoms) compose on top — see
+ * `useSubscribedValue` for the registry half.
+ */
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+export function useChangeLog(log, options = {}) {
+  const [items, setItems] = useState(() => log.getAll());
+  const [filter, setFilter] = useState(() => options.initialFilter ?? {});
+  const [isEnabled, setIsEnabled] = useState(() => log.getEnabled());
+  useEffect(() => log.subscribe(setItems), [log]);
+  const filterItems = options.filterItems;
+  const filteredItems = useMemo(() => filterItems ? filterItems(items, filter) : items, [items, filter, filterItems]);
+  const clear = useCallback(() => {
+    log.clear();
+  }, [log]);
+  const toggleCapture = useCallback(() => {
+    const next = !isEnabled;
+    log.setEnabled(next);
+    setIsEnabled(next);
+  }, [log, isEnabled]);
+  const getById = useCallback(id => log.getById(id), [log]);
+  return {
+    items,
+    filteredItems,
+    filter,
+    setFilter,
+    isEnabled,
+    toggleCapture,
+    clear,
+    getById
+  };
+}
+
+/**
+ * Hold a value that a store pushes through a `(value) => void` listener —
+ * a registry of stores, atoms, sources. Seeded synchronously from `read`.
+ */
+export function useSubscribedValue(read, subscribe) {
+  const [value, setValue] = useState(read);
+  useEffect(() => subscribe(setValue), [subscribe]);
+  return value;
+}

package/lib/module/hooks/useEventStoreEvents.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * React bindings for a `BaseEventStore` — what useRouteEvents and
+ * useStorageEvents each hand-rolled: subscribe while enabled (which
+ * auto-starts the store's capture), coalesce bursts onto one animation
+ * frame so a storm of writes is one commit instead of one per emission,
+ * select/limit the list, and report whether capture is live.
+ */
+
+import { useCallback, useEffect, useState } from "react";
+export function useEventStoreEvents(store, options = {}) {
+  const {
+    enabled = true,
+    maxEvents = 500,
+    select
+  } = options;
+  const [events, setEvents] = useState([]);
+  // Tracked locally so it updates reactively with the subscription.
+  const [isActive, setIsActive] = useState(enabled);
+  useEffect(() => {
+    if (!enabled) {
+      setIsActive(false);
+      return;
+    }
+
+    // Frame-coalesced: bursts land as ONE commit per frame instead of one
+    // per emission — the dominant live-churn cost measured on the network
+    // tool (tool-bench 2026-07-06).
+    let rafId = null;
+    let pending = null;
+    const unsubscribe = store.subscribeToEvents(all => {
+      pending = all;
+      if (rafId != null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        if (!pending) return;
+        let next = pending;
+        pending = null;
+        if (select) next = select(next);
+        if (next.length > maxEvents) next = next.slice(0, maxEvents);
+        setEvents(next);
+      });
+    });
+    setIsActive(true);
+    return () => {
+      unsubscribe();
+      if (rafId != null) cancelAnimationFrame(rafId);
+      // Not setting isActive=false here: a dependency change re-subscribes
+      // immediately, and that is not "stopped".
+    };
+  }, [store, enabled, maxEvents, select]);
+  const clearEvents = useCallback(() => {
+    store.clearEvents();
+  }, [store]);
+  return {
+    events,
+    clearEvents,
+    isActive
+  };
+}

package/lib/module/hooks/usePersistedState.js

@@ -10,25 +10,43 @@ import { persistentStorage } from "../utils/persistentStorage.js";
  */
 const hydratedCache = new Map();
 
+/** The two calls a backend needs. `persistentStorage` and AsyncStorage both fit. */
+
+function defaultParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * `useState` persisted through `persistentStorage` (FileSystem → AsyncStorage
  * → memory). Replaces the load-then-`hasLoaded`-guard `useEffect` pattern
  * every tool used to hand-roll.
  *
- * Values are JSON-serialized; the default is returned until hydration
- * completes (subsequent mounts of the same key hydrate synchronously from an
- * in-memory cache). The third tuple element reports hydration so callers can
- * defer writes that must not clobber a not-yet-loaded value.
+ * Values are JSON-serialized by default; the default is returned until
+ * hydration completes (subsequent mounts of the same key hydrate synchronously
+ * from an in-memory cache). The third tuple element reports hydration so
+ * callers can defer writes that must not clobber a not-yet-loaded value.
  *
  * ```tsx
  * const [tab, setTab, tabHydrated] = usePersistedState("@react_buoy_custom_flags_tab", "flags");
+ *
+ * // A Set, stored as an array:
+ * const [pins, setPins] = usePersistedState(key, new Set<string>(), {
+ *   parse: (raw) => new Set(JSON.parse(raw) as string[]),
+ *   serialize: (set) => JSON.stringify([...set]),
+ * });
  * ```
  */
-export function usePersistedState(key, defaultValue) {
+export function usePersistedState(key, defaultValue, options = {}) {
   const [value, setValue] = useState(() => hydratedCache.has(key) ? hydratedCache.get(key) : defaultValue);
   const [hydrated, setHydrated] = useState(() => hydratedCache.has(key));
   const keyRef = useRef(key);
   keyRef.current = key;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
   useEffect(() => {
     if (hydratedCache.has(key)) {
       setValue(hydratedCache.get(key));
@@ -36,17 +54,22 @@ export function usePersistedState(key, defaultValue) {
       return;
     }
     let cancelled = false;
-    persistentStorage.getItem(key).then(raw => {
+    const storage = optionsRef.current.storage ?? persistentStorage;
+    const parse = optionsRef.current.parse ?? defaultParse;
+    storage.getItem(key).then(raw => {
       if (cancelled) return;
       if (raw != null) {
+        let parsed;
         try {
-          const parsed = JSON.parse(raw);
-          hydratedCache.set(key, parsed);
-          setValue(parsed);
+          parsed = parse(raw);
         } catch {
           // Corrupt payload — fall back to the default and let the next
           // write repair it.
         }
+        if (parsed !== undefined) {
+          hydratedCache.set(key, parsed);
+          setValue(parsed);
+        }
       }
       setHydrated(true);
     }).catch(() => {
@@ -60,9 +83,20 @@ export function usePersistedState(key, defaultValue) {
     setValue(prev => {
       const resolved = typeof next === "function" ? next(prev) : next;
       hydratedCache.set(keyRef.current, resolved);
-      persistentStorage.setItem(keyRef.current, JSON.stringify(resolved)).catch(() => {});
+      const storage = optionsRef.current.storage ?? persistentStorage;
+      const serialize = optionsRef.current.serialize ?? JSON.stringify;
+      try {
+        storage.setItem(keyRef.current, serialize(resolved)).catch(() => {});
+      } catch {
+        // Unserializable value — keep it in memory, skip the write.
+      }
       return resolved;
     });
   }, []);
   return [value, set, hydrated];
+}
+
+/** Test seam: forget every hydrated value. */
+export function resetPersistedStateCache() {
+  hydratedCache.clear();
 }