@buoy-gg/mcp 4.0.1 → 5.0.0

package/dist/chunk-55UIOHVS.mjs

@@ -1,1145 +0,0 @@
-// src/config.ts
-import { DEFAULT_BROKER_PORT } from "@buoy-gg/sync-broker";
-var BROKER_PORT = DEFAULT_BROKER_PORT;
-var BROKER_URL = `http://localhost:${BROKER_PORT}`;
-var DEFAULT_ACTION_TIMEOUT_MS = 15e3;
-var DEFAULT_SNAPSHOT_TIMEOUT_MS = 5e3;
-var DASHBOARD_NAME = "Dashboard";
-var ALL_DEVICES = "All";
-
-// src/sync/SyncClient.ts
-import http from "http";
-import { randomUUID } from "crypto";
-import { io as ioClient } from "socket.io-client";
-import {
-  createBroker
-} from "@buoy-gg/sync-broker";
-var SyncClient = class {
-  constructor(opts = {}) {
-    this.socket = null;
-    this.broker = null;
-    /** Latest capabilities announce per deviceId. */
-    this.capabilities = /* @__PURE__ */ new Map();
-    /** Latest device list from the broker's `all-devices-update`. */
-    this.devices = [];
-    /** Latest snapshot payload per `${deviceId}::${toolId}`. */
-    this.snapshots = /* @__PURE__ */ new Map();
-    /** Tools we've asked the broker to keep streaming, as `${deviceId}::${toolId}`. */
-    this.watching = /* @__PURE__ */ new Set();
-    /** In-flight actions awaiting a result, keyed by requestId. */
-    this.pendingActions = /* @__PURE__ */ new Map();
-    /** Callbacks waiting for the next snapshot of `${deviceId}::${toolId}`. */
-    this.snapshotWaiters = /* @__PURE__ */ new Map();
-    this.port = opts.port ?? BROKER_PORT;
-    this.url = opts.url ?? (opts.port ? `http://localhost:${opts.port}` : BROKER_URL);
-    this.actionTimeoutMs = opts.actionTimeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS;
-    this.log = opts.log ?? ((msg) => process.stderr.write(`[buoy-mcp] ${msg}
-`));
-    this.autoSpawn = opts.autoSpawnBroker ?? true;
-  }
-  // ----------------------------------------------------------------
-  // Lifecycle
-  // ----------------------------------------------------------------
-  /** Connect to a running broker, or spawn one in-process, then handshake. */
-  async start() {
-    const running = await probeBroker(this.url);
-    let mode = "connected";
-    if (!running) {
-      if (!this.autoSpawn) {
-        throw new Error(
-          `No Buoy broker reachable at ${this.url} and autoSpawnBroker is off. Start the Buoy desktop app, or enable autoSpawnBroker.`
-        );
-      }
-      this.log(`no broker at ${this.url} \u2014 spawning one in-process on :${this.port}`);
-      this.broker = createBroker({
-        port: this.port,
-        onError: (e) => this.log(`broker error: ${e.code ?? e.message}`)
-      });
-      await waitForBroker(this.url);
-      mode = "spawned";
-    } else {
-      this.log(`found a running broker at ${this.url} \u2014 connecting as a dashboard`);
-    }
-    await this.connectSocket();
-    return mode;
-  }
-  connectSocket() {
-    return new Promise((resolve, reject) => {
-      const socket = ioClient(this.url, {
-        transports: ["websocket"],
-        query: { deviceName: DASHBOARD_NAME },
-        reconnection: true,
-        reconnectionDelay: 500,
-        timeout: 4e3
-      });
-      this.socket = socket;
-      let settled = false;
-      const onConnect = () => {
-        if (settled) return;
-        settled = true;
-        this.log("connected to broker");
-        resolve();
-      };
-      socket.on("connect", onConnect);
-      socket.once("connect_error", (err) => {
-        if (settled) return;
-        settled = true;
-        reject(new Error(`failed to connect to broker at ${this.url}: ${err.message}`));
-      });
-      socket.on("devtool-capabilities", (msg) => {
-        this.capabilities.set(msg.persistentDeviceId, msg);
-      });
-      socket.on("all-devices-update", (list) => {
-        if (Array.isArray(list)) this.devices = list;
-      });
-      socket.on("devtool-sync", (msg) => {
-        const key = snapKey(msg.persistentDeviceId, msg.toolId);
-        this.snapshots.set(key, msg.payload);
-        const waiters = this.snapshotWaiters.get(key);
-        if (waiters && waiters.length) {
-          this.snapshotWaiters.set(key, []);
-          for (const w of waiters) w(msg.payload);
-        }
-      });
-      socket.on("devtool-action-result", (msg) => {
-        const pending = this.pendingActions.get(msg.requestId);
-        if (!pending) return;
-        this.pendingActions.delete(msg.requestId);
-        clearTimeout(pending.timer);
-        pending.resolve(msg);
-      });
-    });
-  }
-  /** Disconnect and tear down a spawned broker, if any. */
-  async stop() {
-    for (const [, p] of this.pendingActions) {
-      clearTimeout(p.timer);
-      p.reject(new Error("SyncClient stopped"));
-    }
-    this.pendingActions.clear();
-    this.socket?.close();
-    this.socket = null;
-    if (this.broker) {
-      await this.broker.close();
-      this.broker = null;
-    }
-  }
-  // ----------------------------------------------------------------
-  // Queries
-  // ----------------------------------------------------------------
-  /** All devices the broker knows about, merged with their advertised tools. */
-  listDevices() {
-    return this.devices.filter((d) => d.deviceName !== DASHBOARD_NAME && d.deviceId).map((d) => {
-      const caps = this.capabilities.get(d.deviceId);
-      return {
-        deviceId: d.deviceId,
-        deviceName: d.deviceName,
-        platform: d.platform,
-        isConnected: d.isConnected !== false,
-        isPro: d.isPro === true,
-        tools: caps?.tools ?? []
-      };
-    });
-  }
-  /** Connected devices only. */
-  connectedDevices() {
-    return this.listDevices().filter((d) => d.isConnected);
-  }
-  /** Actions advertised for a tool, with the devices offering it. */
-  toolActions(toolId) {
-    return this.listDevices().map((d) => {
-      const tool = d.tools.find((t) => t.toolId === toolId);
-      return tool ? { deviceId: d.deviceId, deviceName: d.deviceName, actions: tool.actions } : null;
-    }).filter((x) => x !== null);
-  }
-  /**
-   * Resolve a concrete target deviceId. If `deviceId` is given it's used as-is.
-   * Otherwise, if exactly one device is connected, that one is chosen; if none
-   * or many, an informative error is thrown (callers can pass "All" explicitly).
-   */
-  resolveDevice(deviceId) {
-    if (deviceId) return deviceId;
-    const connected = this.connectedDevices();
-    if (connected.length === 1) return connected[0].deviceId;
-    if (connected.length === 0) {
-      throw new Error("No devices are connected to the broker. Open the app with Buoy devtools running.");
-    }
-    const list = connected.map((d) => `${d.deviceName} (${d.deviceId})`).join(", ");
-    throw new Error(`Multiple devices connected \u2014 specify deviceId. Connected: ${list}`);
-  }
-  /**
-   * Resolve a target device AND require it to be on Buoy Pro. The Buoy MCP is a
-   * Pro feature: data/action tools call this so a free app can't be driven
-   * through the MCP. The app's Keygen-validated license is the source of truth
-   * (the device reports it over the broker); this just reads that flag.
-   *
-   * `list_devices` deliberately does NOT call this — a free user can still see
-   * their device and that it's unlicensed, which explains why everything else
-   * is blocked.
-   */
-  requireProDevice(deviceId) {
-    const proMsg = (name) => `Buoy Pro is required to use the MCP.${name ? ` The connected app "${name}" is on the free tier.` : ""} Upgrade to Buoy Pro in the app to enable MCP access (run \`list_devices\` to check status).`;
-    if (deviceId === ALL_DEVICES) {
-      if (!this.connectedDevices().some((d) => d.isPro)) throw new Error(proMsg());
-      return ALL_DEVICES;
-    }
-    const target = this.resolveDevice(deviceId);
-    const dev = this.connectedDevices().find((d) => d.deviceId === target);
-    if (!dev?.isPro) throw new Error(proMsg(dev?.deviceName));
-    return target;
-  }
-  // ----------------------------------------------------------------
-  // Watch + snapshots
-  // ----------------------------------------------------------------
-  ensureWatching(toolId, targetDeviceId) {
-    const key = snapKey(targetDeviceId, toolId);
-    if (this.watching.has(key)) return;
-    this.watching.add(key);
-    this.socket?.emit("devtool-watch", { toolId, targetDeviceId, watching: true });
-  }
-  /** Stop streaming a tool (releases the device-side backpressure). */
-  unwatch(toolId, targetDeviceId) {
-    const key = snapKey(targetDeviceId, toolId);
-    if (!this.watching.delete(key)) return;
-    this.socket?.emit("devtool-watch", { toolId, targetDeviceId, watching: false });
-  }
-  /** Last snapshot received for a tool/device, if any. */
-  cachedSnapshot(toolId, deviceId) {
-    return this.snapshots.get(snapKey(deviceId, toolId));
-  }
-  /**
-   * Get a tool's current state. Starts watching (so the device begins emitting),
-   * explicitly requests state, and resolves with the next snapshot. Falls back
-   * to the last cached snapshot if the request times out.
-   */
-  async getSnapshot(toolId, deviceId, opts = {}) {
-    const target = this.resolveDevice(deviceId);
-    const key = snapKey(target, toolId);
-    this.ensureWatching(toolId, target);
-    const next = this.waitForSnapshot(key, opts.timeoutMs ?? DEFAULT_SNAPSHOT_TIMEOUT_MS);
-    this.socket?.emit("request-devtool-state", { toolId, targetDeviceId: target });
-    const payload = await next;
-    if (payload !== void 0) return { deviceId: target, payload };
-    const cached = this.snapshots.get(key);
-    if (cached !== void 0) return { deviceId: target, payload: cached };
-    throw new Error(`Timed out waiting for "${toolId}" state from ${target} (is the tool active?)`);
-  }
-  waitForSnapshot(key, timeoutMs) {
-    return new Promise((resolve) => {
-      const waiters = this.snapshotWaiters.get(key) ?? [];
-      const timer = setTimeout(() => {
-        const remaining = (this.snapshotWaiters.get(key) ?? []).filter((w) => w !== onSnap);
-        this.snapshotWaiters.set(key, remaining);
-        resolve(void 0);
-      }, timeoutMs);
-      const onSnap = (payload) => {
-        clearTimeout(timer);
-        resolve(payload);
-      };
-      waiters.push(onSnap);
-      this.snapshotWaiters.set(key, waiters);
-    });
-  }
-  // ----------------------------------------------------------------
-  // Actions
-  // ----------------------------------------------------------------
-  /**
-   * Invoke a remote action on a device and await its result. Pass deviceId to
-   * target one device, or "All" to broadcast (resolves with the first responder).
-   */
-  async callAction(toolId, action, params, deviceId, opts = {}) {
-    const target = deviceId === ALL_DEVICES ? ALL_DEVICES : this.resolveDevice(deviceId);
-    if (!this.socket) throw new Error("SyncClient is not connected");
-    const requestId = randomUUID();
-    const timeoutMs = opts.timeoutMs ?? this.actionTimeoutMs;
-    const result = await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pendingActions.delete(requestId);
-        reject(new Error(`Action "${toolId}.${action}" timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pendingActions.set(requestId, { resolve, reject, timer });
-      this.socket.emit("devtool-action", {
-        requestId,
-        toolId,
-        targetDeviceId: target,
-        action,
-        params: params ?? {}
-      });
-    });
-    if (!result.ok) {
-      throw new Error(result.error || `Action "${toolId}.${action}" failed on device`);
-    }
-    return result.result;
-  }
-};
-var snapKey = (deviceId, toolId) => `${deviceId}::${toolId}`;
-function probeBroker(url, timeoutMs = 800) {
-  return new Promise((resolve) => {
-    const req = http.get(url, (res) => {
-      res.resume();
-      resolve((res.statusCode ?? 0) > 0);
-    });
-    req.setTimeout(timeoutMs, () => {
-      req.destroy();
-      resolve(false);
-    });
-    req.on("error", () => resolve(false));
-  });
-}
-async function waitForBroker(url, attempts = 20) {
-  for (let i = 0; i < attempts; i++) {
-    if (await probeBroker(url, 300)) return;
-    await delay(50);
-  }
-  throw new Error(`Spawned broker never became reachable at ${url}`);
-}
-var delay = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// src/tools/generic.ts
-import { z } from "zod";
-function json(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
-}
-function fail(message) {
-  return { isError: true, content: [{ type: "text", text: message }] };
-}
-function registerGenericTools(server, sync) {
-  server.registerTool(
-    "list_devices",
-    {
-      description: "List the React Native devices connected to the Buoy broker and the dev tools each one exposes (toolId, version, available actions). Start here.",
-      inputSchema: {}
-    },
-    async () => {
-      const devices = sync.listDevices();
-      if (devices.length === 0) {
-        return json({
-          devices: [],
-          hint: "No devices connected. Open the app with Buoy devtools running, then retry."
-        });
-      }
-      const anyPro = devices.some((d) => d.isConnected && d.isPro);
-      return json({
-        devices,
-        ...anyPro ? {} : {
-          hint: "The Buoy MCP is a Pro feature \u2014 no connected device has an active Buoy Pro license, so data/action tools are blocked. Upgrade to Buoy Pro in the app to enable them."
-        }
-      });
-    }
-  );
-  server.registerTool(
-    "list_tool_actions",
-    {
-      description: "List the actions a given tool exposes, and which connected devices offer it. Use the action names with call_action.",
-      inputSchema: {
-        toolId: z.string().describe('The tool id, e.g. "perf-monitor", "network", "react-query".')
-      }
-    },
-    async ({ toolId }) => {
-      const offerings = sync.toolActions(toolId);
-      if (offerings.length === 0) {
-        return fail(
-          `No connected device exposes tool "${toolId}". Call list_devices to see available tools.`
-        );
-      }
-      return json({ toolId, offerings });
-    }
-  );
-  server.registerTool(
-    "get_snapshot",
-    {
-      description: "Read a tool's current state (its sync snapshot) from a device. Starts watching the tool and returns the next fresh snapshot.",
-      inputSchema: {
-        toolId: z.string().describe("The tool id to read state from."),
-        deviceId: z.string().optional().describe("Target device id. Omit to auto-select when one device is connected."),
-        timeoutMs: z.number().optional().describe("How long to wait for a fresh snapshot before falling back to the cached one.")
-      }
-    },
-    async ({ toolId, deviceId, timeoutMs }) => {
-      try {
-        const target = sync.requireProDevice(deviceId);
-        const { payload } = await sync.getSnapshot(toolId, target, { timeoutMs });
-        return json({ toolId, deviceId: target, snapshot: payload });
-      } catch (e) {
-        return fail(errMsg(e));
-      }
-    }
-  );
-  server.registerTool(
-    "call_action",
-    {
-      description: "Invoke any action a tool exposes (see list_tool_actions) and return its result. This is the generic escape hatch that works for every Buoy tool.",
-      inputSchema: {
-        toolId: z.string().describe('The tool id, e.g. "perf-monitor".'),
-        action: z.string().describe('The action name, e.g. "startRecording", "clearAll".'),
-        params: z.record(z.unknown()).optional().describe("JSON params object for the action (shape depends on the action)."),
-        deviceId: z.string().optional().describe('Target device id. Omit to auto-select one device, or "All" to broadcast.'),
-        timeoutMs: z.number().optional().describe("Max time to wait for the device's result.")
-      }
-    },
-    async ({ toolId, action, params, deviceId, timeoutMs }) => {
-      try {
-        const target = sync.requireProDevice(deviceId);
-        const result = await sync.callAction(toolId, action, params, target, { timeoutMs });
-        return json({ toolId, action, ok: true, result: result ?? null });
-      } catch (e) {
-        return fail(errMsg(e));
-      }
-    }
-  );
-}
-function errMsg(e) {
-  return e instanceof Error ? e.message : String(e);
-}
-
-// src/tools/packs/perfRanking.ts
-var clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
-var FALLBACK = {
-  perCaseDurationMs: 5e3,
-  settleMs: 600,
-  navTimeoutMs: 5e3,
-  runsPerCase: 3,
-  coolDownMs: 2e3,
-  discardWarmupRuns: 0
-};
-function pick(override, saved, fallback) {
-  return override ?? saved ?? fallback;
-}
-function buildAutomationConfig(input, base = {}) {
-  const warnings = [];
-  const targetRoute = (input.targetRoute || "").trim();
-  if (!targetRoute) throw new Error("targetRoute is required (the screen to benchmark).");
-  let bounceRoute = (input.bounceRoute || "").trim();
-  if (!bounceRoute) bounceRoute = targetRoute === "/" ? "/_buoy_bounce" : "/";
-  if (bounceRoute === targetRoute) {
-    throw new Error(
-      `bounceRoute ("${bounceRoute}") must differ from targetRoute \u2014 it's the screen we bounce to so the test screen fully remounts each run.`
-    );
-  }
-  if (!Array.isArray(input.cases) || input.cases.length === 0) {
-    throw new Error("At least one case is required.");
-  }
-  const cases = input.cases.map((c, i) => {
-    const name = (c.name || "").trim() || `case ${i + 1}`;
-    return { id: `case-${i}`, name, params: c.params ?? {}, route: c.route };
-  });
-  const runsPerCase = clamp(Math.round(pick(input.runsPerCase, base.runsPerCase, FALLBACK.runsPerCase)), 1, 10);
-  const coolDownMs = clamp(Math.round(pick(input.coolDownMs, base.coolDownMs, FALLBACK.coolDownMs)), 0, 3e4);
-  const discardWarmupRuns = clamp(
-    Math.round(pick(input.discardWarmupRuns, base.discardWarmupRuns, FALLBACK.discardWarmupRuns)),
-    0,
-    runsPerCase - 1
-  );
-  const shuffleCases = input.shuffleCases ?? base.shuffleCases ?? cases.length > 3;
-  if (cases.length > 3 && shuffleCases === false) {
-    warnings.push(
-      "shuffleCases is off with >3 cases \u2014 later cases may be thermally throttled, biasing results. Consider enabling it."
-    );
-  }
-  if (runsPerCase === 1) {
-    warnings.push("runsPerCase=1 \u2014 no median/variance; a single noisy run can mislead. 3+ is recommended.");
-  }
-  const config = {
-    targetRoute,
-    bounceRoute,
-    perCaseDurationMs: clamp(
-      Math.round(pick(input.perCaseDurationMs, base.perCaseDurationMs, FALLBACK.perCaseDurationMs)),
-      1e3,
-      6e4
-    ),
-    settleMs: clamp(Math.round(pick(input.settleMs, base.settleMs, FALLBACK.settleMs)), 0, 1e4),
-    navTimeoutMs: clamp(Math.round(pick(input.navTimeoutMs, base.navTimeoutMs, FALLBACK.navTimeoutMs)), 1e3, 3e4),
-    cases,
-    runsPerCase,
-    coolDownMs,
-    discardWarmupRuns,
-    shuffleCases,
-    reloadBetweenCases: input.reloadBetweenCases ?? base.reloadBetweenCases ?? false
-  };
-  return { config, warnings };
-}
-function describeBenchmarkSettings(config) {
-  const secs = (ms) => ms >= 1e3 ? `${(ms / 1e3).toFixed(ms % 1e3 ? 1 : 0)}s` : `${ms}ms`;
-  const runs = config.runsPerCase ?? 1;
-  const estMs = estimateBatchMs(config);
-  const estMin = estMs / 6e4;
-  const est = estMin >= 1 ? `~${estMin.toFixed(1)} min` : `~${Math.round(estMs / 1e3)}s`;
-  const parts = [
-    `**${secs(config.perCaseDurationMs)} measured per page**`,
-    runs > 1 ? `**${runs} runs each** (median taken)` : `**1 run each** (no median \u2014 noisier)`,
-    config.reloadBetweenCases ? "**full reload between pages** (no state leaks across tests)" : "no reload between pages",
-    config.shuffleCases ? "shuffled order (cancels thermal bias)" : "fixed order"
-  ];
-  const perPageMs = config.settleMs + config.perCaseDurationMs + (config.coolDownMs ?? 0) + 1800;
-  return `${parts.join(", ")}. That's ~${secs(perPageMs)} wall-clock per page; for ${config.cases.length} page(s) \xD7 ${runs} run(s), **${est}** total.`;
-}
-function estimateBatchMs(config) {
-  const NAV_OVERHEAD = 1800;
-  const perRun = config.settleMs + config.perCaseDurationMs + config.coolDownMs + NAV_OVERHEAD;
-  let total = config.cases.length * (config.runsPerCase ?? 1) * perRun;
-  if (config.reloadBetweenCases) total += config.cases.length * 3e3;
-  return total;
-}
-function computeFlags(r) {
-  const flags = [];
-  const max = r.deviceMaxRefreshRate;
-  if (r.uiFps != null && max && r.uiFps < max * 0.95) {
-    flags.push("UI thread drops frames");
-  } else if (r.uiJank != null && r.uiJank >= 2) {
-    flags.push("UI jank spikes");
-  }
-  if (r.cpu != null && r.cpu >= 90) flags.push("CPU near cap");
-  if (r.jsJank != null && r.jsJank >= 5) flags.push("JS thread stalls");
-  return flags;
-}
-function rankBatchFromIndex(index, batchId, casesOrder, failures = []) {
-  const entries = index.filter((e) => e.batchId === batchId);
-  const failureByIndex = new Map(failures.map((f) => [f.index, f.reason]));
-  const indexes = casesOrder ? casesOrder.map((_, i) => i) : Array.from(new Set(entries.map((e) => e.batchIndex ?? 0))).sort((a, b) => a - b);
-  const medianForCase = (batchIndex) => {
-    const runs = entries.filter((e) => (e.batchIndex ?? 0) === batchIndex);
-    if (runs.length === 0) return void 0;
-    return runs.find((e) => e.isMedianRun === true) ?? runs.find((e) => e.runIndex === 0 || e.runIndex === void 0) ?? runs[0];
-  };
-  const num = (v) => typeof v === "number" ? v : null;
-  const rows = indexes.map((batchIndex) => {
-    const median = medianForCase(batchIndex);
-    const runs = entries.filter((e) => (e.batchIndex ?? 0) === batchIndex).length;
-    const caseName = casesOrder?.[batchIndex]?.name ?? median?.name ?? `case ${batchIndex + 1}`;
-    const failureReason = failureByIndex.get(batchIndex) ?? median?.batchFailureReason;
-    const failed = Boolean(failureReason) || !median;
-    const base = {
-      batchIndex,
-      caseName,
-      params: median?.params ?? {},
-      runs,
-      failed,
-      failureReason: failed ? failureReason ?? "no run recorded" : void 0,
-      uiFps: num(median?.uiFpsAvg),
-      jsFps: num(median?.jsFpsAvg),
-      cpu: num(median?.cpuAvg),
-      memMb: num(median?.memMaxMb),
-      jsJank: num(median?.jsJankFrames),
-      uiJank: num(median?.uiJankFrames),
-      deviceMaxRefreshRate: num(median?.deviceMaxRefreshRate),
-      deltaUiFps: null,
-      deltaJsFps: null
-    };
-    return { ...base, flags: failed ? [] : computeFlags(base) };
-  });
-  const baseline = rows[0];
-  if (baseline) {
-    for (const r of rows) {
-      if (r === baseline) continue;
-      if (r.uiFps != null && baseline.uiFps != null) r.deltaUiFps = round(r.uiFps - baseline.uiFps, 1);
-      if (r.jsFps != null && baseline.jsFps != null) r.deltaJsFps = round(r.jsFps - baseline.jsFps, 1);
-    }
-  }
-  const live = rows.filter((r) => !r.failed);
-  const leaderBy = (sel, better) => {
-    let best;
-    let bestV = NaN;
-    for (const r of live) {
-      const v = sel(r);
-      if (v == null) continue;
-      if (best === void 0 || better(v, bestV)) {
-        best = r;
-        bestV = v;
-      }
-    }
-    return best?.caseName;
-  };
-  const totalJank = (r) => r.jsJank == null && r.uiJank == null ? null : (r.jsJank ?? 0) + (r.uiJank ?? 0);
-  const leaders = {
-    uiFps: leaderBy((r) => r.uiFps, (a, b) => a > b),
-    jsFps: leaderBy((r) => r.jsFps, (a, b) => a > b),
-    lowestCpu: leaderBy((r) => r.cpu, (a, b) => a < b),
-    lowestMem: leaderBy((r) => r.memMb, (a, b) => a < b),
-    fewestJank: leaderBy(totalJank, (a, b) => a < b)
-  };
-  const flagged = live.filter((r) => r.flags.length > 0).map((r) => ({ caseName: r.caseName, flags: r.flags }));
-  const balanced = live.filter((r) => r.flags.length === 0).sort(
-    (a, b) => (b.uiFps ?? 0) - (a.uiFps ?? 0) || (a.cpu ?? Infinity) - (b.cpu ?? Infinity) || (a.memMb ?? Infinity) - (b.memMb ?? Infinity)
-  ).map((r) => r.caseName);
-  return {
-    batchId,
-    baselineName: baseline?.caseName ?? null,
-    deviceMaxRefreshRate: live.find((r) => r.deviceMaxRefreshRate != null)?.deviceMaxRefreshRate ?? null,
-    rows,
-    leaders,
-    flagged,
-    balanced
-  };
-}
-function formatRankingMarkdown(ranking) {
-  const f = (v, d = 1) => v == null ? "\u2014" : v.toFixed(d);
-  const delta = (v) => v == null ? "" : v > 0 ? ` (+${v.toFixed(1)})` : ` (${v.toFixed(1)})`;
-  const lines = [];
-  lines.push(`### Benchmark batch \`${ranking.batchId}\``);
-  lines.push(
-    `**No single winner \u2014 weigh the trade-offs.** UI-thread health matters more than raw averages: a cheap run that drops UI frames is worse than a pricier one that holds them.`
-  );
-  lines.push("");
-  lines.push("| # | Case | UI FPS | JS FPS | CPU % | Mem MB | JS jank | UI jank | Flags |");
-  lines.push("|---|------|-------:|-------:|------:|-------:|--------:|--------:|-------|");
-  for (const r of ranking.rows) {
-    if (r.failed) {
-      lines.push(`| ${r.batchIndex} | ${r.caseName} | \u2014 | \u2014 | \u2014 | \u2014 | \u2014 | \u2014 | \u274C FAILED (${r.failureReason}) |`);
-      continue;
-    }
-    const flagCell = r.flags.length ? `\u26A0\uFE0F ${r.flags.join("; ")}` : "\u2713 clean";
-    lines.push(
-      `| ${r.batchIndex} | ${r.caseName} | ${f(r.uiFps)}${delta(r.deltaUiFps)} | ${f(r.jsFps)}${delta(
-        r.deltaJsFps
-      )} | ${f(r.cpu)} | ${f(r.memMb)} | ${f(r.jsJank, 0)} | ${f(r.uiJank, 0)} | ${flagCell} |`
-    );
-  }
-  lines.push("");
-  const L = ranking.leaders;
-  const leaderLine = [
-    L.uiFps && `UI FPS \u2192 **${L.uiFps}**`,
-    L.jsFps && `JS FPS \u2192 **${L.jsFps}**`,
-    L.lowestCpu && `lowest CPU \u2192 **${L.lowestCpu}**`,
-    L.lowestMem && `lowest mem \u2192 **${L.lowestMem}**`,
-    L.fewestJank && `fewest jank \u2192 **${L.fewestJank}**`
-  ].filter(Boolean).join(" \xB7 ");
-  if (leaderLine) lines.push(`**Per-metric best:** ${leaderLine}`);
-  lines.push(
-    ranking.balanced.length ? `**Balanced (caps nothing):** ${ranking.balanced.join(", ")}` : `**Balanced (caps nothing):** none \u2014 every case stressed at least one axis; pick by which trade-off you can accept.`
-  );
-  if (ranking.flagged.length) {
-    lines.push(
-      `**\u26A0\uFE0F At-risk:** ${ranking.flagged.map((x) => `${x.caseName} (${x.flags.join("; ")})`).join(" \xB7 ")}`
-    );
-  }
-  lines.push("");
-  lines.push(
-    `_Deltas vs baseline (case #0). Don't pick on one metric \u2014 explain the trade-off (e.g. "A is cheapest but drops UI frames \u2192 jank risk; B costs more CPU but caps nothing")._`
-  );
-  return lines.join("\n");
-}
-function compareReportStats(a, b) {
-  const ch = (x, y) => ({
-    a: { avg: round(x.avg, 1), p95: round(x.p95, 1) },
-    b: { avg: round(y.avg, 1), p95: round(y.p95, 1) },
-    deltaAvg: round(y.avg - x.avg, 1)
-  });
-  return {
-    a: a.name,
-    b: b.name,
-    uiFps: ch(a.stats.uiFps, b.stats.uiFps),
-    jsFps: ch(a.stats.jsFps, b.stats.jsFps),
-    cpuUsage: ch(a.stats.cpuUsage, b.stats.cpuUsage),
-    memoryUsage: ch(a.stats.memoryUsage, b.stats.memoryUsage),
-    jsJankFrames: { a: a.stats.jsJankFrames, b: b.stats.jsJankFrames, delta: b.stats.jsJankFrames - a.stats.jsJankFrames },
-    uiJankFrames: { a: a.stats.uiJankFrames, b: b.stats.uiJankFrames, delta: b.stats.uiJankFrames - a.stats.uiJankFrames }
-  };
-}
-function round(n, d) {
-  const p = Math.pow(10, d);
-  return Math.round(n * p) / p;
-}
-
-// src/tools/packs/perfMonitor.ts
-import { z as z2 } from "zod";
-
-// src/tools/packs/perfMonitorTypes.ts
-var PERF_TOOL_ID = "perf-monitor";
-
-// src/tools/packs/perfMonitor.ts
-var POLL_INTERVAL_MS = 1500;
-var delay2 = (ms) => new Promise((r) => setTimeout(r, ms));
-var json2 = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
-var text = (s) => ({ content: [{ type: "text", text: s }] });
-var fail2 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg2 = (e) => e instanceof Error ? e.message : String(e);
-var caseSchema = z2.object({
-  name: z2.string().describe("Display name for this variant (becomes the saved run's name)."),
-  params: z2.record(z2.string()).optional().describe('Query params applied to the route for this case, e.g. { "renderer": "v2", "count": "100" }.'),
-  route: z2.string().optional().describe("Optional per-case route override; defaults to targetRoute.")
-});
-async function readDeviceSettings(sync, deviceId) {
-  try {
-    const cfg = await sync.callAction(PERF_TOOL_ID, "getAutomationConfig", {}, deviceId);
-    if (!cfg) return {};
-    const {
-      perCaseDurationMs,
-      settleMs,
-      navTimeoutMs,
-      runsPerCase,
-      coolDownMs,
-      discardWarmupRuns,
-      shuffleCases,
-      reloadBetweenCases
-    } = cfg;
-    return {
-      perCaseDurationMs,
-      settleMs,
-      navTimeoutMs,
-      runsPerCase,
-      coolDownMs,
-      discardWarmupRuns,
-      shuffleCases,
-      reloadBetweenCases
-    };
-  } catch {
-    return {};
-  }
-}
-async function readPerfSnapshot(sync, deviceId) {
-  const { payload } = await sync.getSnapshot(PERF_TOOL_ID, deviceId, { timeoutMs: 4e3 });
-  return payload;
-}
-function batchIdsIn(index) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const e of index ?? []) if (e.batchId) ids.add(e.batchId);
-  return ids;
-}
-function runCountFor(index, batchId) {
-  return (index ?? []).filter((e) => e.batchId === batchId).length;
-}
-function newestBatchId(index) {
-  let best = null;
-  for (const e of index ?? []) {
-    if (e.batchId && (!best || e.createdAt > best.at)) best = { id: e.batchId, at: e.createdAt };
-  }
-  return best?.id ?? null;
-}
-function failuresFromIndex(index, batchId) {
-  const byCase = /* @__PURE__ */ new Map();
-  for (const e of index ?? []) {
-    if (e.batchId === batchId && e.batchFailureReason && !byCase.has(e.batchIndex ?? 0)) {
-      byCase.set(e.batchIndex ?? 0, e.batchFailureReason);
-    }
-  }
-  return [...byCase.entries()].map(([index2, reason]) => ({ index: index2, reason }));
-}
-async function waitForBatchByIndex(sync, deviceId, opts) {
-  const { preBatchIds, expectedRuns, maxWaitMs, log } = opts;
-  const start = Date.now();
-  let lastPhase = "";
-  let sawActive = false;
-  let idleStreak = 0;
-  while (Date.now() - start < maxWaitMs) {
-    let snap2;
-    try {
-      snap2 = await readPerfSnapshot(sync, deviceId);
-    } catch {
-      await delay2(POLL_INTERVAL_MS);
-      continue;
-    }
-    const index = snap2.index ?? [];
-    const phase = snap2.live?.automation?.phase ?? "idle";
-    const completed = snap2.live?.automationCompleted;
-    if (completed?.phase === "cancelled" && !preBatchIds.has(completed.batchId)) {
-      return { batchId: completed.batchId, failures: [], cancelled: true };
-    }
-    if (completed?.phase === "done" && !preBatchIds.has(completed.batchId)) {
-      return { batchId: completed.batchId, failures: completed.failures ?? failuresFromIndex(index, completed.batchId) };
-    }
-    if (phase !== "idle") sawActive = true;
-    if (phase !== lastPhase) {
-      lastPhase = phase;
-      log(`automation phase: ${phase}`);
-    }
-    const newId2 = [...batchIdsIn(index)].find((id) => !preBatchIds.has(id));
-    if (newId2) {
-      const count = runCountFor(index, newId2);
-      if (expectedRuns > 0 && count >= expectedRuns) {
-        log(`batch ${newId2} complete (${count}/${expectedRuns} runs saved)`);
-        return { batchId: newId2, failures: failuresFromIndex(index, newId2) };
-      }
-      if (phase === "idle" && sawActive && count > 0) {
-        if (++idleStreak >= 3) {
-          log(`batch ${newId2} settled (${count} runs, automation idle)`);
-          return { batchId: newId2, failures: failuresFromIndex(index, newId2) };
-        }
-      } else {
-        idleStreak = 0;
-      }
-    }
-    await delay2(POLL_INTERVAL_MS);
-  }
-  const snap = await readPerfSnapshot(sync, deviceId).catch(() => null);
-  const newId = snap ? [...batchIdsIn(snap.index)].find((id) => !preBatchIds.has(id)) : void 0;
-  if (newId && snap) return { batchId: newId, failures: failuresFromIndex(snap.index, newId), timedOut: true };
-  throw new Error(
-    `Batch did not start within ${Math.round(maxWaitMs / 1e3)}s (last phase: ${lastPhase || "idle"}). Check get_automation_status \u2014 the device may not have navigated.`
-  );
-}
-function registerPerfMonitorTools(server, sync) {
-  server.registerTool(
-    "run_benchmark_batch",
-    {
-      description: "Run a perf-monitor benchmark batch and return a RANKED comparison of all cases (winner by UI FPS). Give it a target route and a matrix of cases (each a name + query params that select a variant on that route); it navigates, records, and benchmarks each case on the device, then ranks them. This blocks until the batch completes (can be minutes for large batches). The app must have the target route render its variants from the params.",
-      inputSchema: {
-        targetRoute: z2.string().describe('The screen to benchmark, e.g. "/perf-test". Reads case params to pick a variant.'),
-        cases: z2.array(caseSchema).min(1).describe("The variants to compare. Case #0 is the baseline for deltas."),
-        bounceRoute: z2.string().optional().describe('Screen to bounce to between runs so the test screen fully remounts. Defaults to "/" (or a stub if target is "/").'),
-        runsPerCase: z2.number().optional().describe("Runs per case; the median becomes the canonical result. Default 3 (1\u201310)."),
-        perCaseDurationMs: z2.number().optional().describe("How long to record each run. Default 5000."),
-        settleMs: z2.number().optional().describe("Idle gap after navigation before recording. Default 600."),
-        coolDownMs: z2.number().optional().describe("Idle between runs/cases for thermal recovery. Default 2000."),
-        navTimeoutMs: z2.number().optional().describe("Max wait for navigation per run. Default 5000."),
-        discardWarmupRuns: z2.number().optional().describe("Discard first N runs of each case before taking the median. Default 0."),
-        shuffleCases: z2.boolean().optional().describe("Interleave + shuffle case order to cancel thermal bias. Default on for >3 cases."),
-        reloadBetweenCases: z2.boolean().optional().describe("Fully reload JS between cases (needs <AutomationResumer/> mounted). Default false."),
-        deviceId: z2.string().optional().describe("Target device id. Omit to auto-select when one device is connected."),
-        maxWaitMs: z2.number().optional().describe("Safety cap for how long to wait for completion. Defaults to ~3\xD7 the estimate + 60s.")
-      }
-    },
-    async (args) => {
-      const log = (m) => process.stderr.write(`[buoy-mcp] ${m}
-`);
-      try {
-        const deviceId = sync.requireProDevice(args.deviceId);
-        const base = await readDeviceSettings(sync, deviceId);
-        const { config, warnings } = buildAutomationConfig(args, base);
-        const estimateMs = estimateBatchMs(config);
-        const maxWaitMs = args.maxWaitMs ?? estimateMs * 3 + 6e4;
-        const expectedRuns = config.cases.length * (config.runsPerCase ?? 1);
-        await sync.callAction(PERF_TOOL_ID, "acknowledgeAutomation", {}, deviceId).catch(() => {
-        });
-        await sync.callAction(PERF_TOOL_ID, "setEnabled", { enabled: true }, deviceId).catch(() => {
-        });
-        await sync.callAction(PERF_TOOL_ID, "refreshIndex", {}, deviceId).catch(() => {
-        });
-        const before = await readPerfSnapshot(sync, deviceId);
-        const preBatchIds = batchIdsIn(before.index);
-        log(
-          `starting batch: ${config.cases.length} cases \xD7 ${config.runsPerCase} runs (~${Math.round(estimateMs / 1e3)}s estimated) on ${deviceId}`
-        );
-        await sync.callAction(PERF_TOOL_ID, "startAutomation", { config }, deviceId);
-        const outcome = await waitForBatchByIndex(sync, deviceId, {
-          preBatchIds,
-          expectedRuns,
-          maxWaitMs,
-          log
-        });
-        if (outcome.cancelled) {
-          await sync.callAction(PERF_TOOL_ID, "acknowledgeAutomation", {}, deviceId).catch(() => {
-          });
-          return fail2(`Batch ${outcome.batchId} was cancelled before completing.`);
-        }
-        await sync.callAction(PERF_TOOL_ID, "refreshIndex", {}, deviceId).catch(() => {
-        });
-        const snap = await readPerfSnapshot(sync, deviceId);
-        const ranking = rankBatchFromIndex(snap.index ?? [], outcome.batchId, config.cases, outcome.failures);
-        await sync.callAction(PERF_TOOL_ID, "acknowledgeAutomation", {}, deviceId).catch(() => {
-        });
-        await sync.callAction(PERF_TOOL_ID, "setEnabled", { enabled: false }, deviceId).catch(() => {
-        });
-        const md = formatRankingMarkdown(ranking);
-        const summary = {
-          batchId: outcome.batchId,
-          leaders: ranking.leaders,
-          balanced: ranking.balanced,
-          flagged: ranking.flagged,
-          rows: ranking.rows,
-          failures: outcome.failures,
-          warnings,
-          estimateMs,
-          ...outcome.timedOut ? { note: "Wait cap hit \u2014 results may be partial (some runs may still be saving)." } : {}
-        };
-        return text(`${md}
-
-\`\`\`json
-${JSON.stringify(summary, null, 2)}
-\`\`\``);
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-  server.registerTool(
-    "get_automation_status",
-    {
-      description: "Get the perf-monitor automation batch status (current phase + last completed batch) without waiting.",
-      inputSchema: { deviceId: z2.string().optional().describe("Target device id (auto-selected if one is connected).") }
-    },
-    async ({ deviceId }) => {
-      try {
-        const target = sync.requireProDevice(deviceId);
-        const snap = await readPerfSnapshot(sync, target);
-        return json2({
-          deviceId: target,
-          automation: snap.live?.automation ?? { phase: "idle" },
-          automationCompleted: snap.live?.automationCompleted ?? null
-        });
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-  server.registerTool(
-    "wait_for_automation",
-    {
-      description: "Block until the in-flight perf-monitor batch finishes, then return its ranked comparison. Use this if a batch was started another way (e.g. on the device).",
-      inputSchema: {
-        deviceId: z2.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        maxWaitMs: z2.number().optional().describe("Max time to wait. Default 600000 (10 min).")
-      }
-    },
-    async ({ deviceId, maxWaitMs }) => {
-      const log = (m) => process.stderr.write(`[buoy-mcp] ${m}
-`);
-      const cap = maxWaitMs ?? 6e5;
-      try {
-        const target = sync.requireProDevice(deviceId);
-        const start = Date.now();
-        let sawActive = false;
-        let idleStreak = 0;
-        let lastCount = -1;
-        let resolved = null;
-        while (Date.now() - start < cap) {
-          let snap2;
-          try {
-            snap2 = await readPerfSnapshot(sync, target);
-          } catch {
-            await delay2(POLL_INTERVAL_MS);
-            continue;
-          }
-          const completed = snap2.live?.automationCompleted;
-          if (completed?.phase === "cancelled") return fail2(`Batch ${completed.batchId} was cancelled.`);
-          if (completed?.phase === "done") {
-            resolved = { batchId: completed.batchId, failures: completed.failures ?? failuresFromIndex(snap2.index, completed.batchId) };
-            break;
-          }
-          const phase = snap2.live?.automation?.phase ?? "idle";
-          if (phase !== "idle") sawActive = true;
-          const newest = newestBatchId(snap2.index);
-          if (phase === "idle" && newest) {
-            const count = runCountFor(snap2.index, newest);
-            if (count === lastCount) {
-              if (sawActive && ++idleStreak >= 3) {
-                resolved = { batchId: newest, failures: failuresFromIndex(snap2.index, newest) };
-                break;
-              }
-              if (!sawActive && Date.now() - start > 4e3) {
-                resolved = { batchId: newest, failures: failuresFromIndex(snap2.index, newest) };
-                break;
-              }
-            } else {
-              idleStreak = 0;
-              lastCount = count;
-            }
-          } else {
-            idleStreak = 0;
-          }
-          await delay2(POLL_INTERVAL_MS);
-        }
-        if (!resolved) return fail2("No automation batch completed within the wait window.");
-        await sync.callAction(PERF_TOOL_ID, "refreshIndex", {}, target).catch(() => {
-        });
-        const snap = await readPerfSnapshot(sync, target);
-        const ranking = rankBatchFromIndex(snap.index ?? [], resolved.batchId, void 0, resolved.failures);
-        await sync.callAction(PERF_TOOL_ID, "acknowledgeAutomation", {}, target).catch(() => {
-        });
-        return text(`${formatRankingMarkdown(ranking)}
-
-\`\`\`json
-${JSON.stringify(ranking, null, 2)}
-\`\`\``);
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-  server.registerTool(
-    "get_batch_report",
-    {
-      description: "Re-rank a previously-run benchmark batch by its batchId (from the saved recordings index).",
-      inputSchema: {
-        batchId: z2.string().describe("The batch id to report on."),
-        deviceId: z2.string().optional().describe("Target device id (auto-selected if one is connected).")
-      }
-    },
-    async ({ batchId, deviceId }) => {
-      try {
-        const target = sync.requireProDevice(deviceId);
-        await sync.callAction(PERF_TOOL_ID, "refreshIndex", {}, target).catch(() => {
-        });
-        const snap = await readPerfSnapshot(sync, target);
-        const entries = (snap.index ?? []).filter((e) => e.batchId === batchId);
-        if (entries.length === 0) return fail2(`No saved runs found for batch "${batchId}".`);
-        const ranking = rankBatchFromIndex(snap.index ?? [], batchId);
-        return text(`${formatRankingMarkdown(ranking)}
-
-\`\`\`json
-${JSON.stringify(ranking, null, 2)}
-\`\`\``);
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-  server.registerTool(
-    "compare_reports",
-    {
-      description: "Compare two saved benchmark runs head-to-head (avg + p95 for FPS/CPU/memory, jank, with deltas).",
-      inputSchema: {
-        reportIdA: z2.string().describe("First (baseline) report id."),
-        reportIdB: z2.string().describe("Second report id to compare against the baseline."),
-        deviceId: z2.string().optional().describe("Target device id (auto-selected if one is connected).")
-      }
-    },
-    async ({ reportIdA, reportIdB, deviceId }) => {
-      try {
-        const target = sync.requireProDevice(deviceId);
-        const [a, b] = await Promise.all([
-          sync.callAction(PERF_TOOL_ID, "loadReport", { id: reportIdA }, target),
-          sync.callAction(PERF_TOOL_ID, "loadReport", { id: reportIdB }, target)
-        ]);
-        if (!a) return fail2(`Report "${reportIdA}" not found.`);
-        if (!b) return fail2(`Report "${reportIdB}" not found.`);
-        return json2(
-          compareReportStats(
-            { name: a.metadata.name, stats: a.stats },
-            { name: b.metadata.name, stats: b.stats }
-          )
-        );
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-  server.registerTool(
-    "get_benchmark_settings",
-    {
-      description: "Read the device's saved benchmark settings (per-page duration, runs, cooldown, reload, shuffle) in plain English with a time estimate. Call this before run_benchmark_batch so you can tell the user what the run will do \u2014 run_benchmark_batch inherits these unless you override them.",
-      inputSchema: {
-        pages: z2.number().optional().describe("How many pages/variants you plan to test, for a total-time estimate. Default 1."),
-        deviceId: z2.string().optional().describe("Target device id (auto-selected if one is connected).")
-      }
-    },
-    async ({ pages, deviceId }) => {
-      try {
-        const target = sync.requireProDevice(deviceId);
-        const settings = await readDeviceSettings(sync, target);
-        const n = Math.max(1, Math.round(pages ?? 1));
-        const { config } = buildAutomationConfig(
-          { targetRoute: "/_preview", cases: Array.from({ length: n }, (_, i) => ({ name: `page ${i + 1}` })) },
-          settings
-        );
-        const source = Object.keys(settings).length > 0 ? "this device's saved settings" : "default profile (none saved)";
-        return text(
-          `**Benchmark settings (${source}):** ${describeBenchmarkSettings(config)}
-
-\`\`\`json
-${JSON.stringify(settings, null, 2)}
-\`\`\``
-        );
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-  server.registerTool(
-    "set_benchmark_settings",
-    {
-      description: `PERSIST benchmark settings on the device so they stick across runs. Only use when the user explicitly wants to save a change ("always", "save this"). For a one-off, pass overrides to run_benchmark_batch instead \u2014 don't change their saved profile.`,
-      inputSchema: {
-        perCaseDurationMs: z2.number().optional().describe("Recording length per page (ms)."),
-        settleMs: z2.number().optional().describe("Idle after navigation before recording (ms)."),
-        coolDownMs: z2.number().optional().describe("Idle between runs/cases (ms)."),
-        navTimeoutMs: z2.number().optional().describe("Max wait for navigation per run (ms)."),
-        runsPerCase: z2.number().optional().describe("Runs per page; median is the canonical result (1\u201310)."),
-        discardWarmupRuns: z2.number().optional().describe("Discard first N runs of each page before the median."),
-        shuffleCases: z2.boolean().optional().describe("Interleave + shuffle case order to cancel thermal bias."),
-        reloadBetweenCases: z2.boolean().optional().describe("Fully reload JS between pages (needs <AutomationResumer/> mounted)."),
-        deviceId: z2.string().optional().describe("Target device id (auto-selected if one is connected).")
-      }
-    },
-    async (args) => {
-      try {
-        const target = sync.requireProDevice(args.deviceId);
-        const current = await sync.callAction(PERF_TOOL_ID, "getAutomationConfig", {}, target) ?? {};
-        const keys = [
-          "perCaseDurationMs",
-          "settleMs",
-          "coolDownMs",
-          "navTimeoutMs",
-          "runsPerCase",
-          "discardWarmupRuns",
-          "shuffleCases",
-          "reloadBetweenCases"
-        ];
-        const overrides = {};
-        for (const k of keys) {
-          const v = args[k];
-          if (v !== void 0) overrides[k] = v;
-        }
-        if (Object.keys(overrides).length === 0) {
-          return fail2("No settings provided to save. Pass at least one field (e.g. perCaseDurationMs).");
-        }
-        const next = { ...current, ...overrides };
-        const saved = await sync.callAction(PERF_TOOL_ID, "setAutomationConfig", { config: next }, target);
-        const settings = await readDeviceSettings(sync, target);
-        const { config } = buildAutomationConfig(
-          { targetRoute: "/_preview", cases: [{ name: "page 1" }] },
-          settings
-        );
-        return text(
-          `Saved. **New benchmark settings:** ${describeBenchmarkSettings(config)}
-
-\`\`\`json
-${JSON.stringify(saved ?? settings, null, 2)}
-\`\`\``
-        );
-      } catch (e) {
-        return fail2(errMsg2(e));
-      }
-    }
-  );
-}
-
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z3 } from "zod";
-var SERVER_INSTRUCTIONS = `Buoy MCP \u2014 drive Buoy dev tools running in a React Native app from your editor.
-
-Buoy tools live inside the app and sync to a local broker; this server connects to that
-broker as a dashboard client. Start by calling \`list_devices\` to see which device(s) are
-connected and which tools (e.g. "perf-monitor", "network", "react-query") they expose, then:
-- \`list_tool_actions\` to see what a tool can do,
-- \`get_snapshot\` to read a tool's current state,
-- \`call_action\` to invoke any tool action generically.
-
-Higher-level tools (e.g. perf-monitor's \`run_benchmark_batch\`) wrap these for common workflows.
-If no device is connected, open the app with Buoy devtools running and try again.
-
-The Buoy MCP is a Pro feature: \`list_devices\` is always available, but data/action tools
-require the connected app to have an active Buoy Pro license. If they error with "Buoy Pro
-required", tell the user to upgrade to Buoy Pro in the app \u2014 don't try to work around it.`;
-function createMcpServer(sync) {
-  const server = new McpServer(
-    { name: "buoy", version: "3.0.2" },
-    { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }
-  );
-  registerGenericTools(server, sync);
-  registerPerfMonitorTools(server, sync);
-  return server;
-}
-var deviceIdField = {
-  deviceId: z3.string().optional().describe(
-    'Target device id (from list_devices). Omit to auto-select when exactly one device is connected. Use "All" to broadcast.'
-  )
-};
-
-export {
-  BROKER_PORT,
-  BROKER_URL,
-  DEFAULT_ACTION_TIMEOUT_MS,
-  DEFAULT_SNAPSHOT_TIMEOUT_MS,
-  DASHBOARD_NAME,
-  ALL_DEVICES,
-  SyncClient,
-  registerGenericTools,
-  buildAutomationConfig,
-  estimateBatchMs,
-  rankBatchFromIndex,
-  formatRankingMarkdown,
-  compareReportStats,
-  registerPerfMonitorTools,
-  createMcpServer
-};