@buoy-gg/storage 7.0.40 → 7.0.42

package/lib/module/storage/utils/storageLabels.js

@@ -0,0 +1 @@
+"use strict";export const storageLabels={async:"Async",asyncFull:"AsyncStorage",mmkv:"MMKV",secure:"Secure",hasSecure:true};

package/lib/module/storage/utils/storageLabels.web.js

@@ -0,0 +1 @@
+"use strict";export const storageLabels={async:"Local",asyncFull:"localStorage",mmkv:"Session",secure:"Secure",hasSecure:false};

package/lib/module/storage/utils/storageOps.js

@@ -1,46 +1 @@
-"use strict";
-
-/**
- * The five operations a storage event can be, and how to recognise one.
- *
- * AsyncStorage and MMKV each have their own action union, and neither maps
- * cleanly onto what a reader wants to see — `multiRemove`, `removeItem` and
- * `delete` are one idea wearing three names. These collapse both onto a single
- * vocabulary so every surface labels, filters and colours events the same way.
- *
- * This is semantics, not presentation: it lives in `utils` rather than beside
- * any one view, so a view can be deleted without taking the vocabulary with it.
- */
-
-import { macOSColors } from "@buoy-gg/shared-ui";
-export const STORAGE_OPS = ["SET", "GET", "MERGE", "DELETE", "CLEAR"];
-const OP_DOT = {
-  SET: macOSColors.semantic.info,
-  GET: macOSColors.text.muted,
-  MERGE: macOSColors.semantic.debug,
-  DELETE: macOSColors.semantic.error,
-  CLEAR: macOSColors.semantic.warning
-};
-export function storageOpDot(op) {
-  return OP_DOT[op];
-}
-
-/** Both backends' action unions, collapsed onto the five display operations. */
-export function storageOpOf(event) {
-  const action = event.action;
-  if (action === "clear" || action === "clearAll") return "CLEAR";
-  if (action.startsWith("get.")) return "GET";
-  if (action === "removeItem" || action === "multiRemove" || action === "delete") return "DELETE";
-  if (action === "mergeItem" || action === "multiMerge") return "MERGE";
-  return "SET";
-}
-
-/**
- * The store synthesises one event per existing key when it first subscribes, so
- * the list isn't empty on open. Those are a SNAPSHOT, not a write: the key
- * already held that value, so there is no "before" to diff against and showing
- * one would invent a change that never happened.
- */
-export function isInitialScan(event) {
-  return Boolean(event.data?.initialScan);
-}
+"use strict";import{macOSColors as r}from"@buoy-gg/shared-ui";export const STORAGE_OPS=["SET","GET","MERGE","DELETE","CLEAR"];const n={SET:r.semantic.info,GET:r.text.muted,MERGE:r.semantic.debug,DELETE:r.semantic.error,CLEAR:r.semantic.warning};export function storageOpDot(e){return n[e]}export function storageOpOf(e){const t=e.action;if(t==="clear"||t==="clearAll")return"CLEAR";if(t.startsWith("get."))return"GET";if(t==="removeItem"||t==="multiRemove"||t==="delete")return"DELETE";if(t==="mergeItem"||t==="multiMerge")return"MERGE";return"SET"}export function isInitialScan(e){return Boolean(e.data?.initialScan)}

package/lib/module/storage/utils/storageQueryUtils.js

@@ -1,30 +1 @@
-"use strict";
-
-import { gameUIColors } from "@buoy-gg/shared-ui";
-/** Human readable label for a storage type id. */
-export function getStorageTypeLabel(storageType) {
-  switch (storageType) {
-    case "mmkv":
-      return "MMKV";
-    case "async":
-      return "Async";
-    case "secure":
-      return "Secure";
-    default:
-      return storageType;
-  }
-}
-
-/** Preferred color token for rendering a given storage type. */
-export function getStorageTypeHexColor(storageType) {
-  switch (storageType) {
-    case "mmkv":
-      return gameUIColors.info;
-    case "async":
-      return gameUIColors.warning;
-    case "secure":
-      return gameUIColors.success;
-    default:
-      return gameUIColors.muted;
-  }
-}
+"use strict";import{gameUIColors as r}from"@buoy-gg/shared-ui";export function getStorageTypeLabel(e){switch(e){case"mmkv":return"MMKV";case"async":return"Async";case"secure":return"Secure";default:return e}}export function getStorageTypeHexColor(e){switch(e){case"mmkv":return r.info;case"async":return r.warning;case"secure":return r.success;default:return r.muted}}

package/lib/module/storage/utils/storageTimeTravelUtils.js

@@ -1,281 +1 @@
-"use strict";
-
-/**
- * Storage Time-Travel Utilities
- *
- * Provides jump and undo functionality for AsyncStorage operations.
- */
-
-import { isDevToolsStorageKey } from "@buoy-gg/shared-ui";
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import { writeMany, removeMany } from "./asyncStorageCompat";
-function isOmittedStorageValue(value) {
-  return !!value && typeof value === "object" && value.__buoyValueOnDevice === true;
-}
-
-/**
- * Undo a single storage operation
- *
- * Restores the previous value(s) before the operation occurred.
- *
- * The restore is deliberately NOT capture-paused. Pausing it meant the write
- * landed but emitted no event, so the modal's event list and current-value
- * panel never changed — UNDO looked like a dead button even though it had
- * worked. Letting the restore emit normally makes it visible and keeps the
- * history honest about what the storage actually did. There is no feedback
- * loop: a write emits an event, and an event never triggers a write.
- *
- * @param event - The storage event to undo
- */
-export async function undoOperation(event) {
-  const {
-    action,
-    data
-  } = event;
-  if (isOmittedStorageValue(data?.prevValue) || isOmittedStorageValue(data?.prevPairs)) {
-    throw new Error("Cannot undo: previous value is still on the device — fetch getEventDetail first");
-  }
-  {
-    switch (action) {
-      case "setItem":
-      case "mergeItem":
-        if (data?.key) {
-          if (data.prevValue === null || data.prevValue === undefined) {
-            // Key didn't exist before, remove it
-            await AsyncStorage.removeItem(data.key);
-          } else {
-            // Restore previous value
-            await AsyncStorage.setItem(data.key, data.prevValue);
-          }
-        }
-        break;
-      case "removeItem":
-        if (data?.key && data.prevValue !== null && data.prevValue !== undefined) {
-          // Restore the removed value
-          await AsyncStorage.setItem(data.key, data.prevValue);
-        }
-        break;
-      case "multiSet":
-      case "multiMerge":
-        if (data?.prevPairs && data.prevPairs.length > 0) {
-          // Restore all previous values
-          for (const [key, value] of data.prevPairs) {
-            if (value === null) {
-              await AsyncStorage.removeItem(key);
-            } else {
-              await AsyncStorage.setItem(key, value);
-            }
-          }
-        }
-        break;
-      case "multiRemove":
-        if (data?.prevPairs && data.prevPairs.length > 0) {
-          // Restore all removed values
-          for (const [key, value] of data.prevPairs) {
-            if (value !== null) {
-              await AsyncStorage.setItem(key, value);
-            }
-          }
-        }
-        break;
-      case "clear":
-        if (data?.prevPairs && data.prevPairs.length > 0) {
-          // Restore all cleared key-value pairs
-          const pairsToRestore = data.prevPairs.filter(([, value]) => value !== null);
-          if (pairsToRestore.length > 0) {
-            await writeMany(pairsToRestore);
-          }
-        }
-        break;
-      default:
-        throw new Error(`Cannot undo unknown action type: ${action}`);
-    }
-  }
-}
-
-/**
- * Jump to a specific point in storage history
- *
- * Reconstructs the state as of `targetEventIndex` by replaying `events` up to
- * that point, then reconciling ONLY the keys that timeline governs.
- *
- * This used to begin with `AsyncStorage.clear()`, which was badly out of
- * proportion: the modal's JUMP button passes one key's history, so clearing
- * wiped every unrelated app key — and Buoy's own `@react_buoy*` settings with
- * them — to restore a single value. Now a jump touches exactly the keys that
- * appear in the events it was given, and never Buoy's own keys. Like
- * [undoOperation], the writes emit normally so the change is visible.
- *
- * @param events - All events in chronological order (oldest first)
- * @param targetEventIndex - The index of the event to jump to (0-based)
- */
-export async function jumpToState(events, targetEventIndex) {
-  if (targetEventIndex < 0 || targetEventIndex >= events.length) {
-    throw new Error(`Invalid event index: ${targetEventIndex}`);
-  }
-  for (const event of events) {
-    const data = event.data;
-    if (isOmittedStorageValue(data?.value) || isOmittedStorageValue(data?.prevValue) || isOmittedStorageValue(data?.pairs) || isOmittedStorageValue(data?.prevPairs)) {
-      throw new Error("Cannot jump: some event values are still on the device — fetch getEventDetail first");
-    }
-  }
-
-  // Build up the state by applying each event up to and including the target.
-  // We use the final values from each event, not the operations themselves.
-  const stateMap = new Map();
-  for (let i = 0; i <= targetEventIndex; i++) {
-    applyEventToStateMap(events[i], stateMap);
-  }
-
-  // Every key the WHOLE timeline touches — including events after the target,
-  // so a key created later is removed rather than left behind.
-  const governedKeys = new Set();
-  for (const event of events) {
-    collectEventKeys(event, governedKeys);
-  }
-  const pairsToSet = [];
-  const keysToRemove = [];
-  for (const key of governedKeys) {
-    // Buoy's own settings are never app state to travel through.
-    if (isDevToolsStorageKey(key)) continue;
-    const value = stateMap.get(key);
-    if (value === undefined || value === null) {
-      keysToRemove.push(key);
-    } else {
-      pairsToSet.push([key, value]);
-    }
-  }
-  if (keysToRemove.length > 0) {
-    await removeMany(keysToRemove);
-  }
-  if (pairsToSet.length > 0) {
-    await writeMany(pairsToSet);
-  }
-}
-
-/**
- * Collect every key an event refers to, across all action shapes — including
- * `prevPairs`, so keys a `clear` removed are still governed by the timeline.
- */
-function collectEventKeys(event, into) {
-  const {
-    data
-  } = event;
-  if (!data) return;
-  if (data.key) into.add(data.key);
-  if (data.keys) for (const key of data.keys) into.add(key);
-  if (data.pairs) for (const [key] of data.pairs) into.add(key);
-  if (data.prevPairs) for (const [key] of data.prevPairs) into.add(key);
-}
-
-/**
- * Helper to apply an event's effects to a state map
- */
-function applyEventToStateMap(event, stateMap) {
-  const {
-    action,
-    data
-  } = event;
-  switch (action) {
-    case "setItem":
-      if (data?.key && data?.value !== undefined) {
-        stateMap.set(data.key, data.value);
-      }
-      break;
-    case "removeItem":
-      if (data?.key) {
-        stateMap.set(data.key, null);
-      }
-      break;
-    case "mergeItem":
-      if (data?.key && data?.value !== undefined) {
-        const existing = stateMap.get(data.key);
-        if (existing) {
-          try {
-            // Merge JSON objects
-            const existingObj = JSON.parse(existing);
-            const newObj = JSON.parse(data.value);
-            const merged = {
-              ...existingObj,
-              ...newObj
-            };
-            stateMap.set(data.key, JSON.stringify(merged));
-          } catch {
-            // If not valid JSON, just overwrite
-            stateMap.set(data.key, data.value);
-          }
-        } else {
-          stateMap.set(data.key, data.value);
-        }
-      }
-      break;
-    case "multiSet":
-      if (data?.pairs) {
-        for (const [key, value] of data.pairs) {
-          stateMap.set(key, value);
-        }
-      }
-      break;
-    case "multiRemove":
-      if (data?.keys) {
-        for (const key of data.keys) {
-          stateMap.set(key, null);
-        }
-      }
-      break;
-    case "multiMerge":
-      if (data?.pairs) {
-        for (const [key, value] of data.pairs) {
-          const existing = stateMap.get(key);
-          if (existing) {
-            try {
-              const existingObj = JSON.parse(existing);
-              const newObj = JSON.parse(value);
-              const merged = {
-                ...existingObj,
-                ...newObj
-              };
-              stateMap.set(key, JSON.stringify(merged));
-            } catch {
-              stateMap.set(key, value);
-            }
-          } else {
-            stateMap.set(key, value);
-          }
-        }
-      }
-      break;
-    case "clear":
-      // Clear the entire state map
-      stateMap.clear();
-      break;
-  }
-}
-
-/**
- * Check if an operation can be undone
- *
- * Some operations may not have the previous value captured.
- */
-export function canUndo(event) {
-  const {
-    action,
-    data
-  } = event;
-  switch (action) {
-    case "setItem":
-    case "mergeItem":
-    case "removeItem":
-      // Can undo if we have the key — but not while prevValue is still a
-      // wire-form on-device marker (restoring that would write garbage).
-      return !!data?.key && !isOmittedStorageValue(data.prevValue);
-    case "multiSet":
-    case "multiRemove":
-    case "multiMerge":
-    case "clear":
-      // Can undo if we have previous pairs
-      return !!data?.prevPairs && data.prevPairs.length > 0 && !isOmittedStorageValue(data.prevPairs);
-    default:
-      return false;
-  }
-}
+"use strict";import{isDevToolsStorageKey as m}from"@buoy-gg/shared-ui";import l from"@react-native-async-storage/async-storage";import{writeMany as f,removeMany as y}from"./asyncStorageCompat";function c(s){return!!s&&typeof s==="object"&&s.__buoyValueOnDevice===true}export async function undoOperation(s){const{action:r,data:e}=s;if(c(e?.prevValue)||c(e?.prevPairs)){throw new Error("Cannot undo: previous value is still on the device \u2014 fetch getEventDetail first")}{switch(r){case"setItem":case"mergeItem":if(e?.key){if(e.prevValue===null||e.prevValue===void 0){await l.removeItem(e.key)}else{await l.setItem(e.key,e.prevValue)}}break;case"removeItem":if(e?.key&&e.prevValue!==null&&e.prevValue!==void 0){await l.setItem(e.key,e.prevValue)}break;case"multiSet":case"multiMerge":if(e?.prevPairs&&e.prevPairs.length>0){for(const[t,a]of e.prevPairs){if(a===null){await l.removeItem(t)}else{await l.setItem(t,a)}}}break;case"multiRemove":if(e?.prevPairs&&e.prevPairs.length>0){for(const[t,a]of e.prevPairs){if(a!==null){await l.setItem(t,a)}}}break;case"clear":if(e?.prevPairs&&e.prevPairs.length>0){const t=e.prevPairs.filter(([,a])=>a!==null);if(t.length>0){await f(t)}}break;default:throw new Error(`Cannot undo unknown action type: ${r}`)}}}export async function jumpToState(s,r){if(r<0||r>=s.length){throw new Error(`Invalid event index: ${r}`)}for(const i of s){const o=i.data;if(c(o?.value)||c(o?.prevValue)||c(o?.pairs)||c(o?.prevPairs)){throw new Error("Cannot jump: some event values are still on the device \u2014 fetch getEventDetail first")}}const e=new Map;for(let i=0;i<=r;i++){k(s[i],e)}const t=new Set;for(const i of s){p(i,t)}const a=[];const n=[];for(const i of t){if(m(i))continue;const o=e.get(i);if(o===void 0||o===null){n.push(i)}else{a.push([i,o])}}if(n.length>0){await y(n)}if(a.length>0){await f(a)}}function p(s,r){const{data:e}=s;if(!e)return;if(e.key)r.add(e.key);if(e.keys)for(const t of e.keys)r.add(t);if(e.pairs)for(const[t]of e.pairs)r.add(t);if(e.prevPairs)for(const[t]of e.prevPairs)r.add(t)}function k(s,r){const{action:e,data:t}=s;switch(e){case"setItem":if(t?.key&&t?.value!==void 0){r.set(t.key,t.value)}break;case"removeItem":if(t?.key){r.set(t.key,null)}break;case"mergeItem":if(t?.key&&t?.value!==void 0){const a=r.get(t.key);if(a){try{const n=JSON.parse(a);const i=JSON.parse(t.value);const o={...n,...i};r.set(t.key,JSON.stringify(o))}catch{r.set(t.key,t.value)}}else{r.set(t.key,t.value)}}break;case"multiSet":if(t?.pairs){for(const[a,n]of t.pairs){r.set(a,n)}}break;case"multiRemove":if(t?.keys){for(const a of t.keys){r.set(a,null)}}break;case"multiMerge":if(t?.pairs){for(const[a,n]of t.pairs){const i=r.get(a);if(i){try{const o=JSON.parse(i);const u=JSON.parse(n);const v={...o,...u};r.set(a,JSON.stringify(v))}catch{r.set(a,n)}}else{r.set(a,n)}}}break;case"clear":r.clear();break}}export function canUndo(s){const{action:r,data:e}=s;switch(r){case"setItem":case"mergeItem":case"removeItem":return!!e?.key&&!c(e.prevValue);case"multiSet":case"multiRemove":case"multiMerge":case"clear":return!!e?.prevPairs&&e.prevPairs.length>0&&!c(e.prevPairs);default:return false}}

package/lib/module/storage/utils/valueType.js

@@ -1,76 +1 @@
-"use strict";
-
-/** Return a concise string describing the JavaScript type of the provided value. */
-export function getValueTypeLabel(value) {
-  if (value === null) return "null";
-  if (value === undefined) return "undefined";
-  if (Array.isArray(value)) return "array";
-  const type = typeof value;
-  if (type === "object") return "object";
-  if (type === "boolean") return "boolean";
-  if (type === "number") return "number";
-  if (type === "string") return "string";
-  return "unknown";
-}
-
-/**
- * A stored value as a tree can show it.
- *
- * AsyncStorage and SecureStore hold strings, so an object arrives as the text
- * `{"a":1}` — displaying that as a string is technically true and useless. Any
- * surface that renders or edits a value structurally has to do this same
- * un-stringify first, so it lives here rather than being re-derived (slightly
- * differently) in each one.
- *
- * A string that doesn't parse comes back untouched: it was just a string that
- * happened to start with a brace.
- */
-export function parseStorageValue(value) {
-  if (typeof value !== "string") return value;
-  const trimmed = value.trim();
-  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-
-/** Longest value preview rendered inline next to the type label. */
-const MAX_INLINE_PREVIEW = 40;
-
-/**
- * Short, human-readable preview of a value for inline display next to the type
- * label, or `null` when the value is too large/complex to preview (long
- * strings, objects, arrays). Lets the user read simple values without opening
- * the card.
- */
-export function getValuePreview(value) {
-  switch (typeof value) {
-    case "boolean":
-      return value ? "true" : "false";
-    case "number":
-      return Number.isFinite(value) ? String(value) : null;
-    case "string":
-      {
-        if (value.length === 0) return '""';
-        if (value.length > MAX_INLINE_PREVIEW) return null;
-        // Collapse whitespace so multi-line/tabbed values stay on one line.
-        return `"${value.replace(/\s+/g, " ")}"`;
-      }
-    default:
-      return null;
-    // objects, arrays, null, undefined
-  }
-}
-
-/**
- * Type label optionally followed by a short value preview — e.g. `boolean · true`,
- * `number · 42`, `string · "hello"`. Falls back to just the type label when the
- * value is too large to preview.
- */
-export function getValueTypeWithPreview(value) {
-  const label = getValueTypeLabel(value);
-  const preview = getValuePreview(value);
-  return preview ? `${label} · ${preview}` : label;
-}
+"use strict";export function getValueTypeLabel(r){if(r===null)return"null";if(r===void 0)return"undefined";if(Array.isArray(r))return"array";const t=typeof r;if(t==="object")return"object";if(t==="boolean")return"boolean";if(t==="number")return"number";if(t==="string")return"string";return"unknown"}export function parseStorageValue(r){if(typeof r!=="string")return r;const t=r.trim();if(!t.startsWith("{")&&!t.startsWith("["))return r;try{return JSON.parse(r)}catch{return r}}const n=40;export function getValuePreview(r){switch(typeof r){case"boolean":return r?"true":"false";case"number":return Number.isFinite(r)?String(r):null;case"string":{if(r.length===0)return'""';if(r.length>n)return null;return`"${r.replace(/\s+/g," ")}"`}default:return null}}export function getValueTypeWithPreview(r){const t=getValueTypeLabel(r);const e=getValuePreview(r);return e?`${t} \xB7 ${e}`:t}

package/lib/typescript/index.d.ts

@@ -51,4 +51,5 @@ export { storageEventStore, isValueOnDevice, batchPairsOf, } from "./storage/sto
  * @internal
  */
 export { requestStorageBrowserRefresh } from "./storage/utils/storageBrowserRefresh";
+export { startBrowserStorageCapture } from './storage/utils/browserStorageLifecycle';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/storage/components/MMKVInstanceSelector.d.ts

@@ -1,11 +1,3 @@
-/**
- * MMKVInstanceSelector Component
- *
- * Dropdown selector for choosing between multiple MMKV instances.
- * Shows instance ID, key count, and metadata badges (encrypted, read-only).
- *
- * Used in GameUIStorageBrowser when storage type filter is set to "mmkv".
- */
 interface MMKVInstanceSelectorProps {
     selectedInstanceId: string | null;
     onSelectInstance: (instanceId: string) => void;

package/lib/typescript/storage/components/StorageEventCard.d.ts

@@ -1,10 +1,3 @@
-/**
- * StorageEventCard
- *
- * Shared card component for displaying storage events.
- * Used by both Storage DevTools and Events DevTools for consistent UI.
- * Uses CompactRow for consistent layout with Redux/React Query cards.
- */
 /** Value type for storage events */
 export type StorageValueType = "string" | "number" | "boolean" | "null" | "undefined" | "object" | "array";
 /**

package/lib/typescript/storage/components/StorageKeyRow.d.ts

@@ -20,12 +20,8 @@ interface StorageKeyRowProps {
     /** Toggle this key's pinned state */
     onTogglePin?: (key: string) => void;
     /**
-     * Open the full-screen editor for this key. Omit to keep the row read-only —
-     * the Edit affordance only appears when a host supplies this.
-     *
-     * The card deliberately doesn't edit anything itself: a tree, six structural
-     * actions and a keyboard don't fit in an expanded row, and cramming them in
-     * is what this replaced. See `StorageKeyEditorScreen`.
+     * Open `StorageKeyDetailScreen` to edit this key. The Edit affordance appears
+     * only when the host supplies this callback; the row does not edit values.
      */
     onEditKey?: (storageKey: StorageKeyInfo) => void;
     /**

package/lib/typescript/storage/components/StorageTypeFilterBar.d.ts

@@ -1,18 +1,3 @@
-/**
- * "Which backend?" — the pill row shared by the Keys and Events tabs.
- *
- * Both tabs answer questions about the same three backends, so asking the
- * question two different ways (or, as it was, only on one tab) is a gap rather
- * than a simplification: you filter the key list to Keychain, switch to Events
- * to see what wrote to it, and you're looking at everything again.
- *
- * The selection is owned by the modal and passed to both, so switching tabs
- * keeps the filter you set.
- *
- * Each pill carries the count it WOULD show, computed before the type filter is
- * applied — a count that collapsed to zero the moment you picked another type
- * would tell you nothing about where to look next.
- */
 export type StorageTypeFilter = "all" | "async" | "mmkv" | "secure";
 export type StorageTypeCounts = Record<StorageTypeFilter, number>;
 interface StorageTypeFilterBarProps {

package/lib/typescript/storage/hooks/useSecureStoreKeys.d.ts

@@ -1,4 +1,4 @@
-import { StorageKeyInfo } from "../types";
+import { RequiredStorageKey, StorageKeyInfo } from "../types";
 interface UseSecureStoreKeysOptions {
     /** Re-read interval in ms. `0` disables polling. */
     pollMs?: number;
@@ -20,6 +20,6 @@ interface UseSecureStoreKeysResult {
  * Values are re-read on a poll and whenever the registry changes, so the
  * browser tracks writes the app makes while the tool is open.
  */
-export declare function useSecureStoreKeys(options?: UseSecureStoreKeysOptions): UseSecureStoreKeysResult;
+export declare function useSecureStoreKeys(requiredStorageKeys?: RequiredStorageKey[], options?: UseSecureStoreKeysOptions): UseSecureStoreKeysResult;
 export {};
 //# sourceMappingURL=useSecureStoreKeys.d.ts.map

package/lib/typescript/storage/sync/storageSyncAdapter.d.ts

@@ -1,4 +1,5 @@
 import { type StorageEvent } from "../stores/storageEventStore";
+import type { RequiredStorageKey } from "../types";
 /**
  * Sentinel used in WIRE-FORM snapshots in place of oversized values.
  * Storage events, MMKV browse dumps, and SecureStore dumps all reuse this
@@ -47,26 +48,19 @@ export interface SecureSnapshotEntry {
     value: unknown;
 }
 /**
- * Sync adapter for the storage tool, consumed by @buoy-gg/external-sync's
- * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
- * this package doesn't need a dependency on it).
- *
- * Subscribing starts the underlying capture lifecycle (including the initial
- * key scan), so storage events are only recorded while a dashboard is
- * watching.
- *
- * The `async.*` actions mirror the AsyncStorage API so the desktop dashboard
- * can proxy its browse/edit mode against the device's real storage.
- *
- * v2: oversized / unserializable event values are replaced with
- * VALUE_ON_DEVICE. Dashboards fetch them via `getEventDetail`.
+ * Called by `createStorageTool` so remote dashboards validate against the
+ * same required keys as the on-device tool. The desktop panel used to have no
+ * way to learn them and showed every key as unchecked.
  */
+export declare function setToolRequiredStorageKeys(keys: RequiredStorageKey[]): void;
 export declare const storageSyncAdapter: {
     version: number;
     getSnapshot: () => StorageEvent[];
     subscribe: (onChange: () => void) => () => void;
     actions: {
         clearEvents: () => void;
+        /** The app's required storage keys, as given to `createStorageTool`. */
+        getRequiredKeys: () => RequiredStorageKey[];
         /**
          * On-demand detail: one event's real value/prevValue/pairs.
          * The per-snapshot stream stays payload-light; this is the explicit,

package/lib/typescript/storage/utils/AsyncStorageListener.web.d.ts

@@ -0,0 +1,24 @@
+import type { AsyncStorageEventListener } from './AsyncStorageListener';
+export type { AsyncStorageEvent, AsyncStorageEventListener } from './AsyncStorageListener';
+export declare function startListening(): Promise<void>;
+export declare function stopListening(): void;
+export declare function addListener(listener: AsyncStorageEventListener): () => void;
+export declare function removeAllListeners(): void;
+export declare function isListening(): boolean;
+export declare function getListenerCount(): number;
+export declare function pauseCapture(): void;
+export declare function resumeCapture(): void;
+export declare function isPaused(): boolean;
+declare const asyncStorageListener: {
+    startListening: typeof startListening;
+    stopListening: typeof stopListening;
+    addListener: typeof addListener;
+    removeAllListeners: typeof removeAllListeners;
+    pause: typeof pauseCapture;
+    resume: typeof resumeCapture;
+    readonly isActive: boolean;
+    readonly listenerCount: number;
+    readonly paused: boolean;
+};
+export default asyncStorageListener;
+//# sourceMappingURL=AsyncStorageListener.web.d.ts.map

package/lib/typescript/storage/utils/browserStorageLifecycle.d.ts

@@ -0,0 +1,3 @@
+/** Native backends are registered by the host application. */
+export declare function startBrowserStorageCapture(): () => void;
+//# sourceMappingURL=browserStorageLifecycle.d.ts.map

package/lib/typescript/storage/utils/browserStorageLifecycle.web.d.ts

@@ -0,0 +1,2 @@
+export declare function startBrowserStorageCapture(): () => void;
+//# sourceMappingURL=browserStorageLifecycle.web.d.ts.map

package/lib/typescript/storage/utils/mmkvAvailability.web.d.ts

@@ -0,0 +1,4 @@
+export declare function isMMKVAvailable(): boolean;
+export declare function getMMKVClass(): null;
+export declare function getMMKVUnavailableMessage(): string;
+//# sourceMappingURL=mmkvAvailability.web.d.ts.map

package/lib/typescript/storage/utils/storageLabels.d.ts

@@ -0,0 +1,8 @@
+export declare const storageLabels: {
+    async: string;
+    asyncFull: string;
+    mmkv: string;
+    secure: string;
+    hasSecure: boolean;
+};
+//# sourceMappingURL=storageLabels.d.ts.map

package/lib/typescript/storage/utils/storageLabels.web.d.ts

@@ -0,0 +1,8 @@
+export declare const storageLabels: {
+    async: string;
+    asyncFull: string;
+    mmkv: string;
+    secure: string;
+    hasSecure: boolean;
+};
+//# sourceMappingURL=storageLabels.web.d.ts.map