@buoy-gg/external-sync 7.0.41 → 7.0.42

package/lib/module/attachDeviceSync.js

@@ -1,290 +1 @@
-"use strict";
-
-import { LicenseManager } from "@buoy-gg/license";
-import { log } from "./utils/logger";
-import { registerToolFlusher, unregisterToolFlusher } from "./crashFlush";
-import { MAX_ACTION_RESULT_BYTES, MAX_SNAPSHOT_EMIT_BYTES, approxSizeOver } from "./emitBudget";
-import { SYNC_PROTOCOL_VERSION } from "./types";
-const LOG = "[ExternalSync]";
-
-/** Minimal socket surface the device-side bridge needs. */
-
-/**
- * "capture" records into the tool's store without pushing snapshots; "stream"
- * also emits on every change. See `DevToolWatchMessage.stream`.
- */
-
-/**
- * Device-side sync bridge (no React). A tool's adapter is only subscribed
- * while a dashboard is watching it (`devtool-watch`).
- */
-export function attachDeviceSync({
-  socket,
-  deviceId,
-  getTools,
-  watched,
-  throttleMs = 200,
-  enableLogs = false
-}) {
-  let disposed = false;
-  let brokerReady = false;
-  let accessGeneration = 0;
-  const allowed = () => !disposed && brokerReady && socket.connected && LicenseManager.hasAccountAccess();
-  const unsubs = new Map();
-  const lastEmit = {};
-  const timers = {};
-  const isForThisDevice = targetDeviceId => targetDeviceId === "All" || targetDeviceId === deviceId;
-  const safeEmit = (event, message) => {
-    if (!allowed()) return;
-    try {
-      socket.emit(event, message);
-    } catch (error) {
-      log(`${LOG} Failed to emit "${event}": ${error}. Payload must be JSON-serializable.`, enableLogs, "error");
-    }
-  };
-  const warnedOversized = new Set();
-  const sendSnapshot = toolId => {
-    if (!allowed()) return;
-    const tool = getTools()[toolId];
-    if (!tool) return;
-    lastEmit[toolId] = Date.now();
-    let payload;
-    try {
-      payload = tool.getSnapshot();
-    } catch {
-      return;
-    }
-    const {
-      over,
-      approxBytes
-    } = approxSizeOver(payload, MAX_SNAPSHOT_EMIT_BYTES);
-    if (over) {
-      if (!warnedOversized.has(toolId)) {
-        warnedOversized.add(toolId);
-        console.warn(`${LOG} "${toolId}" snapshot ≈${(approxBytes / 1e6).toFixed(1)}MB exceeds the ${MAX_SNAPSHOT_EMIT_BYTES / 1e6}MB sync budget — dropped (dashboard will be stale for this tool). The adapter should ship a wire-form snapshot (summaries + on-demand detail).`);
-      }
-      return;
-    }
-    const message = {
-      toolId,
-      persistentDeviceId: deviceId,
-      timestamp: lastEmit[toolId],
-      version: tool.version,
-      kind: "snapshot",
-      payload
-    };
-    safeEmit("devtool-sync", message);
-  };
-  const scheduleSnapshot = toolId => {
-    if (timers[toolId]) return;
-    const elapsed = Date.now() - (lastEmit[toolId] ?? 0);
-    if (elapsed >= throttleMs) {
-      sendSnapshot(toolId);
-      return;
-    }
-    timers[toolId] = setTimeout(() => {
-      delete timers[toolId];
-      sendSnapshot(toolId);
-    }, throttleMs - elapsed);
-  };
-
-  /**
-   * Emit a tool's snapshot immediately, cancelling any throttled push.
-   * The escape hatch for "the tree is about to die, get this out now" — see
-   * ./crashFlush. Ignores watch MODE: a crash flush is worth sending even to a
-   * dashboard that only asked to record.
-   *
-   * It does NOT ignore "is anyone there". Building a snapshot is the expensive
-   * part of this tool (deep-copying every captured entry, then walking it to
-   * price it), and `socket.emit` on a disconnected socket queues into
-   * socket.io's unbounded send buffer. Without these two guards, an app logging
-   * errors in a loop with no dashboard attached would pay that cost several
-   * times a second and grow the buffer until it ran out of memory — in a
-   * customer's app, for no observer.
-   */
-  const flushNow = toolId => {
-    if (!socket.connected) return;
-    if (!unsubs.has(toolId)) return; // nobody is watching this tool
-    if (timers[toolId]) {
-      clearTimeout(timers[toolId]);
-      delete timers[toolId];
-    }
-    sendSnapshot(toolId);
-  };
-  registerToolFlusher(flushNow);
-
-  /** The mode each currently-subscribed tool is wired for. */
-  const activeModes = new Map();
-  const watchTool = (toolId, mode) => {
-    if (!allowed()) return;
-    const tool = getTools()[toolId];
-    if (!tool) return;
-    if (unsubs.has(toolId)) {
-      if (activeModes.get(toolId) === mode) return;
-      // Mode changed (a streaming dashboard left, or arrived) — rewire, but
-      // do NOT drop the subscription in between: releasing it would take the
-      // store's subscriber count to 0 and stop capture mid-flight.
-      const previous = unsubs.get(toolId);
-      unsubs.set(toolId, tool.subscribe(mode === "stream" ? () => scheduleSnapshot(toolId) : () => {}));
-      activeModes.set(toolId, mode);
-      previous?.();
-      log(`${LOG} "${toolId}" watch mode → ${mode}`, enableLogs);
-      return;
-    }
-    unsubs.set(toolId, tool.subscribe(mode === "stream" ? () => scheduleSnapshot(toolId) : () => {}));
-    activeModes.set(toolId, mode);
-    log(`${LOG} Watching "${toolId}" (${mode})`, enableLogs);
-  };
-  const unwatchTool = toolId => {
-    unsubs.get(toolId)?.();
-    unsubs.delete(toolId);
-    activeModes.delete(toolId);
-    if (timers[toolId]) {
-      clearTimeout(timers[toolId]);
-      delete timers[toolId];
-    }
-    log(`${LOG} Stopped watching "${toolId}"`, enableLogs);
-  };
-  const sendCapabilities = () => {
-    const message = {
-      persistentDeviceId: deviceId,
-      protocolVersion: SYNC_PROTOCOL_VERSION,
-      tools: Object.entries(getTools()).map(([toolId, tool]) => ({
-        toolId,
-        version: tool.version,
-        actions: Object.keys(tool.actions ?? {})
-      }))
-    };
-    safeEmit("devtool-capabilities", message);
-  };
-  const handleWatch = message => {
-    if (!allowed() || !isForThisDevice(message.targetDeviceId)) return;
-    if (message.watching) {
-      // `stream` is only trustworthy once a broker has merged every
-      // dashboard's request (see DevToolWatchMessage.consolidated). Without
-      // that, an unmerged capture request could quiet a dashboard that is
-      // actively painting, so default to streaming.
-      const mode = message.consolidated === true && message.stream === false ? "capture" : "stream";
-      watched.set(message.toolId, mode);
-      watchTool(message.toolId, mode);
-      // Only a streaming audience gets the priming snapshot. A capture-only
-      // client reads with `request-devtool-state` when it actually wants one;
-      // pushing here would hand it the very payload it asked not to receive.
-      if (mode === "stream") sendSnapshot(message.toolId);
-    } else {
-      watched.delete(message.toolId);
-      unwatchTool(message.toolId);
-    }
-  };
-  const handleRequest = message => {
-    if (!allowed() || !isForThisDevice(message.targetDeviceId)) return;
-    sendSnapshot(message.toolId);
-  };
-  const handleAction = async message => {
-    if (!allowed() || !isForThisDevice(message.targetDeviceId)) return;
-    const startedAt = accessGeneration;
-    const {
-      requestId,
-      toolId,
-      action,
-      params
-    } = message;
-    const result = {
-      requestId,
-      toolId,
-      action,
-      persistentDeviceId: deviceId,
-      timestamp: Date.now(),
-      ok: false
-    };
-    const tool = getTools()[toolId];
-    const fn = tool?.actions?.[action];
-    if (!fn) {
-      result.error = tool ? `Unknown action "${action}" on tool "${toolId}"` : `Unknown tool "${toolId}"`;
-      safeEmit("devtool-action-result", result);
-      return;
-    }
-    try {
-      result.result = await fn(params);
-      result.ok = true;
-    } catch (error) {
-      result.error = error instanceof Error ? error.message : String(error);
-    }
-
-    // A subsequent admission cannot authorize work from the previous session.
-    if (startedAt !== accessGeneration || !allowed()) return;
-    if (result.ok) {
-      const {
-        over,
-        approxBytes
-      } = approxSizeOver(result.result, MAX_ACTION_RESULT_BYTES);
-      if (over) {
-        result.ok = false;
-        result.result = undefined;
-        result.error = `Result ≈${(approxBytes / 1e6).toFixed(1)}MB exceeds the ${MAX_ACTION_RESULT_BYTES / 1e6}MB sync budget. Narrow the request (e.g. includeValues:false, a limit, or a more specific action).`;
-      }
-    }
-    result.timestamp = Date.now();
-    safeEmit("devtool-action-result", result);
-  };
-  const dropToolWork = () => {
-    accessGeneration += 1;
-    for (const toolId of [...unsubs.keys()]) unwatchTool(toolId);
-    watched.clear();
-    for (const timer of Object.values(timers)) clearTimeout(timer);
-    const buffered = socket;
-    if (buffered.sendBuffer) buffered.sendBuffer = buffered.sendBuffer.filter(packet => !["devtool-sync", "devtool-capabilities", "devtool-action-result", "device-license"].includes(String(packet.data?.[0])));
-  };
-  const announceAccount = () => {
-    const state = LicenseManager.getState();
-    socket.emit("device-license", {
-      tier: state.tier,
-      isPro: state.isPro ? "1" : "0"
-    });
-    sendCapabilities();
-  };
-  const handleAccess = message => {
-    brokerReady = message?.protocol === 1 && message.ready === true;
-    if (!allowed()) dropToolWork();else announceAccount();
-  };
-  const offAccount = LicenseManager.subscribe(() => {
-    if (!LicenseManager.hasAccountAccess()) {
-      if (socket.connected) socket.emit("device-license", {
-        tier: "locked",
-        isPro: "0"
-      });
-      dropToolWork();
-    } else if (allowed()) announceAccount();
-  });
-  const handleConnect = () => {
-    brokerReady = false;
-    socket.emit("buoy:access:request");
-  };
-  const handleDisconnect = () => {
-    brokerReady = false;
-    dropToolWork();
-  };
-  socket.on("buoy:access", handleAccess);
-  for (const [toolId, mode] of watched) {
-    if (getTools()[toolId]) watchTool(toolId, mode);
-  }
-  socket.on("connect", handleConnect);
-  socket.on("disconnect", handleDisconnect);
-  socket.on("devtool-watch", handleWatch);
-  socket.on("request-devtool-state", handleRequest);
-  socket.on("devtool-action", handleAction);
-  if (socket.connected) handleConnect();
-  return () => {
-    disposed = true;
-    offAccount();
-    socket.off("buoy:access", handleAccess);
-    dropToolWork();
-    unregisterToolFlusher(flushNow);
-    socket.off("connect", handleConnect);
-    socket.off("disconnect", handleDisconnect);
-    socket.off("devtool-watch", handleWatch);
-    socket.off("request-devtool-state", handleRequest);
-    socket.off("devtool-action", handleAction);
-    for (const toolId of [...unsubs.keys()]) unwatchTool(toolId);
-  };
-}
+"use strict";import{LicenseManager as w}from"@buoy-gg/license";import{log as A}from"./utils/logger";import{registerToolFlusher as Q,unregisterToolFlusher as Z}from"./crashFlush";import{MAX_ACTION_RESULT_BYTES as G,MAX_SNAPSHOT_EMIT_BYTES as X,approxSizeOver as H}from"./emitBudget";import{SYNC_PROTOCOL_VERSION as k}from"./types";import{realNow as T}from"./realNow";const p="[ExternalSync]";export function attachDeviceSync({socket:n,deviceId:h,getTools:f,watched:m,throttleMs:N=200,enableLogs:v=false}){let _=false;let y=false;let O=0;const i=()=>!_&&y&&n.connected&&w.hasAccountAccess();const c=new Map;const B={};const o={};const M=e=>e==="All"||e===h;const b=(e,t)=>{if(!i())return;try{n.emit(e,t)}catch(r){A(`${p} Failed to emit "${e}": ${r}. Payload must be JSON-serializable.`,v,"error")}};const q=new Set;const u=e=>{if(!i())return;const t=f()[e];if(!t)return;B[e]=T();let r;try{r=t.getSnapshot()}catch{return}const{over:a,approxBytes:l}=H(r,X);if(a){if(!q.has(e)){q.add(e);console.warn(`${p} "${e}" snapshot \u2248${(l/1e6).toFixed(1)}MB exceeds the ${X/1e6}MB sync budget \u2014 dropped (dashboard will be stale for this tool). The adapter should ship a wire-form snapshot (summaries + on-demand detail).`)}return}const D={toolId:e,persistentDeviceId:h,timestamp:B[e],version:t.version,kind:"snapshot",payload:r};b("devtool-sync",D)};const F=e=>{if(o[e])return;const t=T()-(B[e]??0);if(t>=N){u(e);return}o[e]=setTimeout(()=>{delete o[e];u(e)},N-t)};const P=e=>{if(!n.connected)return;if(!c.has(e))return;if(o[e]){clearTimeout(o[e]);delete o[e]}u(e)};Q(P);const $=new Map;const R=(e,t)=>{if(!i())return;const r=f()[e];if(!r)return;if(c.has(e)){if($.get(e)===t)return;const a=c.get(e);c.set(e,r.subscribe(t==="stream"?()=>F(e):()=>{}));$.set(e,t);a?.();A(`${p} "${e}" watch mode \u2192 ${t}`,v);return}c.set(e,r.subscribe(t==="stream"?()=>F(e):()=>{}));$.set(e,t);A(`${p} Watching "${e}" (${t})`,v)};const x=e=>{c.get(e)?.();c.delete(e);$.delete(e);if(o[e]){clearTimeout(o[e]);delete o[e]}A(`${p} Stopped watching "${e}"`,v)};const J=()=>{const e={persistentDeviceId:h,protocolVersion:k,tools:Object.entries(f()).map(([t,r])=>({toolId:t,version:r.version,actions:Object.keys(r.actions??{})}))};b("devtool-capabilities",e)};const C=e=>{if(!i()||!M(e.targetDeviceId))return;if(e.watching){const t=e.consolidated===true&&e.stream===false?"capture":"stream";m.set(e.toolId,t);R(e.toolId,t);if(t==="stream")u(e.toolId)}else{m.delete(e.toolId);x(e.toolId)}};const g=e=>{if(!i()||!M(e.targetDeviceId))return;u(e.toolId)};const j=async e=>{if(!i()||!M(e.targetDeviceId))return;const t=O;const{requestId:r,toolId:a,action:l,params:D}=e;const s={requestId:r,toolId:a,action:l,persistentDeviceId:h,timestamp:T(),ok:false};const W=f()[a];const Y=W?.actions?.[l];if(!Y){s.error=W?`Unknown action "${l}" on tool "${a}"`:`Unknown tool "${a}"`;b("devtool-action-result",s);return}try{s.result=await Y(D);s.ok=true}catch(d){s.error=d instanceof Error?d.message:String(d)}if(t!==O||!i())return;if(s.ok){const{over:d,approxBytes:K}=H(s.result,G);if(d){s.ok=false;s.result=void 0;s.error=`Result \u2248${(K/1e6).toFixed(1)}MB exceeds the ${G/1e6}MB sync budget. Narrow the request (e.g. includeValues:false, a limit, or a more specific action).`}}s.timestamp=T();b("devtool-action-result",s)};const S=()=>{O+=1;for(const t of[...c.keys()])x(t);m.clear();for(const t of Object.values(o))clearTimeout(t);const e=n;if(e.sendBuffer)e.sendBuffer=e.sendBuffer.filter(t=>!["devtool-sync","devtool-capabilities","devtool-action-result","device-license"].includes(String(t.data?.[0])))};const z=()=>{const e=w.getState();n.emit("device-license",{tier:e.tier,isPro:e.isPro?"1":"0"});J()};const U=e=>{y=e?.protocol===1&&e.ready===true;if(!i())S();else z()};const L=w.subscribe(()=>{if(!w.hasAccountAccess()){if(n.connected)n.emit("device-license",{tier:"locked",isPro:"0"});S()}else if(i())z()});const E=()=>{y=false;n.emit("buoy:access:request")};const V=()=>{y=false;S()};n.on("buoy:access",U);for(const[e,t]of m){if(f()[e])R(e,t)}n.on("connect",E);n.on("disconnect",V);n.on("devtool-watch",C);n.on("request-devtool-state",g);n.on("devtool-action",j);if(n.connected)E();return()=>{_=true;L();n.off("buoy:access",U);S();Z(P);n.off("connect",E);n.off("disconnect",V);n.off("devtool-watch",C);n.off("request-devtool-state",g);n.off("devtool-action",j);for(const e of[...c.keys()])x(e)}}

package/lib/module/brokerAccess.js

@@ -1,25 +1 @@
-"use strict";
-
-/** Wait for an account-aware broker before publishing any tool capabilities. */
-
-export function watchBrokerAccess(socket, update) {
-  const lock = () => update(false);
-  const request = () => {
-    lock();
-    socket.emit("buoy:access:request");
-  };
-  const access = message => {
-    const info = message;
-    update(info?.protocol === 1 && info?.ready === true);
-  };
-  socket.on("connect", request);
-  socket.on("disconnect", lock);
-  socket.on("buoy:access", access);
-  lock();
-  if (socket.connected) request();
-  return () => {
-    socket.off("connect", request);
-    socket.off("disconnect", lock);
-    socket.off("buoy:access", access);
-  };
-}
+"use strict";export function watchBrokerAccess(c,e){const n=()=>e(false);const o=()=>{n();c.emit("buoy:access:request")};const s=r=>{const t=r;e(t?.protocol===1&&t?.ready===true)};c.on("connect",o);c.on("disconnect",n);c.on("buoy:access",s);n();if(c.connected)o();return()=>{c.off("connect",o);c.off("disconnect",n);c.off("buoy:access",s)}}

package/lib/module/crashFlush.js

@@ -1,67 +1 @@
-"use strict";
-
-/**
- * crashFlush — a global "push this tool's snapshot RIGHT NOW" seam.
- *
- * Why a global and not an import: the device sync bridge lives in the React
- * tree (`useExternalSync`), but the moment worth capturing most — a fatal
- * render error — is the moment that tree dies. React unmounts the root right
- * after the error is reported, which detaches the bridge and cancels the
- * normal throttled snapshot push, so the crash never reaches the dashboard or
- * the MCP server. The app then looks like it simply stopped answering.
- *
- * A tool that knows it is about to lose the tree (see @buoy-gg/console's fatal
- * hook) calls {@link flushToolSyncNow} synchronously from its error handler,
- * while the socket is still attached, and the snapshot goes out immediately.
- *
- * It is a global because the tools deliberately do NOT depend on this package
- * (their adapters are duck-typed and picked up by auto-discovery), so there is
- * no import edge to hang a registry on. Callers must treat it as best-effort:
- * absent bridge = no-op.
- */
-
-const FLUSH_KEY = "__buoyFlushToolSync";
-
-/** Emit `toolId`'s current snapshot now, bypassing the throttle. */
-
-/**
- * A SET, not a single slot: React can mount a second provider (or re-run the
- * attach effect setup before the old one's cleanup) so two bridges are briefly
- * live at once. A last-writer-wins slot would let the second registration
- * silently disable the first's crash flush — failing in exactly the moment it
- * is the only thing that gets the crash out, with no error and no log.
- */
-
-function flushers() {
-  const g = globalThis;
-  if (!g[FLUSH_KEY]) g[FLUSH_KEY] = new Set();
-  return g[FLUSH_KEY];
-}
-
-/** Install a bridge's flusher. Called by `attachDeviceSync`. */
-export function registerToolFlusher(flush) {
-  flushers().add(flush);
-}
-
-/** Remove one bridge's flusher, leaving any others intact. */
-export function unregisterToolFlusher(flush) {
-  flushers().delete(flush);
-}
-
-/**
- * Push a tool's snapshot immediately through every attached sync bridge.
- * Never throws — a crash path must not crash.
- */
-export function flushToolSyncNow(toolId) {
-  try {
-    for (const flush of flushers()) {
-      try {
-        flush(toolId);
-      } catch {
-        // One bad bridge must not stop the others.
-      }
-    }
-  } catch {
-    // Best-effort by design.
-  }
-}
+"use strict";const t="__buoyFlushToolSync";function e(){const o=globalThis;if(!o[t])o[t]=new Set;return o[t]}export function registerToolFlusher(o){e().add(o)}export function unregisterToolFlusher(o){e().delete(o)}export function flushToolSyncNow(o){try{for(const n of e()){try{n(o)}catch{}}}catch{}}

package/lib/module/emitBudget.js

@@ -1,52 +1 @@
-"use strict";
-
-/**
- * Emit-layer byte budgets — the choke-point guard.
- *
- * Every adapter's snapshot and every action result funnels through
- * socket.emit, whose serializer walks the ENTIRE payload synchronously on
- * the JS thread (and JSON.stringify does not honor structural sharing).
- * Per-adapter guards get missed — the redux adapter shipping raw state
- * trees froze and native-OOM-crashed enterprise apps whenever a dashboard
- * was connected. One budget here closes every adapter's hole at once:
- * oversized payloads are dropped (snapshots) or replaced with an error
- * (action results) instead of being serialized.
- *
- * The estimator is O(limit) — early-abort walk, O(1) for giant strings —
- * never O(payload). Copied per-package by design (see events/redux copies).
- */
-
-/** Max approx bytes for one tool snapshot emit. */
-export const MAX_SNAPSHOT_EMIT_BYTES = 2 * 1024 * 1024;
-/** Max approx bytes for one action-result emit (explicit requests get more). */
-export const MAX_ACTION_RESULT_BYTES = 8 * 1024 * 1024;
-export function approxSizeOver(value, limit) {
-  let bytes = 0;
-  const stack = [value];
-  const seen = new Set();
-  while (stack.length > 0) {
-    if (bytes > limit) return {
-      over: true,
-      approxBytes: bytes
-    };
-    const v = stack.pop();
-    if (v === null || v === undefined) bytes += 4;else if (typeof v === "string") bytes += v.length + 2;else if (typeof v === "number") bytes += 8;else if (typeof v === "boolean") bytes += 5;else if (typeof v === "object") {
-      if (seen.has(v)) continue;
-      seen.add(v);
-      if (Array.isArray(v)) {
-        bytes += 2 + v.length;
-        for (let i = 0; i < v.length; i++) stack.push(v[i]);
-      } else {
-        bytes += 2;
-        for (const k in v) {
-          bytes += k.length + 4;
-          stack.push(v[k]);
-        }
-      }
-    } else bytes += 4;
-  }
-  return {
-    over: bytes > limit,
-    approxBytes: bytes
-  };
-}
+"use strict";export const MAX_SNAPSHOT_EMIT_BYTES=2*1024*1024;export const MAX_ACTION_RESULT_BYTES=8*1024*1024;export function approxSizeOver(p,s){let t=0;const o=[p];const r=new Set;while(o.length>0){if(t>s)return{over:true,approxBytes:t};const e=o.pop();if(e===null||e===void 0)t+=4;else if(typeof e==="string")t+=e.length+2;else if(typeof e==="number")t+=8;else if(typeof e==="boolean")t+=5;else if(typeof e==="object"){if(r.has(e))continue;r.add(e);if(Array.isArray(e)){t+=2+e.length;for(let n=0;n<e.length;n++)o.push(e[n])}else{t+=2;for(const n in e){t+=n.length+4;o.push(e[n])}}}else t+=4}return{over:t>s,approxBytes:t}}

package/lib/module/index.js

@@ -1,29 +1 @@
-"use strict";
-
-// ============================================================
-// HOOKS
-// ============================================================
-export { useExternalSync } from "./useExternalSync";
-export { useExternalSyncSocket } from "./useExternalSyncSocket";
-
-// ============================================================
-// BROKER URL DERIVATION
-// ============================================================
-export { getDefaultSocketURL, getMetroHost, DEFAULT_BROKER_PORT } from "./utils/getDefaultSocketURL";
-
-// ============================================================
-// CRASH FLUSH (get a tool's snapshot out before the tree dies)
-// ============================================================
-export { flushToolSyncNow, registerToolFlusher, unregisterToolFlusher } from "./crashFlush";
-// ============================================================
-// SYNC STATUS (read by the floating menu's settings modal)
-// ============================================================
-export { getSyncStatus, setSyncStatus, subscribeSyncStatus } from "./syncStatusStore";
-// ============================================================
-// PROTOCOL
-// ============================================================
-export { SYNC_PROTOCOL_VERSION } from "./types";
-
-// ============================================================
-// TYPES
-// ============================================================
+"use strict";export{useExternalSync}from"./useExternalSync";export{useExternalSyncSocket}from"./useExternalSyncSocket";export{getDefaultSocketURL,getMetroHost,DEFAULT_BROKER_PORT}from"./utils/getDefaultSocketURL";export{flushToolSyncNow,registerToolFlusher,unregisterToolFlusher}from"./crashFlush";export{getSyncStatus,setSyncStatus,subscribeSyncStatus}from"./syncStatusStore";export{SYNC_PROTOCOL_VERSION}from"./types";

package/lib/module/realNow.js

@@ -0,0 +1 @@
+"use strict";export function realNow(){const e=globalThis.__buoyRealNow;return typeof e==="function"?e():Date.now()}function l(){const e=globalThis.__buoyRealTimers;return e??globalThis}export function realSetTimeout(e,t){return l().setTimeout(e,t)}export function realClearTimeout(e){l().clearTimeout(e)}export function withRealClock(e){const t=globalThis.__buoyWithRealClock;return typeof t==="function"?t(e):e()}const s=["_resetPingTimeout","_hasPingExpired"];export function pinSocketTimers(e){const t=e?.io;if(!t||t.__buoyRealTimers)return;const i=o=>{if(!o)return;o.setTimeoutFn=realSetTimeout;o.clearTimeoutFn=realClearTimeout;for(const n of s){const r=o[n];if(typeof r!=="function"||r.__buoyReal)continue;const c=function(...a){return withRealClock(()=>r.apply(this,a))};c.__buoyReal=true;o[n]=c}};i(t);i(t.engine);const u=t.open;if(typeof u==="function"){t.open=function(...o){const n=u.apply(this,o);i(this?.engine);return n}}t.__buoyRealTimers=true}

package/lib/module/syncStatusStore.js

@@ -1,34 +1 @@
-"use strict";
-
-/**
- * Module-level desktop-sync status, written by useExternalSyncSocket and
- * read by the floating menu's settings modal (via useSyncExternalStore).
- * Lives here rather than in core because only the socket hook knows the
- * platform-rewritten URL and every connection transition — including for
- * apps that call the hook directly instead of using zero-config sync.
- */
-
-let status = {
-  targetURL: null,
-  state: "idle",
-  lastError: null,
-  since: 0
-};
-const listeners = new Set();
-export function setSyncStatus(patch) {
-  status = {
-    ...status,
-    ...patch,
-    since: Date.now()
-  };
-  listeners.forEach(listener => listener());
-}
-export function getSyncStatus() {
-  return status;
-}
-export function subscribeSyncStatus(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
+"use strict";import{realNow as s}from"./realNow";let e={targetURL:null,state:"idle",lastError:null,since:0};const n=new Set;export function setSyncStatus(t){e={...e,...t,since:s()};n.forEach(r=>r())}export function getSyncStatus(){return e}export function subscribeSyncStatus(t){n.add(t);return()=>{n.delete(t)}}

package/lib/module/types.js

@@ -1,93 +1 @@
-"use strict";
-
-// ============================================================
-// DEVTOOL SYNC PROTOCOL (v1)
-//
-// Topology: device is a Socket.IO client; the desktop app hosts
-// the server (broker) and one or more dashboard UIs. The server
-// routes messages between dashboards and devices.
-//
-// Device -> server/dashboard events:
-//   "devtool-capabilities"  DeviceCapabilitiesMessage
-//   "devtool-sync"          DevToolSyncMessage
-//   "devtool-action-result" DevToolActionResultMessage
-//
-// Dashboard/server -> device events:
-//   "devtool-watch"         DevToolWatchMessage
-//   "request-devtool-state" DevToolRequestMessage
-//   "devtool-action"        DevToolActionMessage
-//
-// Backpressure contract: the device sends nothing for a tool until
-// it receives `devtool-watch {watching: true}` for it. The SERVER is
-// responsible for consolidating watch state across dashboards (and
-// for sending `watching: false` when the last watching dashboard
-// closes a panel or disconnects). The device just obeys.
-// ============================================================
-
-/** Version of the envelope/event contract itself (not tool payloads). */
-export const SYNC_PROTOCOL_VERSION = 1;
-
-/** What a sync payload represents. "events"/"diff" reserved for future use. */
-
-// ============================================================
-// TOOL ADAPTER
-// ============================================================
-
-/** A remote-invocable action. Thrown errors are reported back to the dashboard. */
-
-/**
- * The contract each dev tool implements to become remotely syncable.
- * Works with BaseEventStore or any pattern exposing subscribe + getSnapshot.
- *
- * Payloads (snapshots and action results) must be JSON-serializable —
- * no functions, circular references, or class instances.
- */
-
-// ============================================================
-// DEVICE -> DASHBOARD MESSAGES
-// ============================================================
-
-/** Announces available tools + actions on connect and when tools change. */
-
-/** Carries a tool's state to the dashboard. */
-
-/** Response to a `devtool-action` request. */
-
-// ============================================================
-// DASHBOARD -> DEVICE MESSAGES
-// ============================================================
-
-/**
- * Server-consolidated signal that a tool gained/lost its audience.
- *
- * `watching` arms CAPTURE: the device subscribes to the tool, which is what
- * makes its store start recording. `stream` decides whether the device also
- * PUSHES a snapshot on every change (throttled), which is the expensive half —
- * it serializes the whole payload on the JS thread ~5x/sec.
- *
- * Those are separate because their audiences are: a dashboard renders every
- * snapshot, so it wants both. A request/response client (MCP) reads on demand
- * via `request-devtool-state` and would throw the stream away — but it still
- * needs the device to be RECORDING between its reads, or it only ever sees an
- * empty list and concludes the app made no requests.
- */
-
-/** Explicit request for a tool's current state (works even while unwatched). */
-
-/** Invokes a registered action on the device. */
-
-// ============================================================
-// HOOK PROPS
-// ============================================================
-
-// ============================================================
-// PLATFORM
-// ============================================================
-
-/**
- * Valid platform operating systems that can be used with React Native
- */
-
-// ============================================================
-// SOCKET HOOK PROPS
-// ============================================================
+"use strict";export const SYNC_PROTOCOL_VERSION=1;