@buoy-gg/shared-ui 7.0.34 → 7.0.36

package/lib/module/dataViewer/tree/TreeDiffViewer.js

@@ -19,7 +19,7 @@ import React, { useMemo, useState, useEffect, useRef } from "react";
 import { View, Text, ScrollView, StyleSheet, TouchableOpacity } from "react-native";
 import { gameUIColors, night } from "@buoy-gg/shared-ui";
 import { isAbsent } from "../lineDiff.js";
-
+import { monoFont } from "../../ui/fonts.js";
 // ============================================
 // TYPES & INTERFACES
 // ============================================
@@ -785,16 +785,16 @@ const styles = StyleSheet.create({
   summaryIcon: {
     fontSize: 14,
     fontWeight: "700",
-    fontFamily: "monospace"
+    fontFamily: monoFont
   },
   summaryCount: {
     fontSize: 13,
     fontWeight: "600",
-    fontFamily: "monospace"
+    fontFamily: monoFont
   },
   summaryLabel: {
     fontSize: 11,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     opacity: 0.9
   },
   scrollView: {
@@ -818,7 +818,7 @@ const styles = StyleSheet.create({
   },
   lineNumberText: {
     fontSize: 11,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     textAlign: "right"
   },
   marker: {
@@ -830,7 +830,7 @@ const styles = StyleSheet.create({
   },
   markerText: {
     fontSize: 12,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     fontWeight: "600"
   },
   content: {
@@ -851,33 +851,33 @@ const styles = StyleSheet.create({
   },
   expandIcon: {
     fontSize: 11,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     fontWeight: "600"
   },
   colon: {
     fontSize: 12,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     marginHorizontal: 4
   },
   key: {
     fontSize: 11,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     fontWeight: "500",
     opacity: 0.9
   },
   value: {
     fontSize: 11,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     maxWidth: "80%"
   },
   arrow: {
     fontSize: 12,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     fontWeight: "600"
   },
   badge: {
     fontSize: 11,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     fontWeight: "600",
     marginLeft: 8
   },
@@ -889,19 +889,19 @@ const styles = StyleSheet.create({
   },
   emptyIcon: {
     fontSize: 48,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     opacity: 0.2,
     marginBottom: 12
   },
   emptyTitle: {
     fontSize: 14,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     fontWeight: "600",
     marginBottom: 4
   },
   emptySubtitle: {
     fontSize: 12,
-    fontFamily: "monospace",
+    fontFamily: monoFont,
     opacity: 0.6
   }
 });

package/lib/module/hooks/safe-area-impl.js

@@ -3,7 +3,7 @@
 /**
  * Auto-generated safe area implementation
  * Detected: none
- * Generated at: 2026-09-04T01:21:28.486Z
+ * Generated at: 2026-09-10T21:40:50.832Z
  *
  * DO NOT EDIT - This file is generated by scripts/detect-safe-area.js
  *

package/lib/module/icons/index.js

@@ -28,8 +28,35 @@ export { WifiCircuitIcon } from "./WifiCircuitIcon.js";
 export { RouteMapIcon, RouteIcon, NavigationIcon } from "./RouteMapIcon.js";
 export { StackPulseIcon, RenderPulseIcon, HighlightUpdatesIcon } from "./StackPulseIcon.js";
 export { RenderCountIcon } from "./RenderCountIcon.js";
-export { BenchmarkIcon } from "./BenchmarkIcon.js";
+// The hand-drawn stopwatch is legacy; `BenchmarkIcon` is the BIF artwork (same on every port).
+export { BenchmarkIcon as BenchmarkLegacyIcon } from "./BenchmarkIcon.js";
 export { IconBackground } from "./IconBackground.js";
 
 // Export lucide icons
-export * from "./lucide-icons.js";
+export * from "./lucide-icons.js";
+
+// The lucide glyph tier, drawn from shared/icons/glyphs/*.json — the SAME data
+// the Flutter and Swift renderers read. React Native used to carry a second,
+// hand-drawn copy of these icons (`./lucide-icons`), so `Globe` was one drawing
+// on RN and another on every port; the cross-framework parity sheet measured
+// `icons/globe-24` 10.8 % apart on both. These explicit exports shadow the
+// `export * from "./lucide-icons"` above (the same trick `WifiBifIcon` uses),
+// so one edit to a JSON now moves all three frameworks. The hand-drawn
+// originals stay reachable as `<Name>Icon` from `./lucide-icons`.
+//
+// `Pin` is deliberately NOT here: RN's pin carries an extra `active` prop that
+// stands it upright, which the glyph data has no way to express (the ports draw
+// the resting pose only). `WifiIcon` stays lucide for the same kind of reason —
+// see the `WifiBifIcon` note below.
+export { ActivityGlyph as Activity, AlertCircleGlyph as AlertCircle, AlertTriangleGlyph as AlertTriangle, BookmarkGlyph as Bookmark, BoxGlyph as Box, BugGlyph as Bug, CheckCircleGlyph as CheckCircle, CheckGlyph as Check, ChevronDownGlyph as ChevronDown, ChevronLeftGlyph as ChevronLeft, ChevronRightGlyph as ChevronRight, ChevronUpGlyph as ChevronUp, ClockGlyph as Clock, CopyGlyph as Copy, DatabaseGlyph as Database, DockBottomGlyph as DockBottom, DownloadGlyph as Download, Edit3Glyph as Edit3, EyeOffGlyph as EyeOff, EyeGlyph as Eye, FileJsonGlyph as FileJson, FileTextGlyph as FileText, FilmGlyph as Film, FilterGlyph as Filter, FlaskConicalGlyph as FlaskConical, FloatWindowGlyph as FloatWindow, GitBranchGlyph as GitBranch, GlobeGlyph as Globe, HashGlyph as Hash, HomeGlyph as Home, ImageGlyph as Image, InfoGlyph as Info, KeyGlyph as Key, LayersGlyph as Layers, LinkGlyph as Link, LockGlyph as Lock, MinusGlyph as Minus, MusicGlyph as Music, NavigationGlyph as Navigation, PaletteGlyph as Palette, PauseGlyph as Pause, PlayGlyph as Play, PlusGlyph as Plus, PowerGlyph as Power, RefreshCwGlyph as RefreshCw, SearchGlyph as Search, ServerGlyph as Server, SettingsGlyph as Settings,
+// Solid gear (brand tier, so a caller's strokeWidth can't blow the hole open).
+SettingsSolidIcon as SettingsSolid, ShieldGlyph as Shield, Trash2Glyph as Trash2,
+// RN aliases `Trash` onto `Trash2Icon`; the glyph has to shadow both.
+Trash2Glyph as Trash, UnlockGlyph as Unlock, UploadGlyph as Upload, UserGlyph as User, WifiGlyph as Wifi, XCircleGlyph as XCircle, XGlyph as X, ZapGlyph as Zap } from "@buoy-gg/floating-tools-core";
+
+// Every BIF brand icon the dial can show, re-exported so the parity sheet (and tools) render
+// the same artwork by name — see shared/parity/specimens.json `icons/bif-*`.
+export { SentryIcon, EventsIcon, RoutesIcon, RoutePinIcon, RoutePathIcon, RouteDotIcon, RouteTwoPinsIcon, CameraIcon, HighlightIcon, ReduxIcon, StorageIcon, AskBuoyIcon, HighlighterIcon, QueryIcon, ScenariosIcon } from "@buoy-gg/floating-tools-core";
+// `WifiIcon` here stays the lucide glyph (react-query's online toggle); the BIF wifi ships as
+// `WifiBifIcon`. `BenchmarkIcon` IS the BIF stopwatch since 2026-09-04 (perf-monitor's dial icon).
+export { WifiIcon as WifiBifIcon, BenchmarkIcon, BENCHMARK_ICON_COLOR } from "@buoy-gg/floating-tools-core";

package/lib/module/index.js

@@ -5,6 +5,10 @@ export * from "./ui/index.js";
 
 // Store base classes
 export * from "./stores/index.js";
+export * from "./sync/keyedArrays.js";
+export * from "./sync/valueShape.js";
+export * from "./sync/valuePath.js";
+export * from "./sync/typedEdit.js";
 export * from "./sync/wireBudget.js";
 export * from "./sync/wireForm.js";
 export * from "./sync/toolSyncAdapter.js";

package/lib/module/license/FreeAccountPrompt.js

@@ -19,7 +19,7 @@ import { buoyColors } from "../ui/gameUI/constants/gameUIColors.js";
 import { Check, Copy, X } from "../icons/lucide-icons.js";
 import { copyToClipboard } from "../clipboard/index.js";
 import { openPricing } from "./openPricing.js";
-
+import { monoFont } from "../ui/fonts.js";
 /** The one thing a reader has to be able to act on. */
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export const LOGIN_COMMAND = "npx buoy login";
@@ -155,7 +155,7 @@ const styles = StyleSheet.create({
     fontSize: 14,
     fontWeight: "600",
     color: buoyColors.text,
-    fontFamily: "monospace"
+    fontFamily: monoFont
   },
   reassure: {
     fontSize: 12,

package/lib/module/license/LicenseEntryModal.js

@@ -9,12 +9,12 @@
  */
 
 import React, { useCallback } from "react";
-import { View, Text, TouchableOpacity, StyleSheet, Modal, Platform } from "react-native";
+import { View, Text, TouchableOpacity, StyleSheet, Modal } from "react-native";
 import { absoluteFill } from "../utils/absoluteFill.js";
 import { macOSColors } from "../ui/gameUI/constants/macOSDesignSystemColors.js";
 import { openPricing, isWeb } from "./openPricing.js";
 import { X, Key, Link, FileCode, Copy } from "../icons/lucide-icons.js";
-
+import { monoFont } from "../ui/fonts.js";
 // For clipboard functionality
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 let Clipboard = null;
@@ -339,7 +339,7 @@ const styles = StyleSheet.create({
   },
   codeText: {
     fontSize: 11,
-    fontFamily: Platform.OS === "ios" ? "Menlo" : "monospace",
+    fontFamily: monoFont,
     lineHeight: 18,
     color: macOSColors.text.primary
   },

package/lib/module/sync/keyedArrays.js

@@ -0,0 +1,204 @@
+"use strict";
+
+/**
+ * Id-addressed list edits — one implementation, shared by every adapter that
+ * takes a merge patch.
+ *
+ * WHY. Resending a whole array is correct only when the caller has SEEN the
+ * whole array, and reads are capped. Measured with a 20-item list truncated to
+ * 5 (`pnpm ai:array --truncate=5`): the whole-array form scored 0/9 across three
+ * models — two refused outright, and one silently sent back only the 5 items it
+ * had been shown, destroying the other 15. Addressed edits scored 9/9.
+ *
+ * It also makes mass deletion impossible BY OMISSION: an addressed edit can only
+ * remove ids it names. Sending a real array still replaces the list, which is
+ * how a caller deliberately empties one.
+ *
+ * This lives here rather than in one adapter because react-query, zustand and
+ * network all take merge patches, and a second copy of a data-destroying safety
+ * rule is a copy that drifts.
+ */
+const isPlainObject = v => typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** Fields we will treat as an item's stable identity, best first. */
+const ID_FIELDS = ["id", "lineId", "key", "uuid", "_id", "slug", "name"];
+
+/**
+ * The field that identifies items in this list, or undefined if there isn't one.
+ *
+ * Every item must carry it, and every value must be a distinct string/number —
+ * a duplicated id would make an addressed edit ambiguous, and silently picking
+ * the first match is exactly the kind of "helpful" guess that loses data.
+ */
+export function identityField(items) {
+  if (!items.length || !items.every(isPlainObject)) return undefined;
+  const first = items[0];
+  for (const f of ID_FIELDS) {
+    if (!(f in first)) continue;
+    const values = items.map(it => it[f]);
+    const usable = values.every(v => typeof v === "string" || typeof v === "number");
+    if (!usable) continue;
+    if (new Set(values.map(String)).size !== values.length) continue;
+    return f;
+  }
+  return undefined;
+}
+
+/**
+ * The identity an ADDED item should carry.
+ *
+ * `Object.entries` hands back STRING keys, so `{"9901": {id: 9901, …}}` was
+ * written as `{id: "9901"}` — the caller's own numeric id replaced by text, and
+ * then refused by the typed-edit guard as `[2].id: number → string`. The caller
+ * recovers by resending the WHOLE array, which is exactly the truncation-unsafe
+ * move this module exists to prevent. Measured on a live QA run: one added
+ * offer cost a refusal, a full-list retransmission and 35 seconds.
+ *
+ * So the id the caller WROTE wins. With no id in the body, the key is coerced
+ * to the type the existing items use, and only when the text round-trips
+ * exactly: "007" is not 7, and inventing that identity is worse than a refusal
+ * the caller can read.
+ */
+function identityForAdd(current, idField, key, edit) {
+  const supplied = edit[idField];
+  if (typeof supplied === "string" || typeof supplied === "number") {
+    // An item whose id disagrees with the address it was sent under is
+    // ambiguous — either could be the one the caller meant. Say so rather than
+    // silently picking one and writing an item nobody asked for.
+    if (String(supplied) !== key) {
+      return {
+        ok: false,
+        error: `The new item is addressed as \`${key}\` but carries \`${idField}\`: ${JSON.stringify(supplied)}. Use the same value for both — address it by the id it carries.`
+      };
+    }
+    return {
+      ok: true,
+      value: supplied
+    };
+  }
+  const numericList = current.every(it => typeof it[idField] === "number");
+  if (numericList && key.trim() !== "" && String(Number(key)) === key) {
+    return {
+      ok: true,
+      value: Number(key)
+    };
+  }
+  return {
+    ok: true,
+    value: key
+  };
+}
+
+/**
+ * Let a caller address list items by their own id instead of resending the list.
+ *
+ *   { lines: { "seed-1": { qty: 5 } } }   change one field of one item
+ *   { lines: { "seed-2": null } }         remove that item
+ *   { lines: { "new-1": { …all fields… } } }  append (id not already present)
+ *
+ * WHY THIS EXISTS. Resending the whole array is correct only when the caller has
+ * SEEN the whole array, and reads are capped — so on a long list the honest
+ * agents refuse and the careless ones send back only the items they were shown,
+ * silently destroying the rest. Measured: with a 20-item bag truncated to 5, the
+ * whole-array form scored 0/9 across three models and one of them deleted 15
+ * lines without a word. Addressed edits scored 9/9. (`pnpm ai:array`.)
+ *
+ * It also makes mass deletion impossible BY OMISSION: `lines: []` empties a bag,
+ * but a keyed edit can only remove ids it names.
+ *
+ * Returns the patch with keyed objects expanded into real arrays, so everything
+ * downstream — the typed-edit guard, the receipt, the store write — is unchanged
+ * and keeps all of its protections.
+ */
+export function expandKeyedArrays(current, patch, path = "", notes = []) {
+  if (Array.isArray(current) && isPlainObject(patch)) {
+    const idField = identityField(current);
+    if (!idField) {
+      // No stable identity: leave it alone and let the normal guard report the
+      // object-vs-array type change, which says something truer than we could.
+      return {
+        patch,
+        notes
+      };
+    }
+    const byId = new Map(current.map(it => [String(it[idField]), it]));
+    const next = current.slice();
+    let removed = 0;
+    let changed = 0;
+    let added = 0;
+    for (const [id, edit] of Object.entries(patch)) {
+      const i = next.findIndex(it => String(it[idField]) === id);
+      if (edit === null) {
+        if (i === -1) return {
+          patch,
+          notes
+        };
+        next.splice(i, 1);
+        removed++;
+      } else if (i === -1) {
+        if (!isPlainObject(edit)) return {
+          patch,
+          notes
+        };
+        const identity = identityForAdd(current, idField, id, edit);
+        if (!identity.ok) {
+          return {
+            patch,
+            notes,
+            error: identity.error
+          };
+        }
+        next.push({
+          ...edit,
+          [idField]: identity.value
+        });
+        added++;
+      } else {
+        const merged = expandKeyedArrays(byId.get(id), edit, `${path}[${id}]`, notes);
+        if (merged.error) return {
+          patch,
+          notes,
+          error: merged.error
+        };
+        const base = next[i];
+        next[i] = isPlainObject(base) && isPlainObject(merged.patch) ? {
+          ...base,
+          ...merged.patch
+        } : merged.patch;
+        changed++;
+      }
+    }
+    notes.push(`${path || "(root)"}: addressed by \`${idField}\` — ${changed} changed, ${added} added, ${removed} removed, ${next.length} item(s) remain`);
+    return {
+      patch: next,
+      notes
+    };
+  }
+  if (isPlainObject(current) && isPlainObject(patch)) {
+    const outPatch = {};
+    for (const [k, v] of Object.entries(patch)) {
+      const p = path ? `${path}.${k}` : k;
+      if (!(k in current)) {
+        outPatch[k] = v;
+        continue;
+      }
+      const inner = expandKeyedArrays(current[k], v, p, notes);
+      // A refusal deep in the tree is the whole patch's refusal: writing the
+      // rest of it would apply half of what the caller asked for.
+      if (inner.error) return {
+        patch,
+        notes,
+        error: inner.error
+      };
+      outPatch[k] = inner.patch;
+    }
+    return {
+      patch: outPatch,
+      notes
+    };
+  }
+  return {
+    patch,
+    notes
+  };
+}

package/lib/module/sync/toolAttention.test.js

@@ -0,0 +1,50 @@
+"use strict";
+
+/**
+ * The attention badge seam: a tool says "I need you" and the rail hears it.
+ */
+import { describe, expect, it, vi } from "vitest";
+import { getToolAttention, setToolAttention, subscribeToolAttention } from "./toolUiBridge.js";
+describe("toolAttention", () => {
+  it("stores, replaces and clears a badge, notifying once per change", () => {
+    const fn = vi.fn();
+    const off = subscribeToolAttention(fn);
+    setToolAttention("ask-buoy", {
+      kind: "needsInput",
+      label: "Needs your approval"
+    });
+    expect(getToolAttention("ask-buoy")).toEqual({
+      kind: "needsInput",
+      label: "Needs your approval"
+    });
+    expect(fn).toHaveBeenCalledTimes(1);
+    // Same value again is not a change.
+    setToolAttention("ask-buoy", {
+      kind: "needsInput",
+      label: "Needs your approval"
+    });
+    expect(fn).toHaveBeenCalledTimes(1);
+    setToolAttention("ask-buoy", {
+      kind: "done",
+      label: "Finished"
+    });
+    expect(fn).toHaveBeenCalledTimes(2);
+    setToolAttention("ask-buoy", null);
+    expect(getToolAttention("ask-buoy")).toBeNull();
+    expect(fn).toHaveBeenCalledTimes(3);
+    // Clearing what is already clear is silent.
+    setToolAttention("ask-buoy", null);
+    expect(fn).toHaveBeenCalledTimes(3);
+    off();
+  });
+  it("keeps tools apart", () => {
+    setToolAttention("a", {
+      kind: "failed",
+      label: "x"
+    });
+    setToolAttention("b", null);
+    expect(getToolAttention("a")?.kind).toBe("failed");
+    expect(getToolAttention("b")).toBeNull();
+    setToolAttention("a", null);
+  });
+});

package/lib/module/sync/toolUiBridge.js

@@ -65,4 +65,59 @@ export function openBuoyTool(toolId) {
 /** True when some host is listening — for deciding whether to offer the button. */
 export function canOpenBuoyTools() {
   return openers().size > 0;
+}
+
+// ─── Attention ───────────────────────────────────────────────────────────────
+
+/**
+ * "This tool needs you" — shown as a badge on its chip in the minimized rail.
+ *
+ * The case: Ask Buoy is minimized so a tester can watch the app, and the
+ * agent hits a step that needs a tap. Nobody can see the card. The sheet used
+ * to fail safe by DECLINING the change and ending the turn — which made
+ * minimize mean "stop", the opposite of what it is for. Now the approval
+ * holds, the chip gets a badge, and tapping the chip (the existing restore
+ * path) brings the card back. Same seam shape as the opener above: the rail
+ * lives inside the host, the tool cannot import the host, so it publishes
+ * through a global.
+ *
+ * `done` and `failed` cover the other thing a hidden tool cannot say — that
+ * the work you minimized it to wait for has finished.
+ */
+
+const ATTENTION_KEY = "__buoyToolAttention";
+function attention() {
+  const g = globalThis;
+  if (!g[ATTENTION_KEY]) g[ATTENTION_KEY] = {
+    byTool: new Map(),
+    listeners: new Set()
+  };
+  return g[ATTENTION_KEY];
+}
+
+/** Set, replace or (with null) clear a tool's badge. No-op when nothing changed. */
+export function setToolAttention(toolId, next) {
+  const store = attention();
+  const prev = store.byTool.get(toolId) ?? null;
+  if (prev === next || prev && next && prev.kind === next.kind && prev.label === next.label) return;
+  if (next) store.byTool.set(toolId, next);else store.byTool.delete(toolId);
+  for (const fn of store.listeners) {
+    try {
+      fn();
+    } catch {
+      // A throwing subscriber must not stop the others from hearing.
+    }
+  }
+}
+export function getToolAttention(toolId) {
+  return attention().byTool.get(toolId) ?? null;
+}
+
+/** For `useSyncExternalStore` in the rail. */
+export function subscribeToolAttention(fn) {
+  const store = attention();
+  store.listeners.add(fn);
+  return () => {
+    store.listeners.delete(fn);
+  };
 }