@buoy-gg/shared-ui 7.0.36 → 7.0.38

package/lib/module/stores/BaseEventStore.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { getAccountAccess, hasAccountAccess, subscribeAccountAccess } from "../license/licenseModule.js";
 /**
  * BaseEventStore - Abstract base class for event aggregation stores
  *
@@ -65,6 +66,20 @@ export class BaseEventStore extends Subscribable {
     super();
     this.maxEvents = options.maxEvents ?? 500;
     this.storeName = options.storeName;
+    // Defer until subclass fields are initialized before invoking lifecycle hooks.
+    Promise.resolve().then(() => {
+      const reconcile = () => {
+        if (getAccountAccess().status === "locked") {
+          this.stopCapturing();
+          this.events = [];
+          this.notifyArrayListeners();
+        } else if (this.getTotalSubscriberCount() > 0 && !this.captureSuppressed && !this.isCapturing()) {
+          this.startCapturing();
+        }
+      };
+      subscribeAccountAccess(reconcile);
+      reconcile();
+    });
   }
 
   // ===========================================================================
@@ -94,7 +109,7 @@ export class BaseEventStore extends Subscribable {
    * Starts capturing if no one was subscribed.
    */
   onSubscribe() {
-    if (this.getTotalSubscriberCount() === 1 && !this.captureSuppressed) {
+    if (this.getTotalSubscriberCount() === 1 && !this.captureSuppressed && getAccountAccess().status !== "locked") {
       this.startCapturing();
     }
     notifySubscriberCountChange(this.storeName);
@@ -134,7 +149,7 @@ export class BaseEventStore extends Subscribable {
     this.arrayListeners.add(listener);
 
     // Start capturing if this is the first subscriber
-    if (wasEmpty && !this.captureSuppressed) {
+    if (wasEmpty && !this.captureSuppressed && getAccountAccess().status !== "locked") {
       this.startCapturing();
     }
 
@@ -181,11 +196,12 @@ export class BaseEventStore extends Subscribable {
    * @param event - The event to add
    */
   addEvent(event) {
+    if (getAccountAccess().status === "locked") return;
     // Add to beginning (newest first) and limit to maxEvents
     this.events = [event, ...this.events].slice(0, this.maxEvents);
 
     // Notify individual event callbacks (via Subscribable)
-    this.notify(event);
+    if (hasAccountAccess()) this.notify(event);
 
     // Notify array listeners
     this.notifyArrayListeners();
@@ -209,14 +225,14 @@ export class BaseEventStore extends Subscribable {
    * Get all events (newest first)
    */
   getEvents() {
-    return this.events;
+    return hasAccountAccess() ? this.events : [];
   }
 
   /**
    * Get event count
    */
   getEventCount() {
-    return this.events.length;
+    return hasAccountAccess() ? this.events.length : 0;
   }
 
   /**

package/lib/module/stores/createToolStore.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { getAccountAccess, hasAccountAccess, subscribeAccountAccess } from "../license/licenseModule.js";
 /**
  * createToolStore — the one bounded, subscribable buffer every tool used to
  * hand-roll.
@@ -49,6 +50,16 @@ export function createToolStore(options) {
   let nextId = options.firstId ?? 1;
   let lastFlushAt = 0;
   let emitScheduled = false;
+  const empty = [];
+  let observing = false;
+  function observe() {
+    if (observing) return;
+    observing = true;
+    subscribeAccountAccess(() => {
+      if (getAccountAccess().status === "locked") items = [];
+      emit();
+    });
+  }
   const listeners = new Set();
   const clearListeners = new Set();
   function fire() {
@@ -79,19 +90,22 @@ export function createToolStore(options) {
   const store = {
     id,
     subscribe(listener) {
+      observe();
       listeners.add(listener);
       return () => {
         listeners.delete(listener);
       };
     },
     getSnapshot() {
-      return items;
+      observe();
+      return hasAccountAccess() ? items : empty;
     },
     size() {
-      return items.length;
+      return hasAccountAccess() ? items.length : 0;
     },
     add(item) {
-      if (paused) return;
+      observe();
+      if (paused || getAccountAccess().status === "locked") return;
       if (order === "append") {
         items = items.length >= max ? [...items.slice(items.length - max + 1), item] : [...items, item];
       } else {
@@ -100,10 +114,14 @@ export function createToolStore(options) {
       emit();
     },
     set(next) {
+      observe();
+      if (!hasAccountAccess()) return;
       items = trim(next);
       emit();
     },
     update(fn) {
+      observe();
+      if (getAccountAccess().status === "locked") return;
       items = trim(fn(items));
       emit();
     },

package/lib/module/stores/floatingToolStore.js

@@ -0,0 +1,61 @@
+"use strict";
+
+let entries = [];
+let revision = 0;
+const listeners = new Set();
+const notify = () => listeners.forEach(listener => listener());
+export const getFloatingTools = () => entries;
+export const subscribeFloatingTools = listener => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+/** Open or restore one tool. Mount FloatingToolHost once at the application root. */
+export function openFloatingTool(tool) {
+  if (!tool.id.trim()) throw new Error("Floating tools need a non-empty id");
+  const entry = {
+    ...tool,
+    revealToken: ++revision
+  };
+  entries = entries.some(value => value.id === tool.id) ? entries.map(value => value.id === tool.id ? entry : value) : [...entries, entry];
+  notify();
+}
+
+/** Removes the UI only. Tool actions such as Stop belong to the tool's own controller. */
+export function dismissFloatingTool(id) {
+  if (!entries.some(entry => entry.id === id)) return;
+  entries = entries.filter(entry => entry.id !== id);
+  notify();
+}
+
+/** Register at app startup to restore an open tool using its existing position storage. */
+export function registerPersistentFloatingTool(tool, storage) {
+  if (!tool.id.trim()) throw new Error("Floating tools need a non-empty id");
+  const key = `@buoy/floating-tool/${tool.id}/open`;
+  let disposed = false;
+  let changed = false;
+  let wasOpen = entries.some(entry => entry.id === tool.id);
+  let writes = Promise.resolve();
+  const unsubscribe = subscribeFloatingTools(() => {
+    const isOpen = entries.some(entry => entry.id === tool.id);
+    if (isOpen === wasOpen) return;
+    wasOpen = isOpen;
+    changed = true;
+    writes = writes.then(() => storage.setItem(key, isOpen ? "1" : "0")).then(() => {}, () => {});
+  });
+  void storage.getItem(key).then(saved => {
+    if (disposed || changed || wasOpen || saved !== "1") return;
+    // Zero restores the saved hidden state; explicit opens still reveal the tool.
+    entries = [...entries, {
+      ...tool,
+      revealToken: 0
+    }];
+    notify();
+  }).catch(() => {});
+  return () => {
+    disposed = true;
+    unsubscribe();
+  };
+}

package/lib/module/stores/floatingToolStore.test.js

@@ -0,0 +1,111 @@
+"use strict";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { dismissFloatingTool, getFloatingTools, openFloatingTool, subscribeFloatingTools } from "./floatingToolStore.js";
+afterEach(() => getFloatingTools().forEach(tool => dismissFloatingTool(tool.id)));
+describe("floating tool registry", () => {
+  it("restores an existing id and keeps other tools intact", () => {
+    openFloatingTool({
+      id: "network",
+      render: () => null
+    });
+    openFloatingTool({
+      id: "recorder",
+      render: () => null
+    });
+    const first = getFloatingTools()[0].revealToken;
+    const other = getFloatingTools()[1];
+    openFloatingTool({
+      id: "network",
+      render: () => "updated"
+    });
+    expect(getFloatingTools()).toHaveLength(2);
+    expect(getFloatingTools()[0].revealToken).toBeGreaterThan(first);
+    expect(getFloatingTools()[1]).toBe(other);
+  });
+  it("publishes stable snapshots and isolates dismissal", () => {
+    const listener = vi.fn();
+    const unsubscribe = subscribeFloatingTools(listener);
+    openFloatingTool({
+      id: "one",
+      render: () => null
+    });
+    const snapshot = getFloatingTools();
+    expect(getFloatingTools()).toBe(snapshot);
+    dismissFloatingTool("missing");
+    expect(listener).toHaveBeenCalledTimes(1);
+    openFloatingTool({
+      id: "two",
+      render: () => null
+    });
+    dismissFloatingTool("one");
+    expect(getFloatingTools().map(tool => tool.id)).toEqual(["two"]);
+    unsubscribe();
+    dismissFloatingTool("two");
+    expect(listener).toHaveBeenCalledTimes(3);
+  });
+  it("rejects missing tool identities", () => {
+    expect(() => openFloatingTool({
+      id: "  ",
+      render: () => null
+    })).toThrow("non-empty id");
+    expect(getFloatingTools()).toHaveLength(0);
+  });
+});
+describe("persistent floating tools", () => {
+  it("restores after a fresh registry loads and remembers dismissal", async () => {
+    const values = new Map();
+    const storage = {
+      getItem: vi.fn(async key => values.get(key) ?? null),
+      setItem: vi.fn(async (key, value) => {
+        values.set(key, value);
+      })
+    };
+    const tool = {
+      id: "persisted",
+      render: () => null
+    };
+    vi.resetModules();
+    const first = await import("./floatingToolStore");
+    const disposeFirst = first.registerPersistentFloatingTool(tool, storage);
+    first.openFloatingTool(tool);
+    await vi.waitFor(() => expect(values.get("@buoy/floating-tool/persisted/open")).toBe("1"));
+    disposeFirst();
+    vi.resetModules();
+    const second = await import("./floatingToolStore");
+    const disposeSecond = second.registerPersistentFloatingTool(tool, storage);
+    await vi.waitFor(() => expect(second.getFloatingTools()).toHaveLength(1));
+    expect(second.getFloatingTools()[0].revealToken).toBe(0);
+    second.dismissFloatingTool(tool.id);
+    await vi.waitFor(() => expect(values.get("@buoy/floating-tool/persisted/open")).toBe("0"));
+    disposeSecond();
+    vi.resetModules();
+    const third = await import("./floatingToolStore");
+    const disposeThird = third.registerPersistentFloatingTool(tool, storage);
+    await Promise.resolve();
+    expect(third.getFloatingTools()).toHaveLength(0);
+    disposeThird();
+  });
+  it("does not reopen a tool closed while its saved state was loading", async () => {
+    vi.resetModules();
+    const registry = await import("./floatingToolStore");
+    let resolve;
+    const storage = {
+      getItem: () => new Promise(done => {
+        resolve = done;
+      }),
+      setItem: vi.fn(async () => {})
+    };
+    const tool = {
+      id: "race",
+      render: () => null
+    };
+    const dispose = registry.registerPersistentFloatingTool(tool, storage);
+    registry.openFloatingTool(tool);
+    registry.dismissFloatingTool(tool.id);
+    resolve("1");
+    await vi.waitFor(() => expect(storage.setItem).toHaveBeenLastCalledWith("@buoy/floating-tool/race/open", "0"));
+    expect(registry.getFloatingTools()).toHaveLength(0);
+    dispose();
+  });
+});

package/lib/module/sync/toolActionRegistry.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { assertAccountAccess, hasAccountAccess, subscribeAccountAccess } from "../license/licenseModule.js";
 /**
  * toolActionRegistry — the on-device twin of the broker's action dispatch.
  *
@@ -56,13 +57,45 @@ function sources() {
 export function registerToolAdapters(getTools) {
   const set = sources();
   set.add(getTools);
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    const raw = getTools();
+    // Private inverse operations only. No credential bypass reaches public dispatch.
+    const cleanup = async (toolId, action, params) => {
+      if (!(toolId === "network" && action === "deleteOverrideRule" || toolId === "impersonate" && action === "stopImpersonation")) {
+        throw new Error("Unsupported account-lock cleanup operation");
+      }
+      if (toolId === "impersonate") return raw[toolId]?.dispose?.(cleanup);
+      const fn = raw[toolId]?.actions?.[action];
+      if (!fn) throw new Error(`Cleanup unavailable for ${toolId}`);
+      return fn(params);
+    };
+    for (const adapter of Object.values(raw)) {
+      try {
+        Promise.resolve(adapter.dispose?.(cleanup)).catch(error => console.warn("[Buoy] Tool cleanup failed", error));
+      } catch (error) {
+        console.warn("[Buoy] Tool cleanup failed", error);
+      }
+    }
+  };
+  const off = subscribeAccountAccess(() => {
+    if (!hasAccountAccess()) dispose();else disposed = false;
+  });
   return () => {
+    off();
     set.delete(getTools);
+    // A second provider still owns these adapters during Strict Mode/remount.
+    Promise.resolve().then(() => {
+      if (set.size === 0) dispose();
+    });
   };
 }
 
 /** The merged adapter map across every live source. */
 export function getToolAdapters() {
+  if (!hasAccountAccess()) return {};
   const merged = {};
   for (const get of sources()) {
     try {
@@ -71,7 +104,7 @@ export function getToolAdapters() {
       // A source that throws must not take the whole registry down.
     }
   }
-  return merged;
+  return Object.fromEntries(Object.entries(merged).map(([id, adapter]) => [id, guardToolAdapter(adapter)]));
 }
 
 /** Tool ids currently dispatchable. */
@@ -111,6 +144,7 @@ export function listSnapshotToolIds() {
  * an adapter is free to make this a promise later without breaking them.
  */
 export async function readToolSnapshot(toolId) {
+  assertAccountAccess();
   const tools = getToolAdapters();
   const adapter = tools[toolId];
   if (!adapter) throw new Error(`Unknown tool "${toolId}"`);
@@ -120,7 +154,7 @@ export async function readToolSnapshot(toolId) {
   return await adapter.getSnapshot();
 }
 export function isToolRegistryReady() {
-  return sources().size > 0;
+  return hasAccountAccess() && sources().size > 0;
 }
 
 /**
@@ -129,6 +163,7 @@ export function isToolRegistryReady() {
  * surface as plain messages rather than objects nobody can read on a phone.
  */
 export async function dispatchToolAction(toolId, action, params) {
+  assertAccountAccess();
   const tools = getToolAdapters();
   const tool = tools[toolId];
   const fn = tool?.actions?.[action];
@@ -151,4 +186,51 @@ export async function waitForToolRegistry(timeoutMs = 2000) {
     if (isToolRegistryReady()) return true;
   }
   return false;
+}
+
+/** Guard retained references too, and discard results completed after revocation. */
+export function guardToolAdapter(adapter) {
+  const guard = fn => (...args) => {
+    assertAccountAccess();
+    let revoked = false;
+    const off = subscribeAccountAccess(() => {
+      if (!hasAccountAccess()) revoked = true;
+    });
+    const check = () => {
+      if (revoked) throw new Error("Buoy account access ended while the operation was pending.");
+      assertAccountAccess();
+    };
+    try {
+      const result = fn.apply(adapter, args);
+      if (result && typeof result.then === "function") {
+        return Promise.resolve(result).then(value => {
+          check();
+          return value;
+        }).finally(off);
+      }
+      check();
+      off();
+      return result;
+    } catch (error) {
+      off();
+      throw error;
+    }
+  };
+  return {
+    ...adapter,
+    ...(adapter.getSnapshot ? {
+      getSnapshot: guard(adapter.getSnapshot)
+    } : {}),
+    ...(adapter.actions ? {
+      actions: Object.fromEntries(Object.entries(adapter.actions).map(([name, action]) => [name, guard(action)]))
+    } : {}),
+    ...(adapter.subscribe ? {
+      subscribe: listener => {
+        assertAccountAccess();
+        return adapter.subscribe(() => {
+          if (hasAccountAccess()) listener();
+        });
+      }
+    } : {})
+  };
 }

package/lib/module/ui/backgrounds/README.md

@@ -195,3 +195,55 @@ switcher shows both, which is the point — it's a review tool, not decoration.
 Alpha calibration: every preset runs a 0.4–0.55 vignette, and anything fainter
 than ~0.2 alpha disappears under it — hairline strokes in particular need ~0.2
 alpha or a second pixel of height to register at all.
+
+
+## Wormhole mobile preview
+
+Wormhole is the eighth registry entry (including Off). Select it under the
+Buoy dial's Settings → Background; the existing store persists that choice.
+The example app also exposes `/bg-bench?v=wormhole` and
+`/bg-bench?v=wormhole-still` for comparison under identical tool content.
+
+The moving scene is a zoom, and a zoom only loops invisibly when the picture
+is self-similar under the handoff. Two copies of one opaque cloud sheet scale
+toward the viewer one period apart (×√6 in scale, +21° in rotation) and
+crossfade with balanced source-over opacities; each forward pass takes six
+seconds (two periods) at constant proportional expansion, and four passes fit
+inside one 24-second camera-bank cycle. The sheet is built by
+`scripts/generate-wormhole-textures.cjs` by tiling one annulus of the real
+shader frame in log-polar space with exactly that (×√6, +21°) symmetry, so the
+two copies are the same picture wherever they overlap and neither the
+crossfade nor a layer's reset can be seen. The destination is cut from the
+same frame with a feathered alpha and drawn as a static layer above the
+sheets — the far end of a tunnel does not zoom. One native Animated loop
+drives the scene. It approximates the flight: the tunnel geometry is baked into
+the textures, not ray-marched on the device. There is no Skia, Reanimated,
+WebView, new native dependency, or per-frame JS callback.
+
+TRAP (the "badly looping GIF" we shipped first): a feathered ring texture is
+NOT self-similar, so a copy born at 0.42× painted a shrunken tunnel — its own
+copper rim included — over the destination every 3 s, then pushed it outward.
+Fade tuning cannot hide that; only a sheet that matches itself under the
+handoff transform can. `WORMHOLE_PERIOD` / `WORMHOLE_TWIST` in `motion.ts` are
+that transform: change either and regenerate the sheet (the generator checks
+the pixels against the symmetry and refuses a sheet that does not match).
+
+While moving, the 1440×1440 sheet (JPEG) and the 384×384 eye (PNG) contribute
+about 337 KiB of source data and roughly 8.5 MiB of decoded pixels; the still
+(640×640 JPEG, 57 KiB, 1.6 MiB decoded) is mounted only when the scene does
+not move. Instances can reuse the same image source objects. Reduced motion
+shows the still texture; the existing animation primitive pauses on AppState
+changes and stops on unmount. Geometry is window-sized and cropped by each tool
+surface. Actual device performance remains to be measured in the benchmark
+screen.
+
+The desktop menu keeps one Wormhole entry and its existing live WebGL renderer.
+The mobile texture preview does not replace the desktop shader.
+
+Texture source: `node scripts/generate-wormhole-textures.cjs` (from
+`packages/shared`) ports the website's dark shader to the CPU, renders it at
+u_t=4 with the destination centred and no copy scrim or vignette, tiles the
+sheet, cuts the eye, and rewrites `textures.ts`. It keeps the embedded still
+unless `--still scene.jpg` supplies a fresh centered 640px WebGL capture; JPEG
+encoding shells out to macOS `sips`. Both packages and Metro can consume the
+module without an asset-loader plugin.

package/lib/module/ui/backgrounds/ToolBackground.js

@@ -33,7 +33,8 @@ const bucket = n => Math.max(0, Math.ceil(n / 8) * 8);
 export const ToolBackground = /*#__PURE__*/memo(function ToolBackground({
   id,
   motion,
-  opacity = 1
+  opacity = 1,
+  focus
 }) {
   const shared = useToolBackground();
   const [size, setSize] = useState({
@@ -64,7 +65,8 @@ export const ToolBackground = /*#__PURE__*/memo(function ToolBackground({
     children: Variant && ready ? /*#__PURE__*/_jsx(Variant, {
       width: size.width,
       height: size.height,
-      animated: animated
+      animated: animated,
+      focus: focus
     }) : null
   });
 });

package/lib/module/ui/backgrounds/index.js

@@ -15,4 +15,5 @@ export { DeepFieldTunable } from "./variants/deepField.js";
 export { MoonlightTunable } from "./variants/moonlight.js";
 export { DaylightTunable } from "./variants/daylight.js";
 export { LiveSkyTunable } from "./variants/liveSky.js";
-export { getSkyScrub, setSkyScrub, useSkyScrub } from "./skyClock.js";
+export { getSkyScrub, setSkyScrub, useSkyScrub } from "./skyClock.js";
+export { Wormhole } from "./variants/wormhole.js";

package/lib/module/ui/backgrounds/registry.js

@@ -11,6 +11,7 @@
  */
 
 import { DeepField } from "./variants/deepField.js";
+import { Wormhole } from "./variants/wormhole.js";
 import { Hyperspace } from "./variants/hyperspace.js";
 import { LiveSky } from "./variants/liveSky.js";
 import { Abyss, Bubbles, Jellyfish } from "./variants/underwater.js";
@@ -65,6 +66,13 @@ export const BACKGROUND_PRESETS = [{
   nodes: 15,
   views: 250,
   Component: Jellyfish
+}, {
+  id: "wormhole",
+  label: "Wormhole",
+  blurb: "Cobalt clouds and copper light — a native flight through the tunnel",
+  nodes: 1,
+  views: 7,
+  Component: Wormhole
 }];
 
 // Ships OFF: a backdrop is an opt-in, so first load is plain black and the

package/lib/module/ui/backgrounds/variants/wormhole/motion.js

@@ -0,0 +1,44 @@
+"use strict";
+
+/** One slow camera cycle containing four faster forward passes.
+ * Keyframes run on Animated's native driver; this math runs only at import.
+ *
+ * The sheet texture is self-similar: scaled by WORMHOLE_PERIOD and rotated by
+ * WORMHOLE_TWIST it is the same picture (scripts/generate-wormhole-textures.cjs
+ * builds it that way and checks it). The two shells sit exactly one period
+ * apart, so at every instant they show identical pixels and the crossfade
+ * between them — and each shell's reset — cannot be seen. Change either
+ * constant and regenerate the textures; the sheet must be rebuilt to match.
+ */
+export const WORMHOLE_CYCLE_MS = 24000;
+export const WORMHOLE_PASSES = 4;
+/** Scale ratio between the two shells; one pass covers two periods (×6). */
+export const WORMHOLE_PERIOD = Math.sqrt(6);
+/** Degrees the picture turns per period — its spiral symmetry. */
+export const WORMHOLE_TWIST = 21;
+const STEPS_PER_PASS = 64;
+export const WORMHOLE_INPUT = Array.from({
+  length: STEPS_PER_PASS * WORMHOLE_PASSES + 1
+}, (_, i) => i / (STEPS_PER_PASS * WORMHOLE_PASSES));
+const smooth = (from, to, value) => {
+  const t = Math.max(0, Math.min(1, (value - from) / (to - from)));
+  return t * t * (3 - 2 * t);
+};
+const PHASES = [0, 0.5].map(offset => WORMHOLE_INPUT.map(t => (t * WORMHOLE_PASSES + offset) % 1));
+// Broad overlapping windows, with a completely invisible interval around wraps.
+const WEIGHTS = PHASES.map(phase => phase.map(t => Math.sin(Math.PI * t) ** 2 * smooth(0.02, 0.12, t) * (1 - smooth(0.88, 0.98, t))));
+export const WORMHOLE_SHELLS = PHASES.map((phase, layer) => ({
+  // Constant proportional expansion keeps the forward speed steady. The
+  // sheet covers the whole plane from scale 1, so a shell never shows an edge.
+  scale: phase.map(t => Math.pow(WORMHOLE_PERIOD, 2 * t)),
+  // Normalize layer transmission across the overlapping fades.
+  opacity: phase.map((_, i) => {
+    const total = WEIGHTS.reduce((sum, weights) => sum + weights[i], 0);
+    return 1 - Math.pow(0.08, WEIGHTS[layer][i] / total);
+  }),
+  // One twist per period, centred so the shells sit ±θ/2 around the camera.
+  rotate: phase.map(t => `${(2 * t - 1) * WORMHOLE_TWIST}deg`)
+}));
+// Zero velocity at the turnarounds and the loop boundary, rather than the
+// sharp reversal from a three-keyframe triangle-wave camera bank.
+export const WORMHOLE_CAMERA_ROTATION = WORMHOLE_INPUT.map(t => `${-5 * Math.cos(t * Math.PI * 2)}deg`);