@buoy-gg/shared-ui 7.0.41 → 7.0.42

package/lib/module/sync/keyedArrays.js

@@ -1,204 +1 @@
-"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
-  };
-}
+"use strict";const d=e=>typeof e==="object"&&e!==null&&!Array.isArray(e);const m=["id","lineId","key","uuid","_id","slug","name"];export function identityField(e){if(!e.length||!e.every(d))return void 0;const i=e[0];for(const t of m){if(!(t in i))continue;const r=e.map(o=>o[t]);const n=r.every(o=>typeof o==="string"||typeof o==="number");if(!n)continue;if(new Set(r.map(String)).size!==r.length)continue;return t}return void 0}function $(e,i,t,r){const n=r[i];if(typeof n==="string"||typeof n==="number"){if(String(n)!==t){return{ok:false,error:`The new item is addressed as \`${t}\` but carries \`${i}\`: ${JSON.stringify(n)}. Use the same value for both \u2014 address it by the id it carries.`}}return{ok:true,value:n}}const o=e.every(s=>typeof s[i]==="number");if(o&&t.trim()!==""&&String(Number(t))===t){return{ok:true,value:Number(t)}}return{ok:true,value:t}}export function expandKeyedArrays(e,i,t="",r=[]){if(Array.isArray(e)&&d(i)){const n=identityField(e);if(!n){return{patch:i,notes:r}}const o=new Map(e.map(f=>[String(f[n]),f]));const s=e.slice();let y=0;let c=0;let b=0;for(const[f,a]of Object.entries(i)){const l=s.findIndex(u=>String(u[n])===f);if(a===null){if(l===-1)return{patch:i,notes:r};s.splice(l,1);y++}else if(l===-1){if(!d(a))return{patch:i,notes:r};const u=$(e,n,f,a);if(!u.ok){return{patch:i,notes:r,error:u.error}}s.push({...a,[n]:u.value});b++}else{const u=expandKeyedArrays(o.get(f),a,`${t}[${f}]`,r);if(u.error)return{patch:i,notes:r,error:u.error};const g=s[l];s[l]=d(g)&&d(u.patch)?{...g,...u.patch}:u.patch;c++}}r.push(`${t||"(root)"}: addressed by \`${n}\` \u2014 ${c} changed, ${b} added, ${y} removed, ${s.length} item(s) remain`);return{patch:s,notes:r}}if(d(e)&&d(i)){const n={};for(const[o,s]of Object.entries(i)){const y=t?`${t}.${o}`:o;if(!(o in e)){n[o]=s;continue}const c=expandKeyedArrays(e[o],s,y,r);if(c.error)return{patch:i,notes:r,error:c.error};n[o]=c.patch}return{patch:n,notes:r}}return{patch:i,notes:r}}

package/lib/module/sync/toolActionRegistry.js

@@ -1,236 +1 @@
-"use strict";
-
-import { assertAccountAccess, hasAccountAccess, subscribeAccountAccess } from "../license/licenseModule.js";
-/**
- * toolActionRegistry — the on-device twin of the broker's action dispatch.
- *
- * Buoy already has exactly one place where `{toolId, action, params}` becomes a
- * real call into a tool: `handleAction` in external-sync, fed by the adapter
- * map that `autoExternalSync` assembles. That map was private to the React
- * tree, so anything running ON the device (the Scenarios runner) had no way to
- * reach it and would have had to duplicate the map — two dispatch paths that
- * drift the first time an adapter changes.
- *
- * This module publishes the SAME map through a global seam, so a scenario step,
- * a desktop click and an MCP call are one code path with two entry points.
- *
- * WHY A GLOBAL, NOT AN IMPORT: the map is built inside a component (the
- * react-query adapter is a hook, the env adapter is a factory closed over a
- * prop, and custom tools arrive as props), so it cannot be a module constant.
- * Meanwhile the consumer must not import `@buoy-gg/core` — that package imports
- * the tools, and a tool importing it back is the require cycle that puts a
- * LogBox on every reload. Same reasoning, and the same shape, as
- * `crashFlush.ts` in external-sync.
- *
- * WE STORE A GETTER, NOT A SNAPSHOT, for the reason `attachDeviceSync` does:
- * the adapter map is re-created on renders that change its inputs, and a stale
- * captured copy would keep dispatching into adapters the tree has replaced.
- *
- * SAFETY: this registry is populated only while `AutoExternalSync` is mounted,
- * which is itself gated (dev, or release + an explicit opt-in + a real Pro
- * license). It is deliberately NOT a substitute for a caller's own production
- * gate — anything that bends app state through it must check `__DEV__` itself,
- * because the actions reachable here (network overrides, storage writes,
- * impersonation) have no business running in a shipped app.
- */
-
-const REGISTRY_KEY = "__buoyToolActionRegistry";
-
-/** The duck-typed adapter shape, matching external-sync's `ToolSyncAdapter`. */
-
-/**
- * A SET of getters, not one slot — React can briefly mount two providers, or
- * re-run an effect's setup before the previous cleanup. A last-writer-wins slot
- * would let the second registration silently blank the first.
- */
-
-function sources() {
-  const g = globalThis;
-  if (!g[REGISTRY_KEY]) g[REGISTRY_KEY] = new Set();
-  return g[REGISTRY_KEY];
-}
-
-/**
- * Publish the live adapter map. Called by `autoExternalSync` with a getter that
- * reads its current `useMemo` value. Returns the unregister function.
- */
-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 {
-      Object.assign(merged, get());
-    } catch {
-      // A source that throws must not take the whole registry down.
-    }
-  }
-  return Object.fromEntries(Object.entries(merged).map(([id, adapter]) => [id, guardToolAdapter(adapter)]));
-}
-
-/** Tool ids currently dispatchable. */
-export function listToolIds() {
-  return Object.keys(getToolAdapters());
-}
-
-/** `toolId -> action names`, for pre-flight validation and capability display. */
-export function listToolActions() {
-  const out = {};
-  for (const [id, adapter] of Object.entries(getToolAdapters())) {
-    out[id] = Object.keys(adapter.actions ?? {});
-  }
-  return out;
-}
-
-/**
- * Tool ids whose adapter publishes a `getSnapshot`.
- *
- * Buoy's read surface is split in two: some tools answer through `actions`
- * (`listQueries`, `async.getAllKeys`), and some answer only through the
- * snapshot the sync layer polls — console entries, network events, the route
- * sitemap, the env table. Anything driving tools ON the device sees only the
- * first half unless it asks for the second, which is why the console and
- * network panels look empty to an in-app agent that has an action for
- * everything except reading them.
- */
-export function listSnapshotToolIds() {
-  return Object.entries(getToolAdapters()).filter(([, adapter]) => typeof adapter.getSnapshot === "function").map(([id]) => id);
-}
-
-/**
- * Read one tool's snapshot — the same value `attachDeviceSync` puts on the wire
- * for MCP's `get_snapshot`, without a socket.
- *
- * Async to match {@link dispatchToolAction}: every caller already awaits, and
- * 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}"`);
-  if (typeof adapter.getSnapshot !== "function") {
-    throw new Error(`Tool "${toolId}" has no snapshot to read`);
-  }
-  return await adapter.getSnapshot();
-}
-export function isToolRegistryReady() {
-  return hasAccountAccess() && sources().size > 0;
-}
-
-/**
- * Dispatch one action, shaping failures exactly as `handleAction` does: an
- * unknown tool and an unknown action are distinguishable, and adapter errors
- * 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];
-  if (!fn) {
-    throw new Error(tool ? `Unknown action "${action}" on tool "${toolId}"` : `Unknown tool "${toolId}"`);
-  }
-  return await fn(params);
-}
-
-/**
- * Wait for the registry to be populated, for the narrow window between first
- * frame and `AutoExternalSync` mounting. Resolves false on timeout so the
- * caller can say "Buoy tools are still starting up" instead of "unknown tool".
- */
-export async function waitForToolRegistry(timeoutMs = 2000) {
-  if (isToolRegistryReady()) return true;
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    await new Promise(r => setTimeout(r, 50));
-    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();
-        });
-      }
-    } : {})
-  };
-}
+"use strict";import{assertAccountAccess as u,hasAccountAccess as f,subscribeAccountAccess as w}from"../license/licenseModule.js";import{realNow as y}from"../utils/realNow.js";const l="__buoyToolActionRegistry";function p(){const e=globalThis;if(!e[l])e[l]=new Set;return e[l]}export function registerToolAdapters(e){const o=p();o.add(e);let t=false;const c=()=>{if(t)return;t=true;const r=e();const a=async(n,s,b)=>{if(!(n==="network"&&s==="deleteOverrideRule"||n==="impersonate"&&s==="stopImpersonation")){throw new Error("Unsupported account-lock cleanup operation")}if(n==="impersonate")return r[n]?.dispose?.(a);const h=r[n]?.actions?.[s];if(!h)throw new Error(`Cleanup unavailable for ${n}`);return h(b)};for(const n of Object.values(r)){try{Promise.resolve(n.dispose?.(a)).catch(s=>console.warn("[Buoy] Tool cleanup failed",s))}catch(s){console.warn("[Buoy] Tool cleanup failed",s)}}};const i=w(()=>{if(!f())c();else t=false});return()=>{i();o.delete(e);Promise.resolve().then(()=>{if(o.size===0)c()})}}export function getToolAdapters(){if(!f())return{};const e={};for(const o of p()){try{Object.assign(e,o())}catch{}}return Object.fromEntries(Object.entries(e).map(([o,t])=>[o,guardToolAdapter(t)]))}export function listToolIds(){return Object.keys(getToolAdapters())}export function listToolActions(){const e={};for(const[o,t]of Object.entries(getToolAdapters())){e[o]=Object.keys(t.actions??{})}return e}export function listSnapshotToolIds(){return Object.entries(getToolAdapters()).filter(([,e])=>typeof e.getSnapshot==="function").map(([e])=>e)}export async function readToolSnapshot(e){u();const o=getToolAdapters();const t=o[e];if(!t)throw new Error(`Unknown tool "${e}"`);if(typeof t.getSnapshot!=="function"){throw new Error(`Tool "${e}" has no snapshot to read`)}return await t.getSnapshot()}export function isToolRegistryReady(){return f()&&p().size>0}export async function dispatchToolAction(e,o,t){u();const c=getToolAdapters();const i=c[e];const r=i?.actions?.[o];if(!r){throw new Error(i?`Unknown action "${o}" on tool "${e}"`:`Unknown tool "${e}"`)}return await r(t)}export async function waitForToolRegistry(e=2e3){if(isToolRegistryReady())return true;const o=y()+e;while(y()<o){await new Promise(t=>setTimeout(t,50));if(isToolRegistryReady())return true}return false}export function guardToolAdapter(e){const o=t=>(...c)=>{u();let i=false;const r=w(()=>{if(!f())i=true});const a=()=>{if(i)throw new Error("Buoy account access ended while the operation was pending.");u()};try{const n=t.apply(e,c);if(n&&typeof n.then==="function"){return Promise.resolve(n).then(s=>{a();return s}).finally(r)}a();r();return n}catch(n){r();throw n}};return{...e,...e.getSnapshot?{getSnapshot:o(e.getSnapshot)}:{},...e.actions?{actions:Object.fromEntries(Object.entries(e.actions).map(([t,c])=>[t,o(c)]))}:{},...e.subscribe?{subscribe:t=>{u();return e.subscribe(()=>{if(f())t()})}}:{}}}

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

@@ -1,50 +1 @@
-"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);
-  });
-});
+"use strict";import{describe as s,expect as e,it as n,vi as i}from"vitest";import{getToolAttention as a,setToolAttention as o,subscribeToolAttention as d}from"./toolUiBridge.js";s("toolAttention",()=>{n("stores, replaces and clears a badge, notifying once per change",()=>{const l=i.fn();const t=d(l);o("ask-buoy",{kind:"needsInput",label:"Needs your approval"});e(a("ask-buoy")).toEqual({kind:"needsInput",label:"Needs your approval"});e(l).toHaveBeenCalledTimes(1);o("ask-buoy",{kind:"needsInput",label:"Needs your approval"});e(l).toHaveBeenCalledTimes(1);o("ask-buoy",{kind:"done",label:"Finished"});e(l).toHaveBeenCalledTimes(2);o("ask-buoy",null);e(a("ask-buoy")).toBeNull();e(l).toHaveBeenCalledTimes(3);o("ask-buoy",null);e(l).toHaveBeenCalledTimes(3);t()});n("keeps tools apart",()=>{o("a",{kind:"failed",label:"x"});o("b",null);e(a("a")?.kind).toBe("failed");e(a("b")).toBeNull();o("a",null)})});

package/lib/module/sync/toolSyncAdapter.js

@@ -1,58 +1 @@
-"use strict";
-
-/**
- * ToolSyncAdapter — the contract a tool implements to sync to Buoy Desktop /
- * the MCP server, plus `createSyncAdapter`, the one way to build one.
- *
- * Every tool package used to declare its adapter as a bare object literal
- * with the comment "structurally matches external-sync's ToolSyncAdapter so
- * this package doesn't need a dependency on it". That kept the packages
- * decoupled but left the contract unchecked: storage shipped `version: 3`
- * while every sibling was on 2 and nothing noticed. The type now lives here,
- * in shared (which every tool already depends on), and external-sync
- * re-exports it — one definition, checked everywhere.
- *
- * `createSyncAdapter` is deliberately thin. It:
- *  - type-checks the literal against the contract (a wrong `subscribe`
- *    signature or a non-function action fails at compile time),
- *  - keeps the CONCRETE `actions` type, so `adapter.actions.getChangeDetail()`
- *    stays typed for tests and callers,
- *  - merges several change sources into one `subscribe` (a store plus its
- *    registry, envelopes plus drops) — the second most-copied block.
- */
-
-/** A remote-invocable action. Thrown errors are reported back to the dashboard. */
-
-/** Anything that can tell the bridge "something changed". */
-
-/**
- * The contract each dev tool implements to become remotely syncable.
- * Works with BaseEventStore, ChangeLog, createToolStore, or any pattern
- * exposing subscribe + getSnapshot.
- *
- * Payloads (snapshots and action results) must be JSON-serializable —
- * no functions, circular references, or class instances.
- */
-
-/** Subscribe to every source; the returned function unsubscribes from all. */
-export function mergeChangeSources(sources) {
-  if (sources.length === 1) return sources[0];
-  return onChange => {
-    const offs = sources.map(source => source(onChange));
-    return () => {
-      for (const off of offs) off();
-    };
-  };
-}
-export function createSyncAdapter(definition) {
-  const subscribe = Array.isArray(definition.subscribe) ? mergeChangeSources(definition.subscribe) : definition.subscribe;
-  const adapter = {
-    version: definition.version,
-    getSnapshot: definition.getSnapshot,
-    subscribe,
-    ...(definition.actions ? {
-      actions: definition.actions
-    } : {})
-  };
-  return adapter;
-}
+"use strict";export function mergeChangeSources(r){if(r.length===1)return r[0];return s=>{const t=r.map(e=>e(s));return()=>{for(const e of t)e()}}}export function createSyncAdapter(r){const s=Array.isArray(r.subscribe)?mergeChangeSources(r.subscribe):r.subscribe;const t={version:r.version,getSnapshot:r.getSnapshot,subscribe:s,...r.actions?{actions:r.actions}:{}};return t}

package/lib/module/sync/toolUiBridge.js

@@ -1,123 +1 @@
-"use strict";
-
-/**
- * toolUiBridge — let a tool ask the host to bring another tool back on screen.
- *
- * WHY THIS EXISTS. Buoy's tool overlays (the SIMULATED banner, the recording
- * banner, the perf HUD) render as siblings of `AppHostProvider`, not inside it,
- * so none of them can reach the host that knows how to open and restore tools.
- * That is usually fine — an overlay's job is to be seen, not to navigate. It
- * stops being fine the moment an overlay is the ONLY thing on screen and the
- * next step lives inside a tool: the macro recorder minimizes Scenarios so a
- * tester can drive the app, and when they stop, the review screen they need is
- * behind a tool icon they have to know to hunt for.
- *
- * The alternative was moving every overlay inside the provider, which would
- * re-order the stacking of six unrelated tools to fix one banner's button. This
- * is the same global-seam shape `toolActionRegistry` already uses for the same
- * reason: the capability lives inside a component tree, the caller must not
- * import `@buoy-gg/core` (that package imports the tools, and a tool importing
- * it back is a require cycle), so it is published through a global.
- *
- * A SET of openers, not one slot, for the reason the action registry keeps one:
- * React can briefly mount two providers, or re-run an effect's setup before the
- * previous cleanup, and a last-writer-wins slot lets the second registration
- * silently blank the first.
- */
-
-const BRIDGE_KEY = "__buoyToolUiBridge";
-
-/** Returns true when the tool was actually brought back on screen. */
-
-function openers() {
-  const g = globalThis;
-  if (!g[BRIDGE_KEY]) g[BRIDGE_KEY] = new Set();
-  return g[BRIDGE_KEY];
-}
-
-/** Published by the host, inside the provider that owns open tools. */
-export function registerToolOpener(opener) {
-  const set = openers();
-  set.add(opener);
-  return () => {
-    set.delete(opener);
-  };
-}
-
-/**
- * Ask the host to show a tool.
- *
- * Returns false when nothing could do it — no host mounted, or the tool isn't
- * open for it to restore. Callers must treat that as a real answer and say so,
- * rather than rendering a button that silently does nothing.
- */
-export function openBuoyTool(toolId) {
-  for (const opener of openers()) {
-    try {
-      if (opener(toolId)) return true;
-    } catch {
-      // A host that throws must not stop another from answering.
-    }
-  }
-  return false;
-}
-
-/** 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);
-  };
-}
+"use strict";const r="__buoyToolUiBridge";function s(){const t=globalThis;if(!t[r])t[r]=new Set;return t[r]}export function registerToolOpener(t){const o=s();o.add(t);return()=>{o.delete(t)}}export function openBuoyTool(t){for(const o of s()){try{if(o(t))return true}catch{}}return false}export function canOpenBuoyTools(){return s().size>0}const i="__buoyToolAttention";function l(){const t=globalThis;if(!t[i])t[i]={byTool:new Map,listeners:new Set};return t[i]}export function setToolAttention(t,o){const e=l();const n=e.byTool.get(t)??null;if(n===o||n&&o&&n.kind===o.kind&&n.label===o.label)return;if(o)e.byTool.set(t,o);else e.byTool.delete(t);for(const u of e.listeners){try{u()}catch{}}}export function getToolAttention(t){return l().byTool.get(t)??null}export function subscribeToolAttention(t){const o=l();o.listeners.add(t);return()=>{o.listeners.delete(t)}}