@buoy-gg/time-machine 7.0.40 → 7.0.42

package/lib/module/components/preview/verdictMeta.js

@@ -1,54 +1 @@
-"use strict";
-
-/**
- * One place for the verdict → glyph/color/label mapping. Color is ALWAYS
- * paired with a distinct glyph (true minus U+2212, approx U+2248) — the
- * repo-wide accessibility convention for diff surfaces.
- */
-
-import { tm } from "../../ui/tmTheme";
-export const VERDICT_META = {
-  added: {
-    glyph: "+",
-    color: tm.color.accent,
-    label: "added",
-    applies: true
-  },
-  removed: {
-    glyph: "−",
-    color: tm.color.danger,
-    label: "removed",
-    applies: true
-  },
-  changed: {
-    glyph: "≈",
-    color: tm.color.info,
-    label: "changed",
-    applies: true
-  },
-  "too-large": {
-    glyph: "≈",
-    color: tm.color.warning,
-    label: "changed (large)",
-    applies: true
-  },
-  unchanged: {
-    glyph: "=",
-    color: tm.color.labelTertiary,
-    label: "unchanged",
-    applies: false
-  },
-  "wont-apply": {
-    glyph: "⊘",
-    color: tm.color.warning,
-    label: "won't apply",
-    applies: false
-  },
-  recomputes: {
-    glyph: "↻",
-    color: tm.color.labelTertiary,
-    label: "recomputes",
-    applies: false
-  }
-};
-//# sourceMappingURL=verdictMeta.js.map
+"use strict";import{tm as l}from"../../ui/tmTheme";export const VERDICT_META={added:{glyph:"+",color:l.color.accent,label:"added",applies:true},removed:{glyph:"\u2212",color:l.color.danger,label:"removed",applies:true},changed:{glyph:"\u2248",color:l.color.info,label:"changed",applies:true},"too-large":{glyph:"\u2248",color:l.color.warning,label:"changed (large)",applies:true},unchanged:{glyph:"=",color:l.color.labelTertiary,label:"unchanged",applies:false},"wont-apply":{glyph:"\u2298",color:l.color.warning,label:"won't apply",applies:false},recomputes:{glyph:"\u21BB",color:l.color.labelTertiary,label:"recomputes",applies:false}};

package/lib/module/components/sources.js

@@ -1,73 +1 @@
-"use strict";
-
-/**
- * What Time Machine can capture from, and how healthy each source is.
- *
- * On device these are live registry probes; on Buoy Desktop the same shapes
- * arrive mirrored in the sync payload. Route is folded in as a source even
- * though it is a device capability rather than a registered provider — from
- * the user's side "can this snapshot take me back to that screen?" is the
- * same question as "will my Redux store come back".
- */
-
-import { JotaiIcon, QueryIcon, ReduxIcon, RoutesIcon, StorageIcon, TimeMachineIcon, ZustandIcon } from "@buoy-gg/floating-tools-core";
-import { useSyncExternalStore } from "react";
-import { useSnapshotProviders, useTimeMachineState } from "../hooks/useTimeMachine";
-import { canNavigate } from "../store/routeRestore";
-import { ROUTE_SOURCE_ID } from "../store/sourceIds";
-import { getDisabledSources, subscribeSourceSettings } from "../store/sourceSettings";
-export { ROUTE_SOURCE_ID };
-
-/**
- * Buoy icons paint their knock-out parts with `fill: "bg"`, defaulting to a
- * near-black — so whatever surface an icon sits on has to be handed in as
- * `bgColor` or those cut-outs read as black holes (storage's floppy slot and
- * the route glyph are the two that use it).
- */
-
-const ICONS = {
-  storage: StorageIcon,
-  redux: ReduxIcon,
-  zustand: ZustandIcon,
-  jotai: JotaiIcon,
-  query: QueryIcon,
-  route: RoutesIcon
-};
-export function sourceIcon(id) {
-  return ICONS[id] ?? TimeMachineIcon;
-}
-export function useSourceStatuses() {
-  const {
-    remoteProviders,
-    remoteRoute
-  } = useTimeMachineState();
-  const localProviders = useSnapshotProviders();
-  const disabled = useSyncExternalStore(subscribeSourceSettings, getDisabledSources, getDisabledSources);
-  const providers = remoteProviders ? remoteProviders.map(p => ({
-    ...p,
-    enabled: p.enabled !== false
-  })) : localProviders.map(p => ({
-    id: p.id,
-    label: p.label,
-    ...p.status(),
-    enabled: !disabled.has(p.id)
-  }));
-  const routeAvailable = remoteProviders ? remoteRoute?.available === true : canNavigate();
-  return [...providers, {
-    id: ROUTE_SOURCE_ID,
-    label: "Route",
-    canCapture: routeAvailable,
-    canRestore: routeAvailable,
-    enabled: remoteProviders ? remoteRoute?.enabled !== false : !disabled.has(ROUTE_SOURCE_ID),
-    // No live pathname here: these screens only re-render on store changes,
-    // so a route printed as status goes stale the moment you navigate with
-    // the tool still open. Each restore point shows the route it holds.
-    detail: routeAvailable ? "Recorded with every snapshot — a restore can take you back" : "No Expo Router detected — snapshots record no route"
-  }];
-}
-
-/** A source is "attached" when a snapshot would actually pick it up. */
-export function isAttached(source) {
-  return source.canCapture && source.enabled;
-}
-//# sourceMappingURL=sources.js.map
+"use strict";import{JotaiIcon as u,QueryIcon as d,ReduxIcon as l,RoutesIcon as m,StorageIcon as b,TimeMachineIcon as p,ZustandIcon as S}from"@buoy-gg/floating-tools-core";import{useSyncExternalStore as f}from"react";import{useSnapshotProviders as I,useTimeMachineState as h}from"../hooks/useTimeMachine";import{canNavigate as R}from"../store/routeRestore";import{ROUTE_SOURCE_ID as r}from"../store/sourceIds";import{getDisabledSources as s,subscribeSourceSettings as v}from"../store/sourceSettings";export{r as ROUTE_SOURCE_ID};const x={storage:b,redux:l,zustand:S,jotai:u,query:d,route:m};export function sourceIcon(e){return x[e]??p}export function useSourceStatuses(){const{remoteProviders:e,remoteRoute:a}=h();const c=I();const n=f(v,s,s);const i=e?e.map(o=>({...o,enabled:o.enabled!==false})):c.map(o=>({id:o.id,label:o.label,...o.status(),enabled:!n.has(o.id)}));const t=e?a?.available===true:R();return[...i,{id:r,label:"Route",canCapture:t,canRestore:t,enabled:e?a?.enabled!==false:!n.has(r),detail:t?"Recorded with every snapshot \u2014 a restore can take you back":"No Expo Router detected \u2014 snapshots record no route"}]}export function isAttached(e){return e.canCapture&&e.enabled}

package/lib/module/hooks/useTimeMachine.js

@@ -1,19 +1 @@
-"use strict";
-
-import { useEffect, useState, useSyncExternalStore } from "react";
-import { getStateSnapshotProviders, subscribeToStateSnapshotProviders } from "@buoy-gg/shared-ui";
-import { timeMachineStore } from "../store/timeMachineStore";
-export function useTimeMachineState() {
-  return useSyncExternalStore(timeMachineStore.subscribe, () => timeMachineStore.getState());
-}
-
-/** Registered snapshot providers (query registers late, hence the subscribe). */
-export function useSnapshotProviders() {
-  const [providers, setProviders] = useState(getStateSnapshotProviders);
-  useEffect(() => {
-    setProviders(getStateSnapshotProviders());
-    return subscribeToStateSnapshotProviders(() => setProviders(getStateSnapshotProviders()));
-  }, []);
-  return providers;
-}
-//# sourceMappingURL=useTimeMachine.js.map
+"use strict";import{useEffect as s,useState as i,useSyncExternalStore as n}from"react";import{getStateSnapshotProviders as e,subscribeToStateSnapshotProviders as u}from"@buoy-gg/shared-ui";import{timeMachineStore as r}from"../store/timeMachineStore";export function useTimeMachineState(){return n(r.subscribe,()=>r.getState())}export function useSnapshotProviders(){const[o,t]=i(e);s(()=>{t(e());return u(()=>t(e()))},[]);return o}

package/lib/module/index.js

@@ -1,46 +1 @@
-"use strict";
-
-/**
- * @buoy-gg/time-machine
- *
- * Time Machine — snapshot & restore app state for React Native DevTools.
- *
- * Capture the complete client-side state of the app (storage, Redux,
- * Zustand, Jotai, React Query) as a named snapshot; restore any snapshot in
- * one tap to iterate on multi-step test flows without rebuilding state.
- *
- * PUBLIC API - Only these exports are supported for external use.
- */
-
-import { armPendingRouteRestore as armPendingRouteRestoreOnLoad } from "./store/routeRestore";
-
-// Tool preset for FloatingDevTools
-export { timeMachineToolPreset, createTimeMachineTool } from "./preset";
-
-// Components
-export { TimeMachineModal, TimeMachineToolView } from "./components/TimeMachineModal";
-
-// The floating restore bar (one armed point, one tap to restore)
-export { openTimeMachineFloatingTool, TIME_MACHINE_FLOATING_TOOL_ID } from "./components/floating/TimeMachineFloatingTool";
-
-// External-sync adapter (auto-registered by @buoy-gg/core)
-export { timeMachineSyncAdapter } from "./sync/timeMachineSyncAdapter";
-
-// Programmatic snapshot control (also used by tests / power users)
-export { timeMachineStore, RESTORE_ORDER, SAFETY_SNAPSHOT_NAME } from "./store/timeMachineStore";
-
-// Route capture / restore ("also take me back to the screen I was on")
-export { armPendingRouteRestore, captureCurrentRoute, navigateToRoute, canNavigate as canRestoreRoute } from "./store/routeRestore";
-
-// Per-source on/off switches (the Sources strip); off = never captured or restored
-export { isSourceEnabled, setSourceEnabled, subscribeSourceSettings } from "./store/sourceSettings";
-
-// Buoy Desktop remote-mirror seam
-export { setRemoteTimeMachineHandler, replaceTimeMachineFromSnapshot } from "./store/timeMachineStore";
-// A reload-mode restore that also restores the route can't navigate itself —
-// the JS realm dies with the reload. It parks the route in storage; this picks
-// it up on the next boot. Core requires this module while mounting the
-// floating menu, which is the earliest point we're guaranteed to run.
-// Idempotent: repeated imports (or a host calling it explicitly) arm once.
-armPendingRouteRestoreOnLoad();
-//# sourceMappingURL=index.js.map
+"use strict";import{armPendingRouteRestore as e}from"./store/routeRestore";export{timeMachineToolPreset,createTimeMachineTool}from"./preset";export{TimeMachineModal,TimeMachineToolView}from"./components/TimeMachineModal";export{openTimeMachineFloatingTool,TIME_MACHINE_FLOATING_TOOL_ID}from"./components/floating/TimeMachineFloatingTool";export{timeMachineSyncAdapter}from"./sync/timeMachineSyncAdapter";export{timeMachineStore,RESTORE_ORDER,SAFETY_SNAPSHOT_NAME}from"./store/timeMachineStore";export{armPendingRouteRestore,captureCurrentRoute,navigateToRoute,canNavigate as canRestoreRoute}from"./store/routeRestore";export{isSourceEnabled,setSourceEnabled,subscribeSourceSettings}from"./store/sourceSettings";export{setRemoteTimeMachineHandler,replaceTimeMachineFromSnapshot}from"./store/timeMachineStore";e();

package/lib/module/preset.js

@@ -1,51 +1 @@
-"use strict";
-
-/**
- * Pre-configured Time Machine tool for FloatingDevTools.
- *
- * @example
- * ```tsx
- * import { timeMachineToolPreset } from '@buoy-gg/time-machine';
- *
- * <FloatingDevTools apps={[timeMachineToolPreset]} />
- * ```
- */
-
-import { Platform } from "react-native";
-import { TimeMachineIcon, TIME_MACHINE_ICON_COLOR } from "@buoy-gg/shared-ui";
-import { TimeMachineBody } from "./components/TimeMachineBody";
-import { TimeMachineHeaderActions } from "./components/HeaderActions";
-import { jsx as _jsx } from "react/jsx-runtime";
-export const timeMachineToolPreset = {
-  id: "time-machine",
-  name: "TIME MACHINE",
-  description: "Snapshot & restore app state (storage, stores, query cache)",
-  slot: "both",
-  icon: ({
-    size,
-    color,
-    slot
-  }) => /*#__PURE__*/_jsx(TimeMachineIcon, {
-    size: slot === "dial" && Platform.OS !== "web" ? size * 1.5 : size,
-    color: color || TIME_MACHINE_ICON_COLOR
-  }),
-  component: TimeMachineBody,
-  // Declarative chrome: core's ToolModalShell provides the JsModal, the
-  // managed header (screens override it via useToolHeader) and header search.
-  modal: {
-    subtitle: "snapshot & restore app state",
-    searchable: true,
-    searchPlaceholder: "Filter…",
-    headerActions: /*#__PURE__*/_jsx(TimeMachineHeaderActions, {})
-  }
-};
-
-/** Create a custom Time Machine tool configuration. */
-export function createTimeMachineTool(options = {}) {
-  return {
-    ...timeMachineToolPreset,
-    name: options.name ?? timeMachineToolPreset.name,
-    description: options.description ?? timeMachineToolPreset.description
-  };
-}
-//# sourceMappingURL=preset.js.map
+"use strict";import{Platform as i}from"react-native";import{TimeMachineIcon as a,TIME_MACHINE_ICON_COLOR as s}from"@buoy-gg/shared-ui";import{TimeMachineBody as c}from"./components/TimeMachineBody";import{TimeMachineHeaderActions as n}from"./components/HeaderActions";import{jsx as o}from"react/jsx-runtime";export const timeMachineToolPreset={id:"time-machine",name:"TIME MACHINE",description:"Snapshot & restore app state (storage, stores, query cache)",slot:"both",icon:({size:e,color:t,slot:r})=>o(a,{size:r==="dial"&&i.OS!=="web"?e*1.5:e,color:t||s}),component:c,modal:{subtitle:"snapshot & restore app state",searchable:true,searchPlaceholder:"Filter\u2026",headerActions:o(n,{})}};export function createTimeMachineTool(e={}){return{...timeMachineToolPreset,name:e.name??timeMachineToolPreset.name,description:e.description??timeMachineToolPreset.description}}

package/lib/module/store/routeRestore.js

@@ -1,176 +1 @@
-"use strict";
-
-/**
- * Route capture & restore for Time Machine.
- *
- * A restore point is only half the story: state without the screen you were
- * on drops you into the right data on the wrong page. Every snapshot records
- * the route it was captured on, and a restore can navigate back to it.
- *
- * Two navigation paths, because a "reload" restore kills the JS realm:
- * - LIVE restore: navigate immediately once the sources are applied.
- * - RELOAD restore: persist the route BEFORE the reload is scheduled, then
- *   {@link armPendingRouteRestore} picks it up on the next boot, waits for the
- *   router to come online, and navigates.
- *
- * Everything here is best-effort: apps without expo-router capture no route,
- * so the UI simply never offers the option.
- */
-import { getSafeCurrentRoute, getSafeRouter, persistentStorage } from "@buoy-gg/shared-ui";
-
-/**
- * The route a snapshot was captured on. Only the URL is stored — imperative
- * params passed as objects (`navigate(path, { user })`) are not part of a
- * route and are not restored.
- */
-
-/** How a restore's route leg ended, reported back in the RestoreOutcome. */
-
-/**
- * Same `@react_buoy` family as the snapshot vault, so every tool's
- * isDevToolsStorageKey filter (and therefore every wipe/restore) leaves it
- * alone — a pending route must survive the storage restore that precedes the
- * reload it's waiting on.
- */
-const PENDING_KEY = "@react_buoy_time_machine:pending-route";
-
-/**
- * A pending route older than this belongs to a reload that never happened
- * (the app was killed, the user moved on). Boot-time navigation into a screen
- * someone left minutes ago is worse than doing nothing.
- */
-export const PENDING_ROUTE_TTL_MS = 60_000;
-
-/** How long to wait at boot for the router to come online. */
-const ROUTER_READY_TIMEOUT_MS = 8_000;
-
-/** Settle window after the router appears, so the initial route mounts first. */
-const ROUTER_SETTLE_MS = 250;
-function toSnapshotRoute(location) {
-  return {
-    pathname: location.pathname,
-    href: location.href
-  };
-}
-
-/** The route to stamp on a snapshot being captured, or null when unavailable. */
-export function captureCurrentRoute() {
-  const current = getSafeCurrentRoute();
-  return current ? toSnapshotRoute(current) : null;
-}
-
-/** The live route, for "you're already here" checks in the UI. */
-export function currentRoute() {
-  return captureCurrentRoute();
-}
-
-/** True when imperative navigation is possible on this device. */
-export function canNavigate() {
-  return getSafeRouter() != null;
-}
-
-/**
- * Navigate to a captured route now. Uses `navigate` (not `push`) so restoring
- * the same route twice doesn't stack duplicate screens.
- */
-export function navigateToRoute(route) {
-  const base = {
-    pathname: route.pathname,
-    href: route.href
-  };
-  const router = getSafeRouter();
-  if (!router?.navigate) {
-    return {
-      ...base,
-      status: "unavailable",
-      error: "expo-router is not available on this device"
-    };
-  }
-  try {
-    router.navigate(route.href);
-    return {
-      ...base,
-      status: "navigated"
-    };
-  } catch (e) {
-    return {
-      ...base,
-      status: "failed",
-      error: String(e)
-    };
-  }
-}
-
-// ── Pending route (survives the reload) ──────────────────────────────────────
-
-export async function savePendingRoute(route, snapshotName) {
-  const pending = {
-    ...route,
-    savedAt: Date.now(),
-    ...(snapshotName ? {
-      snapshotName
-    } : {})
-  };
-  await persistentStorage.setItem(PENDING_KEY, JSON.stringify(pending));
-}
-export async function clearPendingRoute() {
-  try {
-    await persistentStorage.removeItem(PENDING_KEY);
-  } catch {
-    // best-effort — a stale key is dropped by the TTL check anyway
-  }
-}
-async function loadPendingRoute() {
-  try {
-    const raw = await persistentStorage.getItem(PENDING_KEY);
-    if (!raw) return null;
-    const parsed = JSON.parse(raw);
-    if (typeof parsed?.href !== "string" || !parsed.href) return null;
-    if (typeof parsed.savedAt !== "number") return null;
-    return {
-      pathname: typeof parsed.pathname === "string" ? parsed.pathname : parsed.href,
-      href: parsed.href,
-      savedAt: parsed.savedAt,
-      snapshotName: typeof parsed.snapshotName === "string" ? parsed.snapshotName : undefined
-    };
-  } catch {
-    return null;
-  }
-}
-let armed = false;
-
-/**
- * Boot-time consumer of a pending route: called once when the package loads
- * (core requires it while mounting the floating menu), it navigates to the
- * route a reload-mode restore asked for and clears the slot.
- *
- * Idempotent and self-limiting — the slot is cleared before navigating, so a
- * route that crashes the app on arrival can't put it in a boot loop.
- */
-export function armPendingRouteRestore() {
-  if (armed) return;
-  armed = true;
-  void (async () => {
-    const pending = await loadPendingRoute();
-    if (!pending) return;
-    // Clear FIRST: whatever happens next, this route is spent.
-    await clearPendingRoute();
-    if (Date.now() - pending.savedAt > PENDING_ROUTE_TTL_MS) return;
-    const deadline = Date.now() + ROUTER_READY_TIMEOUT_MS;
-    while (!canNavigate() && Date.now() < deadline) {
-      await new Promise(r => setTimeout(r, 100));
-    }
-    if (!canNavigate()) return;
-    await new Promise(r => setTimeout(r, ROUTER_SETTLE_MS));
-    navigateToRoute({
-      pathname: pending.pathname,
-      href: pending.href
-    });
-  })();
-}
-
-/** @internal test seam — re-arms the boot-time consumer. */
-export function resetPendingRouteArm() {
-  armed = false;
-}
-//# sourceMappingURL=routeRestore.js.map
+"use strict";import{getSafeCurrentRoute as s,getSafeRouter as i,persistentStorage as r}from"@buoy-gg/shared-ui";const a="@react_buoy_time_machine:pending-route";export const PENDING_ROUTE_TTL_MS=6e4;const f=8e3;const c=250;function p(e){return{pathname:e.pathname,href:e.href}}export function captureCurrentRoute(){const e=s();return e?p(e):null}export function currentRoute(){return captureCurrentRoute()}export function canNavigate(){return i()!=null}export function navigateToRoute(e){const t={pathname:e.pathname,href:e.href};const n=i();if(!n?.navigate){return{...t,status:"unavailable",error:"expo-router is not available on this device"}}try{n.navigate(e.href);return{...t,status:"navigated"}}catch(u){return{...t,status:"failed",error:String(u)}}}export async function savePendingRoute(e,t){const n={...e,savedAt:Date.now(),...t?{snapshotName:t}:{}};await r.setItem(a,JSON.stringify(n))}export async function clearPendingRoute(){try{await r.removeItem(a)}catch{}}async function h(){try{const e=await r.getItem(a);if(!e)return null;const t=JSON.parse(e);if(typeof t?.href!=="string"||!t.href)return null;if(typeof t.savedAt!=="number")return null;return{pathname:typeof t.pathname==="string"?t.pathname:t.href,href:t.href,savedAt:t.savedAt,snapshotName:typeof t.snapshotName==="string"?t.snapshotName:void 0}}catch{return null}}let o=false;export function armPendingRouteRestore(){if(o)return;o=true;void(async()=>{const e=await h();if(!e)return;await clearPendingRoute();if(Date.now()-e.savedAt>PENDING_ROUTE_TTL_MS)return;const t=Date.now()+f;while(!canNavigate()&&Date.now()<t){await new Promise(n=>setTimeout(n,100))}if(!canNavigate())return;await new Promise(n=>setTimeout(n,c));navigateToRoute({pathname:e.pathname,href:e.href})})()}export function resetPendingRouteArm(){o=false}

package/lib/module/store/snapshotVault.js

@@ -1,170 +1 @@
-"use strict";
-
-/**
- * Snapshot persistence for Time Machine.
- *
- * Snapshots live ON-DEVICE in persistentStorage (FileSystem → AsyncStorage →
- * localStorage → Memory fallback): no size caps, survives restarts, and never
- * crosses the 2MB external-sync snapshot budget — only metadata does.
- *
- * Layout: ONE storage key per snapshot (persistentStorage's FileSystem
- * backend writes one file per key, and its multiGet is sequential — a single
- * big key beats many small ones), plus one index key holding the metadata
- * list for cheap listing.
- *
- * Keys use the `@react_buoy` family so every tool's isDevToolsStorageKey
- * filter (including our own storage provider) excludes the vault itself from
- * snapshots — a snapshot must never contain snapshots.
- */
-import { persistentStorage } from "@buoy-gg/shared-ui";
-const INDEX_KEY = "@react_buoy_time_machine:index";
-const SNAP_PREFIX = "@react_buoy_time_machine:snap:";
-export async function loadIndex() {
-  try {
-    const raw = await persistentStorage.getItem(INDEX_KEY);
-    if (!raw) return [];
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-async function saveIndex(metas) {
-  await persistentStorage.setItem(INDEX_KEY, JSON.stringify(metas));
-}
-
-/** Persists the snapshot, stamps meta.sizeBytes, and updates the index. */
-export async function saveSnapshot(snapshot, metas) {
-  const serialized = JSON.stringify(snapshot);
-  snapshot.meta.sizeBytes = serialized.length;
-  await persistentStorage.setItem(SNAP_PREFIX + snapshot.meta.id,
-  // Re-stringify so the persisted copy carries the final sizeBytes.
-  JSON.stringify(snapshot));
-  const next = [snapshot.meta, ...metas.filter(m => m.id !== snapshot.meta.id)];
-  await saveIndex(next);
-  return next;
-}
-export async function loadSnapshot(id) {
-  try {
-    const raw = await persistentStorage.getItem(SNAP_PREFIX + id);
-    return raw ? JSON.parse(raw) : null;
-  } catch {
-    return null;
-  }
-}
-export async function deleteSnapshot(id, metas) {
-  await persistentStorage.removeItem(SNAP_PREFIX + id);
-  const next = metas.filter(m => m.id !== id);
-  await saveIndex(next);
-  return next;
-}
-
-/**
- * Rewrite one snapshot's metadata in BOTH places it lives — the index and the
- * snapshot's own record — so a reload can't resurrect the old value from
- * whichever one was missed.
- */
-async function patchMeta(id, patch, metas) {
-  const apply = m => m.id === id ? patch(m) : m;
-  const next = metas.map(apply);
-  await persistentStorage.setItem(INDEX_KEY, JSON.stringify(next));
-  const stored = await loadSnapshot(id);
-  if (stored) {
-    stored.meta = apply(stored.meta);
-    await persistentStorage.setItem(SNAP_PREFIX + id, JSON.stringify(stored));
-  }
-  return next;
-}
-
-/** Set (or clear with null/empty) the "only these items" restore scope. */
-export function setSnapshotScope(id, scope, metas) {
-  return patchMeta(id, m => {
-    const next = {
-      ...m
-    };
-    if (scope && scope.length > 0) next.scope = scope;else delete next.scope;
-    return next;
-  }, metas);
-}
-
-/**
- * Set (or clear with null/empty) the items a restore of this snapshot must
- * leave alone. Saving exclusions also clears any legacy `scope`: the two
- * answer the same question in opposite directions, and the one the user just
- * chose in the preview wins.
- */
-export function setSnapshotExclusions(id, excludedKeys, metas) {
-  return patchMeta(id, m => {
-    const next = {
-      ...m
-    };
-    delete next.scope;
-    if (excludedKeys && excludedKeys.length > 0) next.excludedKeys = excludedKeys;else delete next.excludedKeys;
-    return next;
-  }, metas);
-}
-
-/** Turn this point's route restore on or off — the row's route toggle. */
-export function setSnapshotRestoreRoute(id, restoreRoute, metas) {
-  return patchMeta(id, m => ({
-    ...m,
-    restoreRoute
-  }), metas);
-}
-
-/** Stamp a restore so the list can say which point you are currently in. */
-export function markSnapshotRestored(id, at, metas) {
-  return patchMeta(id, m => ({
-    ...m,
-    lastRestoredAt: at
-  }), metas);
-}
-
-/**
- * Copy a stored snapshot under a new id and name. The payload is copied by
- * reference into a fresh record — the vault serializes it on write, so the
- * two never share mutable state.
- */
-export async function duplicateSnapshot(id, name, metas) {
-  const stored = await loadSnapshot(id);
-  if (!stored) return null;
-  const copy = {
-    meta: {
-      ...stored.meta,
-      id: `${stored.meta.id}_copy_${Date.now().toString(36)}`,
-      name,
-      createdAt: Date.now(),
-      lastRestoredAt: undefined
-    },
-    data: stored.data
-  };
-  delete copy.meta.lastRestoredAt;
-  return {
-    metas: await saveSnapshot(copy, metas),
-    meta: copy.meta
-  };
-}
-
-/** Read a whole record so a delete can be held in memory and undone. */
-export async function readSnapshot(id) {
-  return loadSnapshot(id);
-}
-
-/** Put a held record back exactly as it was. */
-export async function restoreDeletedSnapshot(stored, metas) {
-  return saveSnapshot(stored, metas);
-}
-export async function renameSnapshot(id, name, metas) {
-  const next = metas.map(m => m.id === id ? {
-    ...m,
-    name
-  } : m);
-  await saveIndex(next);
-  const stored = await loadSnapshot(id);
-  if (stored) {
-    stored.meta.name = name;
-    await persistentStorage.setItem(SNAP_PREFIX + id, JSON.stringify(stored));
-  }
-  return next;
-}
-//# sourceMappingURL=snapshotVault.js.map
+"use strict";import{persistentStorage as s}from"@buoy-gg/shared-ui";const p="@react_buoy_time_machine:index";const i="@react_buoy_time_machine:snap:";export async function loadIndex(){try{const t=await s.getItem(p);if(!t)return[];const e=JSON.parse(t);return Array.isArray(e)?e:[]}catch{return[]}}async function d(t){await s.setItem(p,JSON.stringify(t))}export async function saveSnapshot(t,e){const r=JSON.stringify(t);t.meta.sizeBytes=r.length;await s.setItem(i+t.meta.id,JSON.stringify(t));const n=[t.meta,...e.filter(a=>a.id!==t.meta.id)];await d(n);return n}export async function loadSnapshot(t){try{const e=await s.getItem(i+t);return e?JSON.parse(e):null}catch{return null}}export async function deleteSnapshot(t,e){await s.removeItem(i+t);const r=e.filter(n=>n.id!==t);await d(r);return r}async function c(t,e,r){const n=u=>u.id===t?e(u):u;const a=r.map(n);await s.setItem(p,JSON.stringify(a));const o=await loadSnapshot(t);if(o){o.meta=n(o.meta);await s.setItem(i+t,JSON.stringify(o))}return a}export function setSnapshotScope(t,e,r){return c(t,n=>{const a={...n};if(e&&e.length>0)a.scope=e;else delete a.scope;return a},r)}export function setSnapshotExclusions(t,e,r){return c(t,n=>{const a={...n};delete a.scope;if(e&&e.length>0)a.excludedKeys=e;else delete a.excludedKeys;return a},r)}export function setSnapshotRestoreRoute(t,e,r){return c(t,n=>({...n,restoreRoute:e}),r)}export function markSnapshotRestored(t,e,r){return c(t,n=>({...n,lastRestoredAt:e}),r)}export async function duplicateSnapshot(t,e,r){const n=await loadSnapshot(t);if(!n)return null;const a={meta:{...n.meta,id:`${n.meta.id}_copy_${Date.now().toString(36)}`,name:e,createdAt:Date.now(),lastRestoredAt:void 0},data:n.data};delete a.meta.lastRestoredAt;return{metas:await saveSnapshot(a,r),meta:a.meta}}export async function readSnapshot(t){return loadSnapshot(t)}export async function restoreDeletedSnapshot(t,e){return saveSnapshot(t,e)}export async function renameSnapshot(t,e,r){const n=r.map(o=>o.id===t?{...o,name:e}:o);await d(n);const a=await loadSnapshot(t);if(a){a.meta.name=e;await s.setItem(i+t,JSON.stringify(a))}return n}

package/lib/module/store/sourceIds.js

@@ -1,5 +1 @@
-"use strict";
-
-/** Id of the route "source": a device capability, not a snapshot provider. */
-export const ROUTE_SOURCE_ID = "route";
-//# sourceMappingURL=sourceIds.js.map
+"use strict";export const ROUTE_SOURCE_ID="route";