@buoy-gg/zustand 7.0.41 → 7.0.42

package/lib/module/zustand/utils/buoyZustandMiddleware.js

@@ -1,278 +1 @@
-"use strict";
-
-/**
- * Buoy Zustand DevTools — Store instrumentation
- *
- * Two approaches, from easiest to most detailed:
- *
- * 1. watchStores() — RECOMMENDED. One line, zero store modifications.
- *    Uses store.subscribe() externally. Never touches setState.
- *    Safe to add/remove — cannot break your stores even if our code has bugs.
- *
- * 2. buoyDevTools() — Opt-in middleware for advanced use.
- *    Wraps setState to capture the partial argument and timing.
- *    Requires modifying each store's create() call.
- */
-
-import { zustandStateStore } from "./zustandStateStore";
-/** Symbol to mark stores that have been watched/instrumented */
-const WATCHED_SYMBOL = Symbol.for("@@buoy-zustand/watched");
-
-/** The slice of zustand's persist API this module uses. */
-
-/**
- * Detect if a store is using the persist middleware by checking for persist API
- */
-function detectPersist(store) {
-  const persist = store.persist;
-  if (persist && typeof persist.getOptions === "function") {
-    const options = persist.getOptions();
-    return {
-      isPersisted: true,
-      persistName: options?.name,
-      persistApi: persist
-    };
-  }
-  return {
-    isPersisted: false
-  };
-}
-
-// =============================================================================
-// watchStores — Primary, non-intrusive approach
-// =============================================================================
-
-/** Minimal store shape — what Zustand's create() returns */
-
-/**
- * Watch multiple Zustand stores for state changes.
- *
- * This is the recommended, non-intrusive approach. It uses each store's
- * `.subscribe()` method to observe changes from the outside — it never
- * modifies `setState` or any store internals.
- *
- * **Safe by design:** Even if our listener code has a bug, it cannot break
- * your stores. All listener code is wrapped in try/catch.
- *
- * @example
- * ```tsx
- * // In your _layout.tsx or App.tsx — ONE line:
- * import { watchStores } from '@buoy-gg/zustand';
- * import { useCounterStore } from './stores/counter';
- * import { useAuthStore } from './stores/auth';
- * import { useCartStore } from './stores/cart';
- *
- * watchStores({
- *   counterStore: useCounterStore,
- *   authStore: useAuthStore,
- *   cartStore: useCartStore,
- * });
- * ```
- *
- * @param stores - Object mapping store names to Zustand store hooks
- * @returns Cleanup function that removes all subscriptions
- */
-export function watchStores(stores) {
-  const cleanups = [];
-  for (const [name, store] of Object.entries(stores)) {
-    // Skip if already watched
-    const storeAny = store;
-    if (storeAny[WATCHED_SYMBOL]) continue;
-    storeAny[WATCHED_SYMBOL] = true;
-    const {
-      isPersisted,
-      persistName,
-      persistApi
-    } = detectPersist(store);
-
-    // Register the store for overview
-    zustandStateStore.registerStore(name, {
-      getState: store.getState,
-      getInitialState: store.getInitialState,
-      setState: store.setState,
-      subscribe: store.subscribe
-    }, {
-      isPersisted,
-      persistName,
-      // Was detected and thrown away. Without it nothing can re-read the
-      // saved copy after an outside edit — see ZustandStoreInfo.rehydrate.
-      rehydrate: typeof persistApi?.rehydrate === "function" ? () => persistApi.rehydrate() : undefined
-    });
-
-    // The rehydration is a state change nobody's code asked for — the store
-    // simply becomes what the disk said, seconds into the process. Drawn as an
-    // ordinary setState it is the most surprising row in the list and the one
-    // that looks most like a bug, so it gets its own category. Recognised
-    // rather than announced: `hasHydrated()` is still false while the
-    // rehydrating `set` is running, and this listener runs inside it.
-    let sawHydration = false;
-
-    // Subscribe to state changes — completely external, never touches setState
-    const unsubscribe = store.subscribe((state, prevState) => {
-      try {
-        let category;
-        if (!sawHydration && isPersisted) {
-          let hydrating = false;
-          try {
-            hydrating = persistApi?.hasHydrated?.() === false;
-          } catch {
-            // An older persist API without hasHydrated — no worse than before.
-          }
-          if (hydrating) {
-            sawHydration = true;
-            category = "persist";
-          }
-        }
-        zustandStateStore.addStateChange({
-          storeName: name,
-          partial: undefined,
-          // Not available in subscribe-only mode
-          replace: false,
-          prevState,
-          nextState: state,
-          duration: undefined,
-          // Not available in subscribe-only mode
-          category,
-          isPersisted
-        });
-      } catch {
-        // Silently catch — our bug must never propagate into the store
-      }
-    });
-    cleanups.push(() => {
-      unsubscribe();
-      delete store[WATCHED_SYMBOL];
-      zustandStateStore.unregisterStore(name);
-    });
-  }
-  return () => {
-    cleanups.forEach(fn => fn());
-  };
-}
-
-// =============================================================================
-// buoyDevTools — Opt-in middleware (advanced, more detail)
-// =============================================================================
-
-/** Auto-incrementing store name counter for unnamed stores */
-let unnamedCounter = 0;
-
-/**
- * Zustand middleware that instruments a store for Buoy DevTools.
- *
- * This is the advanced approach — it wraps setState to capture:
- * - The partial argument passed to setState
- * - Precise timing of each setState call
- *
- * Use this when you want maximum detail. For most cases, `watchStores()`
- * is simpler and safer.
- *
- * @example
- * ```tsx
- * import { create } from 'zustand';
- * import { buoyDevTools } from '@buoy-gg/zustand';
- *
- * const useCounterStore = create(
- *   buoyDevTools(
- *     (set) => ({
- *       count: 0,
- *       increment: () => set((s) => ({ count: s.count + 1 })),
- *     }),
- *     { name: 'counterStore' }
- *   )
- * );
- * ```
- */
-/**
- * Zustand's own `set` shape (v5 types): with `replace: true` the argument must
- * be a FULL state, so a single `(partial, replace?: boolean)` signature is
- * incompatible in both directions — zustand's set is not assignable to it,
- * which made `create(buoyDevTools(...))` fail to typecheck for every strict-TS
- * user. Mirroring the overloads keeps buoyDevTools a drop-in for `create()`.
- */
-
-/**
- * The store api object zustand hands a middleware, described structurally so
- * this package never has to import zustand's own types (which differ between
- * v4 and v5). `Record<string, unknown>` was wrong here: `StoreApi<T>` has no
- * index signature, so `create(buoyDevTools(...))` failed to typecheck.
- */
-
-export function buoyDevTools(config, options) {
-  return (set, get, api) => {
-    const storeName = options?.name ?? `store-${++unnamedCounter}`;
-    const enabled = options?.enabled !== false;
-
-    // Forwarding a plain `replace?: boolean` through the overloads needs one
-    // widening cast; runtime behavior is unchanged.
-    const rawSet = set;
-    const instrumentedSet = (partial, replace) => {
-      if (!enabled) {
-        return rawSet(partial, replace);
-      }
-      const startTime = performance.now();
-      const prevState = get();
-      rawSet(partial, replace);
-      const nextState = get();
-      const duration = performance.now() - startTime;
-      const resolvedPartial = typeof partial === "function" ? "(updater fn)" : partial;
-      zustandStateStore.addStateChange({
-        storeName,
-        partial: resolvedPartial,
-        replace: replace ?? false,
-        prevState,
-        nextState,
-        duration,
-        // Read back off the registry rather than hardcoded false. Persistence
-        // is a property of the STORE, and this middleware can be wrapped
-        // around a persisted one — every change on such a store used to be
-        // drawn as un-persisted, which is the opposite of what the badge is
-        // for. Registration happens a tick after creation, so a set fired in
-        // that first tick still reports false; the alternative is re-sniffing
-        // `api.persist` on every set.
-        isPersisted: zustandStateStore.getStore(storeName)?.isPersisted ?? false
-      });
-    };
-    const result = config(instrumentedSet, get, api);
-
-    // Register the store after creation
-    setTimeout(() => {
-      if (api[WATCHED_SYMBOL]) return;
-      api[WATCHED_SYMBOL] = true;
-      const {
-        isPersisted,
-        persistName
-      } = detectPersist(api);
-      zustandStateStore.registerStore(storeName, {
-        getState: get,
-        getInitialState: api.getInitialState,
-        // The INSTRUMENTED set, not the raw one.
-        //
-        // This handle is what the tool's own JUMP and RESET STORE call, and
-        // registering the raw `set` here made both of them invisible: the
-        // store changed, the app re-rendered, and nothing appeared in the
-        // log — so the newest row's "state after change" no longer described
-        // the store, and the next diff compared against a state the device
-        // had never been in. The watch path never had this problem, because
-        // it observes the store from outside and cannot be gone around.
-        setState: instrumentedSet,
-        subscribe: api.subscribe
-      }, {
-        isPersisted,
-        persistName
-      });
-    }, 0);
-    return result;
-  };
-}
-
-// =============================================================================
-// Utility
-// =============================================================================
-
-/**
- * Check if a store is being watched/instrumented
- */
-export function isStoreInstrumented(store) {
-  return store[WATCHED_SYMBOL] === true;
-}
+"use strict";import{zustandStateStore as c}from"./zustandStateStore";const d=Symbol.for("@@buoy-zustand/watched");function m(o){const e=o.persist;if(e&&typeof e.getOptions==="function"){const s=e.getOptions();return{isPersisted:true,persistName:s?.name,persistApi:e}}return{isPersisted:false}}export function watchStores(o){const e=[];for(const[s,t]of Object.entries(o)){const r=t;if(r[d])continue;r[d]=true;const{isPersisted:i,persistName:p,persistApi:u}=m(t);c.registerStore(s,{getState:t.getState,getInitialState:t.getInitialState,setState:t.setState,subscribe:t.subscribe},{isPersisted:i,persistName:p,rehydrate:typeof u?.rehydrate==="function"?()=>u.rehydrate():void 0});let f=false;const b=t.subscribe((n,a)=>{try{let S;if(!f&&i){let l=false;try{l=u?.hasHydrated?.()===false}catch{}if(l){f=true;S="persist"}}c.addStateChange({storeName:s,partial:void 0,replace:false,prevState:a,nextState:n,duration:void 0,category:S,isPersisted:i})}catch{}});e.push(()=>{b();delete t[d];c.unregisterStore(s)})}return()=>{e.forEach(s=>s())}}let P=0;export function buoyDevTools(o,e){return(s,t,r)=>{const i=e?.name??`store-${++P}`;const p=e?.enabled!==false;const u=s;const f=(n,a)=>{if(!p){return u(n,a)}const S=performance.now();const l=t();u(n,a);const y=t();const g=performance.now()-S;const h=typeof n==="function"?"(updater fn)":n;c.addStateChange({storeName:i,partial:h,replace:a??false,prevState:l,nextState:y,duration:g,isPersisted:c.getStore(i)?.isPersisted??false})};const b=o(f,t,r);setTimeout(()=>{if(r[d])return;r[d]=true;const{isPersisted:n,persistName:a}=m(r);c.registerStore(i,{getState:t,getInitialState:r.getInitialState,setState:f,subscribe:r.subscribe},{isPersisted:n,persistName:a})},0);return b}}export function isStoreInstrumented(o){return o[d]===true}

package/lib/module/zustand/utils/editableState.js

@@ -1,138 +1 @@
-"use strict";
-
-/**
- * What of a zustand store's state can be EDITED, and how an edit is written.
- *
- * The two zustand facts every rule here follows from:
- *
- * 1. Stores conventionally keep their action functions IN state
- *    (`increment: () => …`). Functions can't be typed into a tree editor and
- *    don't survive serialization, so the editor works on a function-free view
- *    of state.
- * 2. `setState` is either a TOP-LEVEL SHALLOW MERGE (`Object.assign({}, state,
- *    partial)`) or a full replace that deletes every key not present — actions
- *    included. So the editor writes merge-only, always: every edit, however
- *    deep, is expressed as "replace the top-level key(s) that contain it"
- *    ({@link computeMergePartial}), and the two edits a merge cannot express —
- *    removing or renaming a top-level key — are refused rather than silently
- *    not happening.
- *
- * `stripFunctions` lives here (the Time Machine snapshot provider imports it)
- * because capture and editing need the identical answer to "what is this
- * store's data".
- */
-
-/** Bounds every recursive walk over store state. */
-export const STRIP_MAX_DEPTH = 8;
-export function isPlainObjectLike(v) {
-  // Only objects whose own enumerable keys ARE their data. A Map, Set, Date,
-  // RegExp or typed array has none, so walking it with Object.entries turns
-  // it into `{}` — which is how a restored store once got `{}` where the app
-  // kept a Map and crashed on `.values()`. Those go through as-is; the vault's
-  // superjson knows how to carry them.
-  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-}
-
-/** Clone `value` without functions, recording their paths. */
-export function stripFunctions(value, path, fnPaths, seen, depth) {
-  if (typeof value === "function") {
-    fnPaths.push(path);
-    return undefined;
-  }
-  if (typeof value !== "object" || value === null || depth >= STRIP_MAX_DEPTH) {
-    return value;
-  }
-  if (seen.has(value)) return undefined; // cycle — drop the back-reference
-  seen.add(value);
-  if (Array.isArray(value)) {
-    return value.map((item, i) => typeof item === "function" ? (fnPaths.push(`${path}[${i}]`), null) : stripFunctions(item, `${path}[${i}]`, fnPaths, seen, depth + 1));
-  }
-  if (!isPlainObjectLike(value)) return value; // Date/Map/Set/etc. — superjson handles
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    if (typeof v === "function") {
-      fnPaths.push(path ? `${path}.${k}` : k);
-      continue;
-    }
-    out[k] = stripFunctions(v, path ? `${path}.${k}` : k, fnPaths, seen, depth + 1);
-  }
-  return out;
-}
-/**
- * The editor's view of one store's state, with the reasons it may refuse.
- *
- * - A remote mirror that hasn't hydrated yet holds a marker, not state — the
- *   real value is one `getStoreState` round trip away, so "wait" rather than
- *   "can't".
- * - Non-object state (`create(() => 5)`) has no top-level keys, so a merge
- *   write cannot address any part of it. Editing it would require a replace,
- *   which is the destructive path this editor exists to avoid.
- * - A function nested BELOW the top level (rare — the convention keeps actions
- *   at the top) sits inside the very key an edit would rewrite, and a merge
- *   write of that key would silently drop it. Refusing the whole store is
- *   blunt but honest; per-key locks can come later if this ever bites.
- */
-export function editableStateOf(state) {
-  if (isPlainObjectLike(state) && state.__buoyStateOnDevice === true) {
-    return {
-      data: null,
-      fnPaths: [],
-      blockedReason: "Store state hasn't synced from the device yet."
-    };
-  }
-  if (!isPlainObjectLike(state)) {
-    return {
-      data: null,
-      fnPaths: [],
-      blockedReason: "Only stores whose state is a plain object can be edited — " + "a merge write has nothing to address in " + (Array.isArray(state) ? "an array" : `a ${typeof state}`) + "."
-    };
-  }
-  const fnPaths = [];
-  const data = stripFunctions(state, "", fnPaths, new WeakSet(), 0);
-  const nested = fnPaths.filter(p => p.includes(".") || p.includes("["));
-  if (nested.length > 0) {
-    return {
-      data: null,
-      fnPaths,
-      blockedReason: `State keeps a function inside "${nested[0]}" — a merge write of ` + "that key would drop it, so this store can't be edited here."
-    };
-  }
-  return {
-    data,
-    fnPaths,
-    blockedReason: null
-  };
-}
-
-/**
- * Diff an edited draft against the state it was seeded from, as a `setState`
- * MERGE partial: only the top-level keys whose contents changed.
- *
- * Diffed against the SEED, not the live state at save time, on purpose — the
- * partial then carries exactly what the user changed, so a key the app wrote
- * while the editor was open and the user never touched keeps the app's value
- * (per-key last-write-wins, the same contract the draft's own dirtiness uses).
- *
- * Throws on the two edits a merge cannot express, naming the key: a draft
- * that dropped a top-level key (which is also what a raw-JSON rename produces
- * — the old key dropped, a new one added), because `setState(partial, false)`
- * would leave it exactly as it was while the editor showed it gone.
- */
-export function computeMergePartial(seed, draft) {
-  if (!isPlainObjectLike(draft)) {
-    throw new Error("The store's state must stay an object.");
-  }
-  const dropped = Object.keys(seed).filter(k => !(k in draft));
-  if (dropped.length > 0) {
-    throw new Error(`Can't remove top-level ${dropped.length === 1 ? "key" : "keys"} ` + `${dropped.map(k => `"${k}"`).join(", ")} — zustand merge writes ` + "can't delete. Edit the value instead.");
-  }
-  const partial = {};
-  for (const key of Object.keys(draft)) {
-    if (!(key in seed) || JSON.stringify(draft[key]) !== JSON.stringify(seed[key])) {
-      partial[key] = draft[key];
-    }
-  }
-  return partial;
-}
+"use strict";export const STRIP_MAX_DEPTH=8;export function isPlainObjectLike(e){if(typeof e!=="object"||e===null||Array.isArray(e))return false;const t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}export function stripFunctions(e,t,r,o,n){if(typeof e==="function"){r.push(t);return void 0}if(typeof e!=="object"||e===null||n>=STRIP_MAX_DEPTH){return e}if(o.has(e))return void 0;o.add(e);if(Array.isArray(e)){return e.map((i,s)=>typeof i==="function"?(r.push(`${t}[${s}]`),null):stripFunctions(i,`${t}[${s}]`,r,o,n+1))}if(!isPlainObjectLike(e))return e;const c={};for(const[i,s]of Object.entries(e)){if(typeof s==="function"){r.push(t?`${t}.${i}`:i);continue}c[i]=stripFunctions(s,t?`${t}.${i}`:i,r,o,n+1)}return c}export function editableStateOf(e){if(isPlainObjectLike(e)&&e.__buoyStateOnDevice===true){return{data:null,fnPaths:[],blockedReason:"Store state hasn't synced from the device yet."}}if(!isPlainObjectLike(e)){return{data:null,fnPaths:[],blockedReason:"Only stores whose state is a plain object can be edited \u2014 a merge write has nothing to address in "+(Array.isArray(e)?"an array":`a ${typeof e}`)+"."}}const t=[];const r=stripFunctions(e,"",t,new WeakSet,0);const o=t.filter(n=>n.includes(".")||n.includes("["));if(o.length>0){return{data:null,fnPaths:t,blockedReason:`State keeps a function inside "${o[0]}" \u2014 a merge write of that key would drop it, so this store can't be edited here.`}}return{data:r,fnPaths:t,blockedReason:null}}export function computeMergePartial(e,t){if(!isPlainObjectLike(t)){throw new Error("The store's state must stay an object.")}const r=Object.keys(e).filter(n=>!(n in t));if(r.length>0){throw new Error(`Can't remove top-level ${r.length===1?"key":"keys"} ${r.map(n=>`"${n}"`).join(", ")} \u2014 zustand merge writes can't delete. Edit the value instead.`)}const o={};for(const n of Object.keys(t)){if(!(n in e)||JSON.stringify(t[n])!==JSON.stringify(e[n])){o[n]=t[n]}}return o}

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

@@ -1,209 +1 @@
-"use strict";
-
-/**
- * Time Machine snapshot provider for Zustand.
- *
- * Registered into @buoy-gg/shared-ui's stateSnapshotRegistry at module init;
- * consumed by @buoy-gg/time-machine. Neither package imports the other.
- *
- * The Zustand-specific hazard: stores conventionally keep their action
- * functions IN state (`increment: () => ...`). Functions don't survive
- * serialization, and a full `setState(snapshot, true)` replace would wipe
- * them, breaking every `useStore(s => s.increment)` call site. So capture
- * strips functions (recording where they were), and restore re-grafts the
- * LIVE store's functions onto the snapshot before replacing.
- */
-import { classifyPreviewItem, createRestoreScope, emptyRestoreResult, failedRestore, registerStateSnapshotProvider, unionKeys } from "@buoy-gg/shared-ui";
-import { zustandStateStore } from "./zustandStateStore";
-import { isPlainObjectLike, stripFunctions, STRIP_MAX_DEPTH } from "./editableState";
-
-// The function-stripping walk is shared with the store editor (editableState
-// .ts) — capture and editing must agree on what a store's "data" is.
-const MAX_DEPTH = STRIP_MAX_DEPTH;
-/**
- * Copy every function-valued property from the LIVE state onto the restored
- * snapshot (creating containers as needed), so store actions keep working
- * after a full replace.
- */
-function graftFunctions(target, live, seen, depth) {
-  if (!isPlainObjectLike(live) || !isPlainObjectLike(target)) return;
-  if (depth >= MAX_DEPTH || seen.has(live)) return;
-  seen.add(live);
-  for (const [k, v] of Object.entries(live)) {
-    if (typeof v === "function") {
-      target[k] = v;
-    } else if (isPlainObjectLike(v)) {
-      if (!isPlainObjectLike(target[k])) {
-        // Branch missing from the snapshot — only recreate it if it holds
-        // functions somewhere; otherwise the snapshot's absence wins.
-        if (!containsFunction(v, new WeakSet(), depth + 1)) continue;
-        target[k] = {};
-      }
-      graftFunctions(target[k], v, seen, depth + 1);
-    }
-  }
-}
-function containsFunction(value, seen, depth) {
-  if (depth >= MAX_DEPTH || seen.has(value)) return false;
-  seen.add(value);
-  for (const v of Object.values(value)) {
-    if (typeof v === "function") return true;
-    if (isPlainObjectLike(v) && containsFunction(v, seen, depth + 1)) return true;
-  }
-  return false;
-}
-function status() {
-  const count = zustandStateStore.getStores().length;
-  if (count === 0) {
-    return {
-      canCapture: false,
-      canRestore: false,
-      detail: "No Zustand stores registered — pass `zustandStores` to FloatingDevTools or add the buoyDevTools middleware"
-    };
-  }
-  return {
-    canCapture: true,
-    canRestore: true
-  };
-}
-async function capture() {
-  const warnings = [];
-  const stores = {};
-  for (const info of zustandStateStore.getStores()) {
-    const fnPaths = [];
-    let state;
-    try {
-      state = stripFunctions(info.api.getState(), "", fnPaths, new WeakSet(), 0);
-    } catch (e) {
-      warnings.push(`store "${info.name}": capture failed (${String(e)})`);
-      continue;
-    }
-    stores[info.name] = {
-      state,
-      fnPaths
-    };
-  }
-  return {
-    data: {
-      stores
-    },
-    warnings
-  };
-}
-async function restore(data, options) {
-  const snapshot = data;
-  const scope = createRestoreScope(options);
-  const result = emptyRestoreResult();
-  if (!snapshot?.stores) {
-    return failedRestore("empty zustand snapshot");
-  }
-  for (const [name, envelope] of Object.entries(snapshot.stores)) {
-    if (!scope.allows(name)) continue;
-    const info = zustandStateStore.getStore(name);
-    if (!info) {
-      result.skipped.push({
-        id: name,
-        reason: "store not registered (renamed, or created after snapshot?)"
-      });
-      continue;
-    }
-    try {
-      const next = envelope.state;
-      graftFunctions(next, info.api.getState(), new WeakSet(), 0);
-      info.api.setState(next, true);
-      if (info.api.getState() === next) {
-        result.applied += 1;
-      } else {
-        result.warnings.push(`store "${name}": setState did not take effect`);
-        result.ok = false;
-      }
-    } catch (e) {
-      result.skipped.push({
-        id: name,
-        reason: String(e)
-      });
-      result.ok = false;
-    }
-  }
-  const excludedWarning = scope.excludedWarning("store(s)");
-  if (excludedWarning) result.warnings.push(excludedWarning);
-  return result;
-}
-
-/**
- * Per-store restore preview. Both sides are function-stripped through the
- * SAME depth-8 normalizer as capture — diffing snapshot-vs-RAW-live would
- * report every stripped function and every beyond-depth subtree as removed.
- */
-async function previewItems(target, base) {
-  const targetStores = target?.stores ?? {};
-  const liveMode = base === undefined;
-  const baseStores = {};
-  if (liveMode) {
-    for (const info of zustandStateStore.getStores()) {
-      const fnPaths = [];
-      try {
-        baseStores[info.name] = {
-          state: stripFunctions(info.api.getState(), "", fnPaths, new WeakSet(), 0),
-          fnPaths
-        };
-      } catch {
-        // unreadable live store — treated as absent
-      }
-    }
-  } else {
-    Object.assign(baseStores, base?.stores ?? {});
-  }
-  const items = [];
-  const notes = [];
-  let preservedFns = 0;
-  for (const name of unionKeys(baseStores, targetStores)) {
-    const inTarget = name in targetStores;
-    const inBase = name in baseStores;
-    if (!inTarget) {
-      // Restore never touches stores the snapshot doesn't know about.
-      if (liveMode) notes.push(`store "${name}" not in snapshot — untouched`);else items.push({
-        key: name,
-        label: name,
-        verdict: "removed",
-        oldValue: baseStores[name].state
-      });
-      continue;
-    }
-    preservedFns += targetStores[name].fnPaths?.length ?? 0;
-    if (liveMode && !zustandStateStore.getStore(name)) {
-      items.push({
-        key: name,
-        label: name,
-        verdict: "wont-apply",
-        reason: "store not registered (renamed, or created after snapshot?)"
-      });
-      continue;
-    }
-    items.push(classifyPreviewItem({
-      key: name,
-      label: name,
-      oldValue: baseStores[name]?.state,
-      newValue: targetStores[name].state,
-      inOld: inBase,
-      inNew: true
-    }, {
-      tooLargeReason: "store too large to render a diff — restore still applies it"
-    }));
-  }
-  if (preservedFns > 0) {
-    notes.push(`${preservedFns} store action function${preservedFns === 1 ? "" : "s"} preserved on restore (not diffed)`);
-  }
-  return {
-    items,
-    notes
-  };
-}
-registerStateSnapshotProvider({
-  id: "zustand",
-  label: "Zustand",
-  status,
-  capture,
-  restore,
-  previewItems
-});
+"use strict";import{classifyPreviewItem as m,createRestoreScope as y,emptyRestoreResult as k,failedRestore as w,registerStateSnapshotProvider as b,unionKeys as v}from"@buoy-gg/shared-ui";import{zustandStateStore as u}from"./zustandStateStore";import{isPlainObjectLike as d,stripFunctions as l,STRIP_MAX_DEPTH as P}from"./editableState";const p=P;function S(n,r,s,o){if(!d(r)||!d(n))return;if(o>=p||s.has(r))return;s.add(r);for(const[e,a]of Object.entries(r)){if(typeof a==="function"){n[e]=a}else if(d(a)){if(!d(n[e])){if(!g(a,new WeakSet,o+1))continue;n[e]={}}S(n[e],a,s,o+1)}}}function g(n,r,s){if(s>=p||r.has(n))return false;r.add(n);for(const o of Object.values(n)){if(typeof o==="function")return true;if(d(o)&&g(o,r,s+1))return true}return false}function R(){const n=u.getStores().length;if(n===0){return{canCapture:false,canRestore:false,detail:"No Zustand stores registered \u2014 pass `zustandStores` to FloatingDevTools or add the buoyDevTools middleware"}}return{canCapture:true,canRestore:true}}async function O(){const n=[];const r={};for(const s of u.getStores()){const o=[];let e;try{e=l(s.api.getState(),"",o,new WeakSet,0)}catch(a){n.push(`store "${s.name}": capture failed (${String(a)})`);continue}r[s.name]={state:e,fnPaths:o}}return{data:{stores:r},warnings:n}}async function T(n,r){const s=n;const o=y(r);const e=k();if(!s?.stores){return w("empty zustand snapshot")}for(const[c,f]of Object.entries(s.stores)){if(!o.allows(c))continue;const t=u.getStore(c);if(!t){e.skipped.push({id:c,reason:"store not registered (renamed, or created after snapshot?)"});continue}try{const i=f.state;S(i,t.api.getState(),new WeakSet,0);t.api.setState(i,true);if(t.api.getState()===i){e.applied+=1}else{e.warnings.push(`store "${c}": setState did not take effect`);e.ok=false}}catch(i){e.skipped.push({id:c,reason:String(i)});e.ok=false}}const a=o.excludedWarning("store(s)");if(a)e.warnings.push(a);return e}async function W(n,r){const s=n?.stores??{};const o=r===void 0;const e={};if(o){for(const t of u.getStores()){const i=[];try{e[t.name]={state:l(t.api.getState(),"",i,new WeakSet,0),fnPaths:i}}catch{}}}else{Object.assign(e,r?.stores??{})}const a=[];const c=[];let f=0;for(const t of v(e,s)){const i=t in s;const h=t in e;if(!i){if(o)c.push(`store "${t}" not in snapshot \u2014 untouched`);else a.push({key:t,label:t,verdict:"removed",oldValue:e[t].state});continue}f+=s[t].fnPaths?.length??0;if(o&&!u.getStore(t)){a.push({key:t,label:t,verdict:"wont-apply",reason:"store not registered (renamed, or created after snapshot?)"});continue}a.push(m({key:t,label:t,oldValue:e[t]?.state,newValue:s[t].state,inOld:h,inNew:true},{tooLargeReason:"store too large to render a diff \u2014 restore still applies it"}))}if(f>0){c.push(`${f} store action function${f===1?"":"s"} preserved on restore (not diffed)`)}return{items:a,notes:c}}b({id:"zustand",label:"Zustand",status:R,capture:O,restore:T,previewItems:W});