@buoy-gg/jotai 7.0.16 → 7.0.18

package/lib/module/jotai/components/JotaiAtomDetailContent.js

@@ -271,9 +271,11 @@ export function JotaiAtomDetailContent({
   changes,
   selectedIndex,
   onIndexChange,
-  disableInternalFooter = false
+  disableInternalFooter = false,
+  initialView = "change"
 }) {
-  const [activeView, setActiveView] = useState("change");
+  // View state (initialView seeds it once; taps own it afterwards)
+  const [activeView, setActiveView] = useState(initialView);
   const [diffMode, setDiffMode] = useState("tree");
   const totalChanges = changes.length;
   const atomColor = jotaiStateStore.getAtomColor(change.atomLabel);

package/lib/module/jotai/components/JotaiModal.js

@@ -8,7 +8,7 @@
  * - Events tab: Live atom change monitoring with diffs
  */
 
-import { useState, useMemo, useRef, useCallback } from "react";
+import { useState, useMemo, useRef, useCallback, useEffect } from "react";
 import { View, Text, StyleSheet, FlatList, TextInput, TouchableOpacity } from "react-native";
 import { JsModal, ModalHeader, TabSelector, macOSColors, buoyColors, Search, Filter, Power, X, Box, devToolsStorageKeys, ProUpgradeModal, PowerToggleButton, ToolbarCopyButton, ToolbarClearButton, truncatePayload, TickProvider } from "@buoy-gg/shared-ui";
 import { useIsPro } from "@buoy-gg/license";
@@ -42,11 +42,16 @@ export function JotaiModal({
   onBack,
   onMinimize,
   enableSharedModalDimensions = false,
-  inline = false
+  inline = false,
+  initialTab,
+  initialSelectedChangeId,
+  initialDetailView,
+  onChangeSelect,
+  onAtomExpand
 }) {
   const isPro = useIsPro();
   const [showProModal, setShowProModal] = useState(false);
-  const [activeTab, setActiveTab] = useState("atoms");
+  const [activeTab, setActiveTab] = useState(initialTab ?? "atoms");
   const [selectedHistoryAtom, setSelectedHistoryAtom] = useState(null);
   const [showFilters, setShowFilters] = useState(false);
   const [ignoredPatterns, setIgnoredPatterns] = useState(new Set());
@@ -98,6 +103,30 @@ export function JotaiModal({
   }, [selectedChangeId, activeChanges]);
   const selectedChange = selectedChangeIndex !== null ? activeChanges[selectedChangeIndex] : null;
 
+  // Notify the host on selection (keyed by change id so re-renders with the
+  // same selection don't re-fire; remote mirrors fetch atom values here).
+  const lastNotifiedSelectionRef = useRef(null);
+  useEffect(() => {
+    if (!onChangeSelect) return;
+    const id = selectedChange?.id ?? null;
+    if (id === null || id === lastNotifiedSelectionRef.current) return;
+    lastNotifiedSelectionRef.current = id;
+    onChangeSelect(selectedChange);
+  }, [selectedChange, onChangeSelect]);
+
+  // Deep link into a change's detail (see initialSelectedChangeId). Applied
+  // at most once per id, so the list re-rendering — or the user pressing Back
+  // — never re-opens it.
+  const appliedInitialSelectionRef = useRef(null);
+  useEffect(() => {
+    if (!initialSelectedChangeId) return;
+    if (appliedInitialSelectionRef.current === initialSelectedChangeId) return;
+    const exists = activeChanges.some(c => c.id === initialSelectedChangeId);
+    if (!exists) return;
+    appliedInitialSelectionRef.current = initialSelectedChangeId;
+    setSelectedChangeId(initialSelectedChangeId);
+  }, [initialSelectedChangeId, activeChanges]);
+
   // Search state
   const [searchText, setSearchText] = useState("");
   const [isSearchActive, setIsSearchActive] = useState(false);
@@ -338,7 +367,8 @@ export function JotaiModal({
         changes: activeChanges,
         selectedIndex: selectedChangeIndex,
         onIndexChange: handleIndexChange,
-        disableInternalFooter: true
+        disableInternalFooter: true,
+        initialView: initialDetailView
       });
     }
     if (selectedHistoryAtom) {
@@ -371,7 +401,8 @@ export function JotaiModal({
       return /*#__PURE__*/_jsx(JotaiAtomBrowser, {
         atoms: displayedAtoms,
         searchQuery: searchText,
-        onViewHistory: handleViewHistory
+        onViewHistory: handleViewHistory,
+        onAtomExpand: onAtomExpand
       });
     }
 

package/lib/module/jotai/sync/jotaiSyncAdapter.js

@@ -1,6 +1,60 @@
 "use strict";
 
 import { jotaiStateStore } from "../utils/jotaiStateStore";
+/**
+ * Sentinel used in WIRE-FORM snapshots in place of raw prevValue/nextValue.
+ * Same hazard as redux/zustand: up to 200 changes × 2 values on every
+ * snapshot. Dashboards fetch values via `getChangeDetail`.
+ */
+export const VALUE_ON_DEVICE = Object.freeze({
+  __buoyValueOnDevice: true,
+  note: "Atom values stay on the device — fetched on demand via getChangeDetail / getAtomValue."
+});
+const MAX_CHANGE_DETAIL_BYTES = 8 * 1024 * 1024;
+const MAX_WIRE_PAYLOAD_BYTES = 16 * 1024;
+function jsonLongerThan(value, limit) {
+  let bytes = 0;
+  const stack = [value];
+  const seen = new Set();
+  while (stack.length > 0) {
+    if (bytes > limit) return true;
+    const v = stack.pop();
+    if (v === null || v === undefined) bytes += 4;else if (typeof v === "string") bytes += v.length + 2;else if (typeof v === "number") bytes += 8;else if (typeof v === "boolean") bytes += 5;else if (typeof v === "object") {
+      if (seen.has(v)) continue;
+      seen.add(v);
+      if (Array.isArray(v)) {
+        bytes += 2 + v.length;
+        for (let i = 0; i < v.length; i++) stack.push(v[i]);
+      } else {
+        bytes += 2;
+        for (const k in v) {
+          bytes += k.length + 4;
+          stack.push(v[k]);
+        }
+      }
+    } else bytes += 4;
+  }
+  return bytes > limit;
+}
+function toWireChange(change) {
+  return {
+    ...change,
+    prevValue: VALUE_ON_DEVICE,
+    nextValue: VALUE_ON_DEVICE
+  };
+}
+function toWireValue(value) {
+  try {
+    JSON.stringify(value);
+  } catch {
+    return VALUE_ON_DEVICE;
+  }
+  if (jsonLongerThan(value, MAX_WIRE_PAYLOAD_BYTES)) {
+    return VALUE_ON_DEVICE;
+  }
+  return value;
+}
+
 /**
  * Sync adapter for the jotai tool, consumed by @buoy-gg/external-sync's
  * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
@@ -11,12 +65,19 @@ import { jotaiStateStore } from "../utils/jotaiStateStore";
  * already records. The snapshot carries both the change timeline and the
  * atom registry (with each atom's current value) so the dashboard can render
  * the atom browser.
+ *
+ * v2: change-log prevValue/nextValue are replaced with on-device markers.
+ * Dashboards fetch values via `getChangeDetail`. Oversized / unserializable
+ * `atoms[].currentValue` uses the same marker and is fetched via `getAtomValue`.
  */
 export const jotaiSyncAdapter = {
-  version: 1,
+  version: 2,
   getSnapshot: () => ({
-    changes: jotaiStateStore.getAtomChanges(),
-    atoms: jotaiStateStore.getAtomSnapshots()
+    changes: jotaiStateStore.getAtomChanges().map(toWireChange),
+    atoms: jotaiStateStore.getAtomSnapshots().map(atom => ({
+      ...atom,
+      currentValue: toWireValue(atom.currentValue)
+    }))
   }),
   subscribe: onChange => {
     const unsubscribeChanges = jotaiStateStore.subscribe(onChange);
@@ -30,6 +91,78 @@ export const jotaiSyncAdapter = {
     clearEvents: () => {
       jotaiStateStore.clearAtomChanges();
     },
+    /**
+     * On-demand detail: one change's real prevValue/nextValue.
+     * The per-snapshot stream stays value-free; this is the explicit,
+     * size-guarded channel for the detail pane.
+     */
+    getChangeDetail: params => {
+      const {
+        id
+      } = params ?? {};
+      if (!id) return {
+        found: false,
+        reason: "missing id"
+      };
+      const change = jotaiStateStore.getAtomChangeById(id);
+      if (!change) return {
+        found: false,
+        reason: "unknown id"
+      };
+      const cappedNote = {
+        __buoyTruncated: true,
+        note: `Exceeds the ${MAX_CHANGE_DETAIL_BYTES / (1024 * 1024)}MB detail limit — inspect it on-device.`
+      };
+      const cap = value => jsonLongerThan(value, MAX_CHANGE_DETAIL_BYTES) ? cappedNote : value;
+      return {
+        found: true,
+        id,
+        prevValue: cap(change.prevValue),
+        nextValue: cap(change.nextValue)
+      };
+    },
+    /**
+     * On-demand current value for one atom. Wire-form snapshots replace
+     * oversized / unserializable `currentValue` with VALUE_ON_DEVICE.
+     */
+    getAtomValue: params => {
+      const {
+        label
+      } = params ?? {};
+      if (!label) return {
+        found: false,
+        reason: "missing label"
+      };
+      const atom = jotaiStateStore.getAtom(label);
+      if (!atom) return {
+        found: false,
+        reason: "unknown label"
+      };
+      let currentValue;
+      try {
+        currentValue = atom.getValue();
+      } catch {
+        currentValue = undefined;
+      }
+      const cappedNote = {
+        __buoyTruncated: true,
+        note: `Exceeds the ${MAX_CHANGE_DETAIL_BYTES / (1024 * 1024)}MB detail limit — inspect it on-device.`
+      };
+      try {
+        JSON.stringify(currentValue);
+      } catch {
+        return {
+          found: true,
+          label,
+          currentValue: VALUE_ON_DEVICE
+        };
+      }
+      return {
+        found: true,
+        label,
+        currentValue: jsonLongerThan(currentValue, MAX_CHANGE_DETAIL_BYTES) ? cappedNote : currentValue
+      };
+    },
     /**
      * Compact current-value reader for a remote driver (MCP/LLM): registered
      * atoms with light metadata; each atom's `currentValue` stays on the device
@@ -73,7 +206,8 @@ export const jotaiSyncAdapter = {
       const {
         label,
         value
-      } = params;
+      } = params ?? {};
+      if (!label) throw new Error("setAtom requires a `label`");
       jotaiStateStore.setAtomValue(label, value);
     }
   }

package/lib/module/jotai/utils/jotaiStateStore.js

@@ -286,17 +286,83 @@ class JotaiStateStore {
    */
   replaceFromSnapshot(changes, atomSnapshots) {
     if (!this.isEnabled) return;
-    this.atomChanges = changes.slice(0, this.maxChanges);
-    this.atoms = new Map(atomSnapshots.map(snapshot => [snapshot.label, {
-      label: snapshot.label,
-      changeCount: snapshot.changeCount,
-      color: snapshot.color,
-      getValue: () => snapshot.currentValue
-    }]));
+
+    // Preserve values a remote mirror already hydrated — wire-form snapshots
+    // always carry markers, and a later snapshot must not blank the detail pane.
+    const hydrated = new Map();
+    for (const existing of this.atomChanges) {
+      const prev = existing.prevValue;
+      if (!prev || prev.__buoyValueOnDevice !== true) {
+        hydrated.set(existing.id, existing);
+      }
+    }
+    this.atomChanges = changes.slice(0, this.maxChanges).map(change => {
+      const kept = hydrated.get(change.id);
+      const incoming = change.prevValue;
+      return kept && incoming?.__buoyValueOnDevice === true ? {
+        ...change,
+        prevValue: kept.prevValue,
+        nextValue: kept.nextValue
+      } : change;
+    });
+
+    // Preserve currentValue a remote mirror already hydrated — oversized
+    // atoms arrive as VALUE_ON_DEVICE markers on every snapshot.
+    const hydratedAtoms = new Map();
+    for (const [label, atom] of this.atoms) {
+      try {
+        const value = atom.getValue();
+        const marker = value;
+        if (!marker || marker.__buoyValueOnDevice !== true) {
+          hydratedAtoms.set(label, value);
+        }
+      } catch {
+        // ignore
+      }
+    }
+    this.atoms = new Map(atomSnapshots.map(snapshot => {
+      const incoming = snapshot.currentValue;
+      const kept = hydratedAtoms.get(snapshot.label);
+      const currentValue = kept !== undefined && incoming?.__buoyValueOnDevice === true ? kept : snapshot.currentValue;
+      return [snapshot.label, {
+        label: snapshot.label,
+        changeCount: snapshot.changeCount,
+        color: snapshot.color,
+        getValue: () => currentValue
+      }];
+    }));
     this.notifyListeners();
     this.notifyAtomListeners();
   }
 
+  /**
+   * Hydrate one mirrored change with real values fetched on demand from the
+   * device via the adapter's `getChangeDetail`. Remote-mirror (desktop) only.
+   */
+  hydrateChange(id, patch) {
+    const index = this.atomChanges.findIndex(c => c.id === id);
+    if (index === -1) return;
+    this.atomChanges = [...this.atomChanges.slice(0, index), {
+      ...this.atomChanges[index],
+      ...patch
+    }, ...this.atomChanges.slice(index + 1)];
+    this.notifyListeners();
+  }
+
+  /**
+   * Hydrate one mirrored atom's currentValue fetched on demand from the
+   * device via the adapter's `getAtomValue`. Remote-mirror (desktop) only.
+   */
+  hydrateAtomValue(label, currentValue) {
+    const atom = this.atoms.get(label);
+    if (!atom) return;
+    this.atoms.set(label, {
+      ...atom,
+      getValue: () => currentValue
+    });
+    this.notifyAtomListeners();
+  }
+
   // ---- Atom Registry ----
 
   registerAtom(label, getValue, setValue) {

package/lib/module/jotai/utils/snapshotProvider.js

@@ -0,0 +1,232 @@
+"use strict";
+
+/**
+ * Time Machine snapshot provider for Jotai.
+ *
+ * Registered into @buoy-gg/shared-ui's stateSnapshotRegistry at module init;
+ * consumed by @buoy-gg/time-machine.
+ *
+ * Coverage is opt-in by nature: only atoms the app passed to `watchAtoms` /
+ * `watchDefaultStoreAtoms` are visible. Derived (read-only) atoms are captured
+ * for inspection but never restored — they recompute from their sources.
+ * Caveat (documented): atoms with custom write functions (`atomWithReducer`)
+ * receive ACTIONS through `store.set`, so restoring a raw value can misbehave;
+ * nothing in the registry distinguishes them from plain atoms.
+ */
+import { registerStateSnapshotProvider } from "@buoy-gg/shared-ui";
+import { boundedDeepEqual } from "@buoy-gg/shared-ui/dataViewer";
+import { jotaiStateStore } from "./jotaiStateStore";
+function status() {
+  const atoms = jotaiStateStore.getAtoms();
+  if (atoms.length === 0) {
+    return {
+      canCapture: false,
+      canRestore: false,
+      detail: "No Jotai atoms registered — pass your atoms to watchAtoms() / watchDefaultStoreAtoms()"
+    };
+  }
+  const writable = atoms.filter(a => a.setValue).length;
+  return {
+    canCapture: true,
+    canRestore: writable > 0,
+    detail: writable < atoms.length ? `${atoms.length - writable} derived atom(s) recompute automatically and are not restored` : undefined
+  };
+}
+async function capture() {
+  const warnings = [];
+  const atoms = {};
+  let derived = 0;
+  for (const info of jotaiStateStore.getAtoms()) {
+    try {
+      const value = info.getValue();
+      if (typeof value === "function") {
+        warnings.push(`atom "${info.label}": function value not capturable`);
+        continue;
+      }
+      if (!info.setValue) derived += 1;
+      atoms[info.label] = {
+        value,
+        writable: Boolean(info.setValue)
+      };
+    } catch (e) {
+      warnings.push(`atom "${info.label}": capture failed (${String(e)})`);
+    }
+  }
+  if (derived > 0) {
+    warnings.push(`${derived} derived atom(s) captured for inspection only (recompute on restore)`);
+  }
+  return {
+    data: {
+      atoms
+    },
+    warnings
+  };
+}
+async function restore(data, options) {
+  const snapshot = data;
+  const excludedSet = new Set(options?.excludeKeys ?? []);
+  const includedSet = options?.includeKeys ? new Set(options.includeKeys) : null;
+  const touch = key => !excludedSet.has(key) && (!includedSet || includedSet.has(key));
+  let excludedHits = 0;
+  const result = {
+    ok: true,
+    applied: 0,
+    skipped: [],
+    warnings: []
+  };
+  if (!snapshot?.atoms) {
+    return {
+      ok: false,
+      applied: 0,
+      skipped: [],
+      warnings: ["empty jotai snapshot"]
+    };
+  }
+  let derived = 0;
+  for (const [label, entry] of Object.entries(snapshot.atoms)) {
+    if (!touch(label)) {
+      excludedHits += 1;
+      continue;
+    }
+    if (!entry.writable) {
+      derived += 1;
+      continue;
+    }
+    const info = jotaiStateStore.getAtom(label);
+    if (!info) {
+      result.skipped.push({
+        id: label,
+        reason: "atom not registered (renamed, or unwatched since snapshot?)"
+      });
+      continue;
+    }
+    if (!info.setValue) {
+      result.skipped.push({
+        id: label,
+        reason: "atom is now read-only (derived)"
+      });
+      continue;
+    }
+    try {
+      info.setValue(entry.value);
+      result.applied += 1;
+    } catch (e) {
+      result.skipped.push({
+        id: label,
+        reason: String(e)
+      });
+      result.ok = false;
+    }
+  }
+  if (derived > 0) {
+    result.warnings.push(`${derived} derived atom(s) left to recompute`);
+  }
+  if (excludedHits > 0) {
+    result.warnings.push(`${excludedHits} atom(s) excluded by you`);
+  }
+  return result;
+}
+
+/** Per-atom restore preview. `base` omitted = compare against live atoms. */
+async function previewItems(target, base) {
+  const targetAtoms = target?.atoms ?? {};
+  const liveMode = base === undefined;
+  const baseAtoms = {};
+  if (liveMode) {
+    for (const info of jotaiStateStore.getAtoms()) {
+      try {
+        baseAtoms[info.label] = {
+          value: info.getValue(),
+          writable: Boolean(info.setValue)
+        };
+      } catch {
+        // unreadable atom — treated as absent
+      }
+    }
+  } else {
+    Object.assign(baseAtoms, base?.atoms ?? {});
+  }
+  const items = [];
+  const notes = [];
+  const labels = new Set([...Object.keys(baseAtoms), ...Object.keys(targetAtoms)]);
+  for (const label of labels) {
+    const inTarget = label in targetAtoms;
+    if (!inTarget) {
+      if (liveMode) notes.push(`atom "${label}" not in snapshot — untouched`);else items.push({
+        key: label,
+        label,
+        verdict: "removed",
+        oldValue: baseAtoms[label]?.value
+      });
+      continue;
+    }
+    const entry = targetAtoms[label];
+    const equal = label in baseAtoms && boundedDeepEqual(baseAtoms[label].value, entry.value);
+    if (!entry.writable) {
+      items.push({
+        key: label,
+        label,
+        verdict: equal ? "unchanged" : "recomputes",
+        reason: equal ? undefined : "derived atom — recomputes from its sources",
+        oldValue: baseAtoms[label]?.value,
+        newValue: entry.value
+      });
+      continue;
+    }
+    if (liveMode) {
+      const info = jotaiStateStore.getAtom(label);
+      if (!info) {
+        items.push({
+          key: label,
+          label,
+          verdict: "wont-apply",
+          reason: "atom not registered (renamed, or unwatched since snapshot?)"
+        });
+        continue;
+      }
+      if (!info.setValue) {
+        items.push({
+          key: label,
+          label,
+          verdict: "wont-apply",
+          reason: "atom is now read-only (derived)"
+        });
+        continue;
+      }
+    }
+    if (!(label in baseAtoms)) {
+      items.push({
+        key: label,
+        label,
+        verdict: "added",
+        newValue: entry.value
+      });
+    } else if (equal) {
+      items.push({
+        key: label,
+        label,
+        verdict: "unchanged"
+      });
+    } else {
+      items.push({
+        key: label,
+        label,
+        verdict: "changed",
+        oldValue: baseAtoms[label].value,
+        newValue: entry.value
+      });
+    }
+  }
+  return {
+    items,
+    notes
+  };
+}
+registerStateSnapshotProvider({
+  id: "jotai",
+  label: "Jotai",
+  status,
+  capture,
+  restore,
+  previewItems
+});

package/lib/module/jotai/utils/watchAtoms.js

@@ -56,9 +56,11 @@ export function watchAtoms(store, atoms, options) {
     }
 
     // Register the atom for the browser view. A setter is captured only when
-    // the store supports `set` (writable atoms); read-only/derived atoms throw
-    // at set time and are reported as read-only.
-    const setter = store.set ? value => {
+    // the store supports `set` AND the atom itself is writable (has a `write`
+    // function — primitive atoms get a default one, read-only derived atoms
+    // have none). Deriveds used to get a setter that threw inside jotai at
+    // set time; now they're correctly reported as read-only up front.
+    const setter = store.set && typeof atom.write === "function" ? value => {
       store.set(atom, value);
     } : undefined;
     jotaiStateStore.registerAtom(label, () => {

package/lib/typescript/index.d.ts

@@ -29,6 +29,7 @@
  * watchAtoms(myStore, { countAtom, authAtom });
  * ```
  */
+import "./jotai/utils/snapshotProvider";
 export { jotaiToolPreset, createJotaiTool } from "./preset";
 export { watchAtoms } from "./jotai/utils/watchAtoms";
 export { watchDefaultStoreAtoms } from "./jotai/utils/watchAtoms";
@@ -41,7 +42,7 @@ export { JotaiAtomChangeItem } from "./jotai/components/JotaiAtomChangeItem";
 export { JotaiAtomDetailContent, JotaiAtomDetailFooter, } from "./jotai/components/JotaiAtomDetailContent";
 export { JotaiIcon, JOTAI_ICON_COLOR } from "./jotai/components/JotaiIcon";
 export { jotaiSyncAdapter } from "./jotai/sync/jotaiSyncAdapter";
-export type { JotaiModalProps, JotaiAtomChange, JotaiAtomInfo, JotaiAtomSnapshot, JotaiFilter, AtomChangeCategory, WatchAtomsOptions, } from "./jotai/types";
+export type { JotaiModalProps, JotaiDetailViewMode, JotaiAtomChange, JotaiAtomInfo, JotaiAtomSnapshot, JotaiFilter, AtomChangeCategory, WatchAtomsOptions, } from "./jotai/types";
 /** @internal */
 export { jotaiStateStore } from "./jotai/utils/jotaiStateStore";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK5D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAKtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAK9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,YAAY,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAOnF,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAK3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,YAAY,EACV,eAAe,EACf,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAKvB,gBAAgB;AAChB,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,gCAAgC,CAAC;AAKxC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK5D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAKtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAK9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,YAAY,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAOnF,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAK3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAKvB,gBAAgB;AAChB,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC"}

package/lib/typescript/jotai/components/JotaiAtomBrowser.d.ts

@@ -9,7 +9,9 @@ interface JotaiAtomBrowserProps {
     atoms: JotaiAtomInfo[];
     searchQuery: string;
     onViewHistory: (atomLabel: string) => void;
+    /** Fired when an atom row is expanded (not when collapsed). */
+    onAtomExpand?: (label: string) => void;
 }
-export declare function JotaiAtomBrowser({ atoms, searchQuery, onViewHistory, }: JotaiAtomBrowserProps): import("react").JSX.Element;
+export declare function JotaiAtomBrowser({ atoms, searchQuery, onViewHistory, onAtomExpand, }: JotaiAtomBrowserProps): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=JotaiAtomBrowser.d.ts.map

package/lib/typescript/jotai/components/JotaiAtomBrowser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JotaiAtomBrowser.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomBrowser.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG9C,UAAU,qBAAqB;IAC7B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAyGD,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,WAAW,EACX,aAAa,GACd,EAAE,qBAAqB,+BAiFvB"}
+{"version":3,"file":"JotaiAtomBrowser.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomBrowser.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG9C,UAAU,qBAAqB;IAC7B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,+DAA+D;IAC/D,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAgHD,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,WAAW,EACX,aAAa,EACb,YAAY,GACb,EAAE,qBAAqB,+BAwFvB"}

package/lib/typescript/jotai/components/JotaiAtomDetailContent.d.ts

@@ -9,15 +9,20 @@
  * Mirrors ZustandStateDetailContent.tsx from @buoy-gg/zustand
  */
 import React from "react";
-import type { JotaiAtomChange } from "../types";
+import type { JotaiAtomChange, JotaiDetailViewMode } from "../types";
 interface JotaiAtomDetailContentProps {
     change: JotaiAtomChange;
     changes: JotaiAtomChange[];
     selectedIndex: number;
     onIndexChange: (index: number) => void;
     disableInternalFooter?: boolean;
+    /**
+     * Seeds the CHANGE / VALUE / DIFF toggle once on mount. Host deep-links
+     * (docs live tour) pass this; the user's own toggle taps take over after.
+     */
+    initialView?: JotaiDetailViewMode;
 }
-export declare function JotaiAtomDetailContent({ change, changes, selectedIndex, onIndexChange, disableInternalFooter, }: JotaiAtomDetailContentProps): React.JSX.Element;
+export declare function JotaiAtomDetailContent({ change, changes, selectedIndex, onIndexChange, disableInternalFooter, initialView, }: JotaiAtomDetailContentProps): React.JSX.Element;
 export declare function JotaiAtomDetailFooter({ change, changes, selectedIndex, onIndexChange, }: {
     change: JotaiAtomChange;
     changes: JotaiAtomChange[];

package/lib/typescript/jotai/components/JotaiAtomDetailContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JotaiAtomDetailContent.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomDetailContent.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAA+C,MAAM,OAAO,CAAC;AA0BpE,OAAO,KAAK,EAAE,eAAe,EAAsB,MAAM,UAAU,CAAC;AAmQpE,UAAU,2BAA2B;IACnC,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,OAAO,EACP,aAAa,EACb,aAAa,EACb,qBAA6B,GAC9B,EAAE,2BAA2B,qBAyJ7B;AAED,wBAAgB,qBAAqB,CAAC,EACpC,MAAM,EACN,OAAO,EACP,aAAa,EACb,aAAa,GACd,EAAE;IACD,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,4BAcA"}
+{"version":3,"file":"JotaiAtomDetailContent.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomDetailContent.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAA+C,MAAM,OAAO,CAAC;AA0BpE,OAAO,KAAK,EACV,eAAe,EAEf,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAiQlB,UAAU,2BAA2B;IACnC,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,WAAW,CAAC,EAAE,mBAAmB,CAAC;CACnC;AAED,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,OAAO,EACP,aAAa,EACb,aAAa,EACb,qBAA6B,EAC7B,WAAsB,GACvB,EAAE,2BAA2B,qBA2J7B;AAED,wBAAgB,qBAAqB,CAAC,EACpC,MAAM,EACN,OAAO,EACP,aAAa,EACb,aAAa,GACd,EAAE;IACD,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,4BAcA"}