@buoy-gg/shared-ui 7.0.32 → 7.0.34

package/lib/commonjs/ui/otto/ottoSheet.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WATER_ROWS = exports.WATER_ROW0 = exports.WATER_FRAMES = exports.WATER_CELLS = exports.TRANSPARENT = exports.MAX_PERIOD = exports.CELLS = void 0;
+exports.cycleIndexes = cycleIndexes;
+exports.flatColors = flatColors;
+exports.gridKey = gridKey;
+exports.ottoCycle = ottoCycle;
+exports.ottoSheets = ottoSheets;
+exports.rectsOf = rectsOf;
+var _ottoEngine = require("./ottoEngine.js");
+/**
+ * Otto's precomputed animation.
+ *
+ * Every state is a short loop (48 ticks at most). This module renders that
+ * loop once, splits it into a BODY layer and a 7-frame WATER layer (they
+ * composite back pixel-for-pixel: compose() only paints water into empty
+ * cells and blanks a submerged body below the waterline), dedupes the
+ * frames, and turns each distinct frame into merged rectangles. The shipping
+ * <Otto/> mounts those rectangles ONCE as a strip of static Views and slides
+ * a window over the strip on the UI thread.
+ *
+ * Why: the buoy-optimize rounds in OTTO_PERF_PLAN.md showed that any renderer
+ * re-creating Views per tick pegs the JS thread (5 FPS at 34 sprites, dropped
+ * UI frames even at 1 sprite), while "mount once, move a window natively"
+ * costs nothing per tick and keeps moving while JS is blocked.
+ *
+ * Everything here is pure `react-native`-free TypeScript, cached per state.
+ */
+
+const CELLS = exports.CELLS = _ottoEngine.OTTO_GRID * _ottoEngine.OTTO_GRID;
+const WATER_ROW0 = exports.WATER_ROW0 = 13;
+const WATER_ROWS = exports.WATER_ROWS = _ottoEngine.OTTO_GRID - WATER_ROW0;
+const WATER_CELLS = exports.WATER_CELLS = WATER_ROWS * _ottoEngine.OTTO_GRID;
+/** The wave is a function of floor(t/2) mod 7. */
+const WATER_FRAMES = exports.WATER_FRAMES = 7;
+const TRANSPARENT = exports.TRANSPARENT = "transparent";
+/** Longest state cycle in ticks (idle and sleep are 48). */
+const MAX_PERIOD = exports.MAX_PERIOD = 48;
+function gridKey(grid) {
+  return grid.map(r => r.join("")).join("|");
+}
+
+/** Flat 256 colours, row-major, `transparent` for empty cells. */
+function flatColors(grid) {
+  const out = new Array(CELLS);
+  for (let y = 0; y < _ottoEngine.OTTO_GRID; y++) {
+    const row = grid[y];
+    for (let x = 0; x < _ottoEngine.OTTO_GRID; x++) out[y * _ottoEngine.OTTO_GRID + x] = _ottoEngine.OTTO_PALETTE[row[x]] ?? TRANSPARENT;
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------- cycle ---
+
+const cycleCache = new Map();
+function ottoCycle(state, keyline) {
+  const cacheKey = `${state}|${keyline ? 1 : 0}`;
+  const hit = cycleCache.get(cacheKey);
+  if (hit) return hit;
+  const keys = [];
+  const grids = [];
+  for (let t = 0; t < MAX_PERIOD * 2; t++) {
+    const g = (0, _ottoEngine.renderOttoFrame)(state, t, {
+      water: false,
+      keyline
+    });
+    grids.push(g);
+    keys.push(gridKey(g));
+  }
+  let period = MAX_PERIOD;
+  for (let P = 1; P <= MAX_PERIOD; P++) {
+    let ok = true;
+    for (let t = 0; t < MAX_PERIOD; t++) {
+      if (keys[t] !== keys[t + P]) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) {
+      period = P;
+      break;
+    }
+  }
+  const body = grids.slice(0, period).map(flatColors);
+  const water = [];
+  for (let w = 0; w < WATER_FRAMES; w++) {
+    const flat = [];
+    for (const row of (0, _ottoEngine.ottoWaterRows)(w * 2)) for (const k of row) flat.push(_ottoEngine.OTTO_PALETTE[k] ?? TRANSPARENT);
+    water.push(flat);
+  }
+  const cycle = {
+    period,
+    body,
+    water
+  };
+  cycleCache.set(cacheKey, cycle);
+  return cycle;
+}
+
+/** Frame indexes for a cycle at local tick `t`. */
+function cycleIndexes(t, period) {
+  const local = Math.max(0, t);
+  return {
+    bi: local % period,
+    wi: Math.floor(local / 2) % WATER_FRAMES
+  };
+}
+
+// ---------------------------------------------------------------- rects ---
+
+/**
+ * Same-colour runs per row, then runs merged with the identical run directly
+ * below them — roughly a third fewer Views than row runs alone. Covers
+ * exactly the non-transparent cells, never overlaps (proved offline over
+ * every frame of every state).
+ */
+function rectsOf(colors, cols, rows) {
+  const open = [];
+  const done = [];
+  for (let y = 0; y < rows; y++) {
+    const rowRuns = [];
+    let x = 0;
+    while (x < cols) {
+      const color = colors[y * cols + x];
+      let w = 1;
+      while (x + w < cols && colors[y * cols + x + w] === color) w++;
+      if (color !== TRANSPARENT) rowRuns.push({
+        x,
+        y,
+        w,
+        h: 1,
+        color
+      });
+      x += w;
+    }
+    const next = [];
+    for (const r of rowRuns) {
+      const above = open.find(o => o.x === r.x && o.w === r.w && o.color === r.color && o.y + o.h === r.y);
+      if (above) {
+        above.h += 1;
+        next.push(above);
+      } else {
+        next.push(r);
+      }
+    }
+    for (const o of open) if (!next.includes(o)) done.push(o);
+    open.length = 0;
+    open.push(...next);
+  }
+  done.push(...open);
+  return done;
+}
+
+// ---------------------------------------------------------------- sheets --
+
+/** One layer as a strip of distinct frames, and which frame each tick shows. */
+
+const sheetCache = new Map();
+function stripOf(frames, cols, rows) {
+  const keys = frames.map(f => f.join(","));
+  const indexOf = new Map();
+  const distinct = [];
+  keys.forEach((k, i) => {
+    if (!indexOf.has(k)) {
+      indexOf.set(k, distinct.length);
+      distinct.push(rectsOf(frames[i], cols, rows));
+    }
+  });
+  return {
+    colOf: keys.map(k => indexOf.get(k) ?? 0),
+    frames: distinct
+  };
+}
+
+/** Both layers of a state as strips of rectangles. Pure; cached per state. */
+function ottoSheets(state, keyline) {
+  const key = `${state}|${keyline ? 1 : 0}`;
+  const hit = sheetCache.get(key);
+  if (hit) return hit;
+  const cycle = ottoCycle(state, keyline);
+  const built = {
+    period: cycle.period,
+    body: stripOf(cycle.body, _ottoEngine.OTTO_GRID, _ottoEngine.OTTO_GRID),
+    water: stripOf(cycle.water, _ottoEngine.OTTO_GRID, WATER_ROWS)
+  };
+  sheetCache.set(key, built);
+  return built;
+}

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

@@ -433,15 +433,19 @@ const JsModalComponent = ({
     return () => clearTimeout(timeoutId);
   }, [mode, panelHeight, dimensions, visible, persistenceKey, enablePersistence, isStateLoaded]);
 
-  // Sync with external height if provided
+  // Seed the external height ONCE. This used to re-run when `isResizing`
+  // flipped, which snapped an externally-controlled sheet back to
+  // initialHeight the moment a drag-resize ended (the release handler had
+  // just written the real height). The host owns the value after the seed;
+  // persistence restore above may overwrite the seed, which is correct.
+  const externalHeightSeeded = useRef(false);
   useEffect(() => {
-    // Height sync effect
-    if (externalAnimatedHeight && !isResizing) {
+    if (externalAnimatedHeight && !externalHeightSeeded.current) {
+      externalHeightSeeded.current = true;
       currentHeightRef.current = initialHeight;
       externalAnimatedHeight.setValue(initialHeight);
-      // Set external height
     }
-  }, [externalAnimatedHeight, initialHeight, isResizing]);
+  }, [externalAnimatedHeight, initialHeight]);
 
   // Update refs when dimensions change
   useEffect(() => {
@@ -531,11 +535,14 @@ const JsModalComponent = ({
           onModeChangeRef.current?.(savedState.mode);
         }
 
-        // Restore bottom sheet height
+        // Restore bottom sheet height. The external animated height (when a
+        // host passes one) IS the rendered height, so it must be restored
+        // too or a persisted sheet always reopens at initialHeight.
         if (savedState.panelHeight) {
           setPanelHeight(savedState.panelHeight);
           currentHeightRef.current = savedState.panelHeight;
           animatedBottomPosition.setValue(savedState.panelHeight);
+          externalAnimatedHeight?.setValue(savedState.panelHeight);
         }
 
         // Restore floating dimensions and position
@@ -595,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
@@ -717,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) {
@@ -904,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);
@@ -917,6 +958,7 @@ const JsModalComponent = ({
       animatedBottomPosition.stopAnimation(val => {
         currentHeightRef.current = val;
       });
+      externalAnimatedHeight?.stopAnimation();
       bottomSheetTranslateY.stopAnimation();
     },
     onPanResponderMove: evt => {
@@ -963,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-01T17:57:34.045Z
+ * Generated at: 2026-09-04T01:21:28.486Z
  *
  * DO NOT EDIT - This file is generated by scripts/detect-safe-area.js
  *