@buoy-gg/shared-ui 7.0.40 → 7.0.42

package/lib/module/stores/ignoredPatternsStore.web.js

@@ -1,221 +1 @@
-"use strict";
-
-/**
- * ignoredPatternsStore.web — web twin of ignoredPatternsStore.ts (the shared
- * persisted "ignored patterns" singleton for network-style URL filtering).
- *
- * The native store imports shared's RN `persistentStorage` (whose module graph
- * carries guarded expo-file-system / async-storage requires), which is why the
- * web shims never re-exported it. This twin keeps the ENTIRE store class, hook
- * and persistence contract identical — same class shape, same
- * `devToolsStorageKeys.network.ignoredDomains()` storage key, same persisted
- * JSON shape (`IgnoredPattern[]`, with the legacy `string[]` migration) — and
- * swaps only the storage backing: a file-local localStorage adapter that
- * matches the `persistentStorage` API (async getItem/setItem, best-effort,
- * provenance: example-tauri/src/shims/shared-ui.web.ts's adapter — web Buoy
- * chrome persistence lives in webview localStorage).
- *
- * Everything else — pure matching (`ignoredPatternsCore`), the migration +
- * ensure-defaults logic, the dirty-flag load race guard, the module-scope
- * stable mutation identities — is the native code, not a fork of its
- * semantics. Web consumers get the same shared, persisted pattern list the
- * phone has, keyed identically, so a DOM port and a react-native-web port of
- * the same app read/write the same entry.
- *
- * @platform React DOM Web
- */
-
-import { useEffect, useMemo, useState } from "react";
-import { devToolsStorageKeys } from "../storage/devToolsStorageKeys.js";
-
-// Pure matching types/helpers live in ignoredPatternsCore.ts (web-shim-safe);
-// re-exported here so this module's surface twins the native store's.
-import { DEFAULT_IGNORED_PATTERNS } from "./ignoredPatternsCore.js";
-export { urlMatchesIgnoredPattern, isUrlIgnored } from "./ignoredPatternsCore.js";
-
-/**
- * localStorage-backed implementation of the shared `persistentStorage` API
- * (getItem/setItem returning promises, silent best-effort failure) — the same
- * adapter recipe the web shared-ui shims use for Buoy chrome persistence.
- * Local to this file so the web store pulls zero RN/expo modules.
- */
-const persistentStorage = {
-  async getItem(key) {
-    try {
-      return window.localStorage.getItem(key);
-    } catch {
-      return null;
-    }
-  },
-  async setItem(key, value) {
-    try {
-      window.localStorage.setItem(key, value);
-    } catch {
-      // Ignore quota/availability errors — callers treat this as best-effort.
-    }
-  }
-};
-const DEFAULT_PATTERNS = DEFAULT_IGNORED_PATTERNS;
-
-/** Tolerate the legacy `string[]` persisted format and stray junk. */
-function migratePatterns(raw) {
-  if (!Array.isArray(raw)) return [];
-  const migrated = [];
-  for (const entry of raw) {
-    if (typeof entry === "string" && entry.trim()) {
-      migrated.push({
-        value: entry,
-        mode: "contains"
-      });
-    } else if (entry && typeof entry === "object" && typeof entry.value === "string") {
-      const e = entry;
-      migrated.push({
-        value: e.value,
-        mode: e.mode === "exact" ? "exact" : "contains"
-      });
-    }
-  }
-  return migrated;
-}
-
-/** Always keep the default patterns present (e.g. Buoy's license API). */
-function ensureDefaults(patterns) {
-  const result = [...patterns];
-  for (const def of DEFAULT_PATTERNS) {
-    if (!result.some(p => p.value === def.value)) {
-      result.push({
-        ...def
-      });
-    }
-  }
-  return result;
-}
-/**
- * Singleton store. One instance per JS runtime, so every consumer (Network
- * tool, Events tool, any web panel) shares the same patterns.
- */
-class IgnoredPatternsStore {
-  patterns = ensureDefaults(DEFAULT_PATTERNS.map(p => ({
-    ...p
-  })));
-  listeners = new Set();
-  loaded = false;
-  loadPromise = null;
-  /** Set once a mutation happens so a slow initial load can't clobber it. */
-  dirty = false;
-
-  /** Current patterns (stable reference until a mutation occurs). */
-  getPatterns() {
-    return this.patterns;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    // Lazily hydrate from storage the first time anyone cares.
-    void this.ensureLoaded();
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  emit() {
-    this.listeners.forEach(l => l());
-  }
-  ensureLoaded() {
-    if (this.loaded) return Promise.resolve();
-    if (this.loadPromise) return this.loadPromise;
-    this.loadPromise = (async () => {
-      try {
-        const stored = await persistentStorage.getItem(devToolsStorageKeys.network.ignoredDomains());
-        // A mutation may have raced this read — never overwrite user intent.
-        if (stored && !this.dirty) {
-          const migrated = ensureDefaults(migratePatterns(JSON.parse(stored)));
-          this.patterns = migrated;
-        }
-      } catch {
-        // Silently fall back to defaults.
-      } finally {
-        this.loaded = true;
-        this.emit();
-      }
-    })();
-    return this.loadPromise;
-  }
-  persist() {
-    persistentStorage.setItem(devToolsStorageKeys.network.ignoredDomains(), JSON.stringify(this.patterns)).catch(() => {
-      // Silently fail — patterns remain in memory.
-    });
-  }
-  commit(next) {
-    this.dirty = true;
-    this.patterns = next;
-    this.emit();
-    this.persist();
-  }
-
-  /** Add a pattern (no-op if its value already exists). */
-  add(pattern) {
-    const value = pattern.value.trim();
-    if (!value) return;
-    if (this.patterns.some(p => p.value === value)) return;
-    this.commit([...this.patterns, {
-      value,
-      mode: pattern.mode
-    }]);
-  }
-
-  /** Remove a pattern by value. */
-  remove(value) {
-    if (!this.patterns.some(p => p.value === value)) return;
-    this.commit(this.patterns.filter(p => p.value !== value));
-  }
-
-  /** Add as `contains` if absent, otherwise remove (used by detail-view chips). */
-  toggle(value) {
-    const trimmed = value.trim();
-    if (!trimmed) return;
-    this.commit(this.patterns.some(p => p.value === trimmed) ? this.patterns.filter(p => p.value !== trimmed) : [...this.patterns, {
-      value: trimmed,
-      mode: "contains"
-    }]);
-  }
-
-  /** Flip an existing pattern between `contains` and `exact`. */
-  toggleMode(value) {
-    if (!this.patterns.some(p => p.value === value)) return;
-    this.commit(this.patterns.map(p => p.value === value ? {
-      ...p,
-      mode: p.mode === "contains" ? "exact" : "contains"
-    } : p));
-  }
-}
-export const ignoredPatternsStore = new IgnoredPatternsStore();
-/**
- * Mutations live at module scope so they keep a STABLE identity across
- * renders (same rationale as native: inline arrows handed every consumer a
- * fresh `toggle` per render and defeated `memo` downstream).
- */
-const addPattern = pattern => ignoredPatternsStore.add(pattern);
-const removePattern = value => ignoredPatternsStore.remove(value);
-const togglePattern = value => ignoredPatternsStore.toggle(value);
-const togglePatternMode = value => ignoredPatternsStore.toggleMode(value);
-
-/**
- * Subscribe to the shared ignored-patterns store. All consumers in a runtime
- * see the same patterns and the same mutations.
- */
-export function useIgnoredPatterns() {
-  const [patterns, setPatterns] = useState(() => ignoredPatternsStore.getPatterns());
-  useEffect(() => {
-    return ignoredPatternsStore.subscribe(() => {
-      setPatterns(ignoredPatternsStore.getPatterns());
-    });
-  }, []);
-  const values = useMemo(() => new Set(patterns.map(p => p.value)), [patterns]);
-  return {
-    patterns,
-    values,
-    add: addPattern,
-    remove: removePattern,
-    toggle: togglePattern,
-    toggleMode: togglePatternMode
-  };
-}
+"use strict";export*from"./ignoredPatternsStore.shared.js";

package/lib/module/stores/index.js

@@ -1,10 +1 @@
-"use strict";
-
-/**
- * Shared store utilities and base classes
- */
-
-export { BaseEventStore } from "./BaseEventStore.js";
-export { ignoredPatternsStore, useIgnoredPatterns, urlMatchesIgnoredPattern, isUrlIgnored } from "./ignoredPatternsStore";
-export { createToolStore } from "./createToolStore.js";
-export { ChangeLog } from "./ChangeLog.js";
+"use strict";export{BaseEventStore}from"./BaseEventStore.js";export{ignoredPatternsStore,useIgnoredPatterns,urlMatchesIgnoredPattern,isUrlIgnored}from"./ignoredPatternsStore";export{createToolStore}from"./createToolStore.js";export{ChangeLog}from"./ChangeLog.js";

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()})}}:{}}}