@buoy-gg/time-machine 7.0.35 → 7.0.38

package/lib/commonjs/index.js

@@ -9,6 +9,18 @@ Object.defineProperty(exports, "RESTORE_ORDER", {
     return _timeMachineStore.RESTORE_ORDER;
   }
 });
+Object.defineProperty(exports, "SAFETY_SNAPSHOT_NAME", {
+  enumerable: true,
+  get: function () {
+    return _timeMachineStore.SAFETY_SNAPSHOT_NAME;
+  }
+});
+Object.defineProperty(exports, "TIME_MACHINE_FLOATING_TOOL_ID", {
+  enumerable: true,
+  get: function () {
+    return _TimeMachineFloatingTool.TIME_MACHINE_FLOATING_TOOL_ID;
+  }
+});
 Object.defineProperty(exports, "TimeMachineModal", {
   enumerable: true,
   get: function () {
@@ -45,12 +57,24 @@ Object.defineProperty(exports, "createTimeMachineTool", {
     return _preset.createTimeMachineTool;
   }
 });
+Object.defineProperty(exports, "isSourceEnabled", {
+  enumerable: true,
+  get: function () {
+    return _sourceSettings.isSourceEnabled;
+  }
+});
 Object.defineProperty(exports, "navigateToRoute", {
   enumerable: true,
   get: function () {
     return _routeRestore.navigateToRoute;
   }
 });
+Object.defineProperty(exports, "openTimeMachineFloatingTool", {
+  enumerable: true,
+  get: function () {
+    return _TimeMachineFloatingTool.openTimeMachineFloatingTool;
+  }
+});
 Object.defineProperty(exports, "replaceTimeMachineFromSnapshot", {
   enumerable: true,
   get: function () {
@@ -63,6 +87,18 @@ Object.defineProperty(exports, "setRemoteTimeMachineHandler", {
     return _timeMachineStore.setRemoteTimeMachineHandler;
   }
 });
+Object.defineProperty(exports, "setSourceEnabled", {
+  enumerable: true,
+  get: function () {
+    return _sourceSettings.setSourceEnabled;
+  }
+});
+Object.defineProperty(exports, "subscribeSourceSettings", {
+  enumerable: true,
+  get: function () {
+    return _sourceSettings.subscribeSourceSettings;
+  }
+});
 Object.defineProperty(exports, "timeMachineStore", {
   enumerable: true,
   get: function () {
@@ -84,8 +120,10 @@ Object.defineProperty(exports, "timeMachineToolPreset", {
 var _routeRestore = require("./store/routeRestore");
 var _preset = require("./preset");
 var _TimeMachineModal = require("./components/TimeMachineModal");
+var _TimeMachineFloatingTool = require("./components/floating/TimeMachineFloatingTool");
 var _timeMachineSyncAdapter = require("./sync/timeMachineSyncAdapter");
 var _timeMachineStore = require("./store/timeMachineStore");
+var _sourceSettings = require("./store/sourceSettings");
 /**
  * @buoy-gg/time-machine
  *
@@ -102,12 +140,16 @@ var _timeMachineStore = require("./store/timeMachineStore");
 
 // Components
 
+// The floating restore bar (one armed point, one tap to restore)
+
 // External-sync adapter (auto-registered by @buoy-gg/core)
 
 // Programmatic snapshot control (also used by tests / power users)
 
 // Route capture / restore ("also take me back to the screen I was on")
 
+// Per-source on/off switches (the Sources strip); off = never captured or restored
+
 // Buoy Desktop remote-mirror seam
 
 // A reload-mode restore that also restores the route can't navigate itself —

package/lib/commonjs/preset.js

@@ -5,9 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createTimeMachineTool = createTimeMachineTool;
 exports.timeMachineToolPreset = void 0;
+var _reactNative = require("react-native");
 var _sharedUi = require("@buoy-gg/shared-ui");
 var _TimeMachineBody = require("./components/TimeMachineBody");
-var _HeaderReloadButton = require("./components/HeaderReloadButton");
+var _HeaderActions = require("./components/HeaderActions");
 var _jsxRuntime = require("react/jsx-runtime");
 /**
  * Pre-configured Time Machine tool for FloatingDevTools.
@@ -27,9 +28,10 @@ const timeMachineToolPreset = exports.timeMachineToolPreset = {
   slot: "both",
   icon: ({
     size,
-    color
+    color,
+    slot
   }) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_sharedUi.TimeMachineIcon, {
-    size: size,
+    size: slot === "dial" && _reactNative.Platform.OS !== "web" ? size * 1.5 : size,
     color: color || _sharedUi.TIME_MACHINE_ICON_COLOR
   }),
   component: _TimeMachineBody.TimeMachineBody,
@@ -39,7 +41,7 @@ const timeMachineToolPreset = exports.timeMachineToolPreset = {
     subtitle: "snapshot & restore app state",
     searchable: true,
     searchPlaceholder: "Filter…",
-    headerActions: /*#__PURE__*/(0, _jsxRuntime.jsx)(_HeaderReloadButton.HeaderReloadButton, {})
+    headerActions: /*#__PURE__*/(0, _jsxRuntime.jsx)(_HeaderActions.TimeMachineHeaderActions, {})
   }
 };
 

package/lib/commonjs/store/sourceIds.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROUTE_SOURCE_ID = void 0;
+/** Id of the route "source": a device capability, not a snapshot provider. */
+const ROUTE_SOURCE_ID = exports.ROUTE_SOURCE_ID = "route";
+//# sourceMappingURL=sourceIds.js.map

package/lib/commonjs/store/sourceSettings.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensureSourceSettingsLoaded = ensureSourceSettingsLoaded;
+exports.getDisabledSources = getDisabledSources;
+exports.isSourceEnabled = isSourceEnabled;
+exports.resetSourceSettingsForTests = resetSourceSettingsForTests;
+exports.setSourceEnabled = setSourceEnabled;
+exports.subscribeSourceSettings = subscribeSourceSettings;
+var _sharedUi = require("@buoy-gg/shared-ui");
+/**
+ * Which sources Time Machine is allowed to touch.
+ *
+ * A source switched off here is left out of every capture and every restore,
+ * from the tool, the bar, the desktop and MCP alike: "off" has to mean off
+ * everywhere, or the one path that forgets it is the one that breaks the app.
+ * The case this exists for is a store whose full replace the app cannot
+ * survive (a Zustand store holding live handles, say): leave it off and the
+ * rest of the state still round-trips.
+ *
+ * Persisted as the set of ids that are OFF, so a source that registers for
+ * the first time tomorrow starts on, and the default is "everything".
+ */
+
+const setting = (0, _sharedUi.definePersistedSetting)(_sharedUi.devToolsStorageKeys.timeMachine.disabledSources(), [], {
+  sanitize: value => Array.isArray(value) ? value.filter(v => typeof v === "string") : []
+});
+let disabled = new Set();
+let loaded = false;
+let loadPromise = null;
+const listeners = new Set();
+const notify = () => listeners.forEach(listener => listener());
+function ensureSourceSettingsLoaded() {
+  if (loaded) return Promise.resolve();
+  if (!loadPromise) {
+    loadPromise = setting.load().then(ids => {
+      // A toggle made while the read was in flight wins over the disk copy.
+      if (disabled.size === 0) {
+        disabled = new Set(ids);
+        notify();
+      }
+    }).finally(() => {
+      loaded = true;
+    });
+  }
+  return loadPromise;
+}
+function subscribeSourceSettings(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** Stable across renders until something changes, for useSyncExternalStore. */
+function getDisabledSources() {
+  return disabled;
+}
+function isSourceEnabled(id) {
+  return !disabled.has(id);
+}
+function setSourceEnabled(id, enabled) {
+  if (enabled === !disabled.has(id)) return;
+  const next = new Set(disabled);
+  if (enabled) next.delete(id);else next.add(id);
+  disabled = next;
+  notify();
+  void setting.save([...next]);
+}
+
+/** Test seam: forget everything without touching storage. */
+function resetSourceSettingsForTests() {
+  disabled = new Set();
+  loaded = false;
+  loadPromise = null;
+}
+//# sourceMappingURL=sourceSettings.js.map

package/lib/commonjs/store/timeMachineStore.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RESTORE_ORDER = void 0;
+exports.SAFETY_SNAPSHOT_NAME = exports.RESTORE_ORDER = void 0;
 exports.replaceTimeMachineFromSnapshot = replaceTimeMachineFromSnapshot;
 exports.setRemoteTimeMachineHandler = setRemoteTimeMachineHandler;
 exports.timeMachineStore = void 0;
@@ -12,6 +12,8 @@ var _sharedUi = require("@buoy-gg/shared-ui");
 var _dataViewer = require("@buoy-gg/shared-ui/dataViewer");
 var _snapshotVault = require("./snapshotVault");
 var _routeRestore = require("./routeRestore");
+var _sourceSettings = require("./sourceSettings");
+var _sourceIds = require("./sourceIds");
 /**
  * Time Machine orchestrator — snapshot CRUD + capture/restore across every
  * registered StateSnapshotProvider (storage, redux, zustand, jotai, query,
@@ -39,7 +41,22 @@ const RESTORE_ORDER = exports.RESTORE_ORDER = ["storage", "redux", "zustand", "j
 function defaultSnapshotName(route) {
   const now = new Date();
   const clock = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
-  return route ? `${route.pathname} · ${clock}` : `Snapshot · ${clock}`;
+  const screen = route ? route.pathname === "/" ? "Home" : route.pathname : null;
+  return screen ? `${screen} · ${clock}` : `Snapshot · ${clock}`;
+}
+
+/**
+ * Two captures in the same minute on the same screen would get the same
+ * default name and be told apart by nothing. Number the repeats.
+ */
+function dedupeName(name, existing) {
+  const taken = new Set(existing.map(m => m.name));
+  if (!taken.has(name)) return name;
+  for (let n = 2; n < 1000; n++) {
+    const candidate = `${name} (${n})`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return name;
 }
 
 /**
@@ -53,6 +70,8 @@ function willRestoreRoute(meta) {
 
 /** Extra knobs a restore accepts beyond mode + exclusions. */
 
+const SAFETY_SNAPSHOT_NAME = exports.SAFETY_SNAPSHOT_NAME = "Before last restore";
+
 /** Provider capability row as mirrored to a remote dashboard. */
 
 /** One side of a preview comparison. */
@@ -144,7 +163,7 @@ class TimeMachineStore {
   }
 
   /** Capture all capturable sources (or a subset) into a named snapshot. */
-  async capture(name, sourceIds) {
+  async capture(name, sourceIds, options) {
     if (remoteHandler) {
       const result = await remoteHandler("capture", {
         name,
@@ -153,11 +172,12 @@ class TimeMachineStore {
       return result.snapshot;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     this.setState({
       busy: "capture"
     });
     try {
-      const providers = (0, _sharedUi.getStateSnapshotProviders)().filter(p => p.status().canCapture && (!sourceIds || sourceIds.includes(p.id)));
+      const providers = (0, _sharedUi.getStateSnapshotProviders)().filter(p => p.status().canCapture && (0, _sourceSettings.isSourceEnabled)(p.id) && (!sourceIds || sourceIds.includes(p.id)));
       const data = {};
       const sources = {};
       for (const provider of providers) {
@@ -174,21 +194,31 @@ class TimeMachineStore {
         }
       }
       // Where the app was when this state was true — restoring can return here.
-      const route = (0, _routeRestore.captureCurrentRoute)();
+      const route = (0, _sourceSettings.isSourceEnabled)(_sourceIds.ROUTE_SOURCE_ID) ? (0, _routeRestore.captureCurrentRoute)() : null;
+      // The safety slot is rolling: the previous one goes before this one lands.
+      let current = this.state.snapshots;
+      if (options?.safety) {
+        for (const stale of current.filter(m => m.safety)) {
+          current = await (0, _snapshotVault.deleteSnapshot)(stale.id, current);
+        }
+      }
       const snapshot = {
         meta: {
           id: nextId(),
-          name: name.trim() || defaultSnapshotName(route),
+          name: options?.safety ? SAFETY_SNAPSHOT_NAME : dedupeName(name.trim() || defaultSnapshotName(route), current),
           createdAt: Date.now(),
           sizeBytes: 0,
           ...(route ? {
             route
           } : {}),
+          ...(options?.safety ? {
+            safety: true
+          } : {}),
           sources
         },
         data
       };
-      const snapshots = await (0, _snapshotVault.saveSnapshot)(snapshot, this.state.snapshots);
+      const snapshots = await (0, _snapshotVault.saveSnapshot)(snapshot, current);
       this.setState({
         snapshots
       });
@@ -211,6 +241,7 @@ class TimeMachineStore {
       return result.snapshot;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const snapshot = {
       meta: {
         id: nextId(),
@@ -248,6 +279,16 @@ class TimeMachineStore {
       return outcome;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
+    // The way back from a mis-tap: capture what is about to be replaced.
+    // Restoring the safety slot itself never rolls it, or Undo would eat
+    // its own target.
+    let safetySnapshotId;
+    if (options?.safetyCapture && !this.state.snapshots.find(m => m.id === id)?.safety) {
+      safetySnapshotId = (await this.capture(SAFETY_SNAPSHOT_NAME, undefined, {
+        safety: true
+      })).id;
+    }
     this.setState({
       busy: "restore"
     });
@@ -260,7 +301,10 @@ class TimeMachineStore {
         mode,
         at: Date.now(),
         willReload: false,
-        results: {}
+        results: {},
+        ...(safetySnapshotId ? {
+          safetySnapshotId
+        } : {})
       };
       if (stored.meta.baseline) {
         // Fresh install: wipe every clearable source, then reload so all
@@ -308,10 +352,10 @@ class TimeMachineStore {
       // No prompt any more: the point carries its own answer, and having a
       // route means wanting it back unless you said otherwise. An explicit
       // option still wins, so MCP and the desktop can force either way.
-      const wantsRoute = options?.restoreRoute ?? willRestoreRoute(stored.meta);
+      const wantsRoute = (0, _sourceSettings.isSourceEnabled)(_sourceIds.ROUTE_SOURCE_ID) && (options?.restoreRoute ?? willRestoreRoute(stored.meta));
       if (mode === "reload") {
         // Storage only; everything in-memory rebuilds after the reload.
-        if (stored.data.storage && (!includeBySource || includeBySource.has("storage"))) {
+        if (stored.data.storage && (0, _sourceSettings.isSourceEnabled)("storage") && (!includeBySource || includeBySource.has("storage"))) {
           outcome.results.storage = await this.restoreSource("storage", stored.data.storage, excludeBySource.get("storage"), includeBySource?.get("storage"));
         }
         // Hand the route to the NEXT boot — this realm is about to die, so the
@@ -343,6 +387,17 @@ class TimeMachineStore {
       for (const sid of sourceIds) {
         // Sources entirely outside the scope are untouched and unreported.
         if (includeBySource && !includeBySource.has(sid)) continue;
+        // A source switched off in Sources is left exactly as it is. Reported
+        // as a warning, not a failure: this is what you asked for.
+        if (!(0, _sourceSettings.isSourceEnabled)(sid)) {
+          outcome.results[sid] = {
+            ok: true,
+            applied: 0,
+            skipped: [],
+            warnings: ["Switched off in Sources; left as it is"]
+          };
+          continue;
+        }
         outcome.results[sid] = await this.restoreSource(sid, stored.data[sid], excludeBySource.get(sid), includeBySource?.get(sid));
       }
       // Navigate LAST — the screen we land on should read the restored state.
@@ -409,6 +464,7 @@ class TimeMachineStore {
       return;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const stored = await (0, _snapshotVault.readSnapshot)(id);
     const snapshots = await (0, _snapshotVault.deleteSnapshot)(id, this.state.snapshots);
     this.setState({
@@ -448,6 +504,7 @@ class TimeMachineStore {
       return;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const snapshots = await (0, _snapshotVault.setSnapshotRestoreRoute)(id, restoreRoute, this.state.snapshots);
     this.setState({
       snapshots
@@ -463,6 +520,7 @@ class TimeMachineStore {
       return result?.snapshot ?? null;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const source = this.state.snapshots.find(s => s.id === id);
     if (!source) return null;
     const result = await (0, _snapshotVault.duplicateSnapshot)(id, `${source.name} copy`, this.state.snapshots);
@@ -481,6 +539,7 @@ class TimeMachineStore {
       return;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const snapshots = await (0, _snapshotVault.renameSnapshot)(id, name, this.state.snapshots);
     this.setState({
       snapshots
@@ -501,6 +560,7 @@ class TimeMachineStore {
       return;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const snapshots = await (0, _snapshotVault.setSnapshotScope)(id, scope, this.state.snapshots);
     this.setState({
       snapshots
@@ -521,6 +581,7 @@ class TimeMachineStore {
       return;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const snapshots = await (0, _snapshotVault.setSnapshotExclusions)(id, excludedKeys, this.state.snapshots);
     this.setState({
       snapshots
@@ -638,6 +699,7 @@ class TimeMachineStore {
       return;
     }
     await this.ensureLoaded();
+    await (0, _sourceSettings.ensureSourceSettingsLoaded)();
     const runId = ++this.previewRunId;
     this.setState({
       preview: {
@@ -669,6 +731,9 @@ class TimeMachineStore {
       const sourceIds = isBaseline ? (0, _sharedUi.getStateSnapshotProviders)().filter(p => p.clear).map(p => p.id) : [...RESTORE_ORDER.filter(sid => sid in rightData), ...Object.keys(rightData).filter(sid => !RESTORE_ORDER.includes(sid))];
       const sources = [];
       for (const sid of sourceIds) {
+        // Off in Sources: a restore will not touch it, so there is nothing
+        // to preview.
+        if (!(0, _sourceSettings.isSourceEnabled)(sid)) continue;
         // Yield a frame between sources — verdict passes are bounded but a
         // five-source build shouldn't run as one synchronous block.
         await new Promise(r => setTimeout(r, 0));

package/lib/commonjs/sync/timeMachineSyncAdapter.js

@@ -9,6 +9,8 @@ var _dataViewer = require("@buoy-gg/shared-ui/dataViewer");
 var _timeMachineStore = require("../store/timeMachineStore");
 var _snapshotVault = require("../store/snapshotVault");
 var _routeRestore = require("../store/routeRestore");
+var _sourceSettings = require("../store/sourceSettings");
+var _sourceIds = require("../store/sourceIds");
 /**
  * Sync adapter for the Time Machine tool, consumed by @buoy-gg/external-sync's
  * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
@@ -31,7 +33,8 @@ function providerStatuses() {
       label: p.label,
       canCapture: s.canCapture,
       canRestore: s.canRestore,
-      detail: s.detail
+      detail: s.detail,
+      enabled: (0, _sourceSettings.isSourceEnabled)(p.id)
     };
   });
 }
@@ -51,6 +54,7 @@ function metadata() {
     // a dashboard has no router of its own to probe, so it's mirrored here.
     route: {
       available: (0, _routeRestore.canNavigate)(),
+      enabled: (0, _sourceSettings.isSourceEnabled)(_sourceIds.ROUTE_SOURCE_ID),
       ...(current ? {
         current: current.href
       } : {})

package/lib/commonjs/ui/SwipeActionsRow.js

@@ -96,11 +96,20 @@ function SwipeActionsRow({
   (0, _react.useEffect)(() => () => {
     if (closeOpenRow === close) closeOpenRow = null;
   }, [close]);
+
+  // The row is glass now, so the actions can't hide under it: they fade in
+  // with the first points of the drag instead of sitting there at rest.
+  const actionOpacity = translateX.interpolate({
+    inputRange: [-24, 0],
+    outputRange: [1, 0],
+    extrapolate: "clamp"
+  });
   return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
     style: styles.clip,
-    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Animated.View, {
       style: [styles.actionLayer, {
-        width: openWidth
+        width: openWidth,
+        opacity: actionOpacity
       }],
       children: actions.map(action => /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
         style: [styles.action, action.background ? {
@@ -159,7 +168,9 @@ const styles = _reactNative.StyleSheet.create({
     fontWeight: "600",
     letterSpacing: _tmTheme.tm.tracking.control
   },
-  // Opaque so the red action never bleeds through the row it sits under.
+  // Glass, like the card it sits in. The actions underneath are faded out
+  // at rest (see actionOpacity), which is what keeps them from bleeding
+  // through a translucent row.
   content: {
     backgroundColor: _tmTheme.tm.color.group
   }

package/lib/commonjs/ui/primitives.js

@@ -147,6 +147,8 @@ const styles = _reactNative.StyleSheet.create({
     marginHorizontal: _tmTheme.tm.gutter,
     backgroundColor: _tmTheme.tm.color.group,
     borderRadius: _tmTheme.tm.radius.group,
+    borderWidth: 1,
+    borderColor: _tmTheme.tm.color.groupBorder,
     overflow: "hidden"
   },
   separator: {

package/lib/commonjs/ui/tmTheme.js

@@ -9,7 +9,7 @@ var _sharedUi = require("@buoy-gg/shared-ui");
  * Time Machine design tokens — the "modern" surface language.
  *
  * A grouped-inset list system (iOS Settings shape): one dark sheet, rounded
- * grouped cards holding hairline-separated rows, uppercase section labels
+ * glass cards holding hairline-separated rows, uppercase section labels
  * outside the cards, and explanatory footnotes under them.
  *
  * COLOR COMES FROM the shared `night` palette (ui/night/nightTheme.ts) — not
@@ -39,15 +39,28 @@ const tm = exports.tm = {
      * without the list reading through the CTA.
      */
     sheet: "rgba(5, 5, 5, 0.92)",
-    /** A grouped card. */
-    group: _sharedUi.night.color.surface,
+    /**
+     * A grouped card: night glass, so the star field behind the sheet shows
+     * through every card the way it does through the header chips. Cards
+     * take `groupBorder` as a hairline, or the glass reads as a smudge.
+     */
+    group: _sharedUi.night.color.glass,
+    groupBorder: _sharedUi.night.color.glassBorder,
     /** Row press / hover wash on top of a group. */
-    rowPressed: _sharedUi.night.color.surfaceElevated,
+    rowPressed: _sharedUi.night.color.glassElevated,
     /** Hairline between rows, inset from the left like iOS. */
     separator: _sharedUi.night.color.separator,
     /** Neutral control fill (icon discs, chips, round buttons). */
-    fill: _sharedUi.night.color.surfaceElevated,
+    fill: _sharedUi.night.color.glassElevated,
     fillStrong: _sharedUi.night.color.fillTertiary,
+    /** Opaque ring around a badge on a glass card (the sheet's own color). */
+    ring: _sharedUi.night.color.bg,
+    /**
+     * Opaque disc behind a Buoy icon. The icons paint their knock-outs in
+     * the color they are handed, so a translucent fill turns a floppy disk
+     * into a yellow square. Stays solid on purpose.
+     */
+    disc: _sharedUi.night.color.surfaceElevated,
     label: _sharedUi.night.color.text,
     labelSecondary: _sharedUi.night.color.textSecondary,
     labelTertiary: _sharedUi.night.color.textTertiary,

package/lib/module/components/HeaderActions.js

@@ -0,0 +1,85 @@
+"use strict";
+
+/**
+ * The tool's header actions, in Network's header language: labeled
+ * dark-glass chips. "Action bar" is named for the thing it opens, the
+ * floating action bar over the app, and takes the accent ink as the one
+ * action a newcomer has to find. Reload is the plain JS reload.
+ *
+ * Action bar puts a restore point on the floating bar and gets the modal out
+ * of the way. The preview screen passes the point it is showing as `armId`,
+ * so opening it from there arms that point; the list leaves it to the
+ * default rule.
+ */
+import { StyleSheet, Text, TouchableOpacity, View } from "react-native";
+import { night } from "@buoy-gg/shared-ui";
+import { useToolHost } from "@buoy-gg/core";
+import { HeaderReloadButton } from "./HeaderReloadButton";
+import { openTimeMachineFloatingTool } from "./floating/TimeMachineFloatingTool";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function HeaderBarButton({
+  armId
+}) {
+  const host = useToolHost();
+  const onPress = () => {
+    openTimeMachineFloatingTool(armId);
+    // Same move as Network: the bar is for using the app, so the modal
+    // minimizes to the dock instead of covering the screen the bar controls.
+    host.minimize();
+  };
+  return /*#__PURE__*/_jsxs(TouchableOpacity, {
+    style: styles.labeledChip,
+    onPress: onPress,
+    accessibilityLabel: "Open the floating action bar over the app",
+    accessibilityRole: "button",
+    testID: "time-machine-header-bar",
+    children: [/*#__PURE__*/_jsx(View, {
+      style: styles.glyph
+    }), /*#__PURE__*/_jsx(Text, {
+      style: styles.label,
+      children: "Action bar"
+    })]
+  });
+}
+export function TimeMachineHeaderActions({
+  armId
+}) {
+  return /*#__PURE__*/_jsxs(View, {
+    style: styles.row,
+    children: [/*#__PURE__*/_jsx(HeaderBarButton, {
+      armId: armId
+    }), /*#__PURE__*/_jsx(HeaderReloadButton, {})]
+  });
+}
+const styles = StyleSheet.create({
+  row: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8
+  },
+  labeledChip: {
+    height: 32,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 6,
+    paddingHorizontal: 10,
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: night.color.border,
+    backgroundColor: night.color.buttonSurface
+  },
+  // A small strip outline: the thing the button opens.
+  glyph: {
+    width: 14,
+    height: 8,
+    borderRadius: 3,
+    borderWidth: 1.5,
+    borderColor: night.color.accent
+  },
+  label: {
+    fontSize: 11,
+    fontWeight: "700",
+    color: night.color.accent
+  }
+});
+//# sourceMappingURL=HeaderActions.js.map