@buoy-gg/mcp 7.0.16 → 7.0.18

package/dist/cli.js

@@ -52,8 +52,12 @@ var SyncClient = class {
     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();
+    /**
+     * Capture-mode watches this client holds, keyed by snapKey. Stored with
+     * their addressing because they have to be RE-SENT on every reconnect: the
+     * broker keys watch state by socket id, and a reconnect gets a new one.
+     */
+    this.watching = /* @__PURE__ */ new Map();
     /** In-flight actions awaiting a result, keyed by requestId. */
     this.pendingActions = /* @__PURE__ */ new Map();
     /** Callbacks waiting for the next snapshot of `${deviceId}::${toolId}`. */
@@ -109,6 +113,7 @@ var SyncClient = class {
         resolve();
       };
       socket.on("connect", onConnect);
+      socket.on("connect", () => this.rearmWatches());
       socket.once("connect_error", (err) => {
         if (settled) return;
         settled = true;
@@ -219,11 +224,50 @@ var SyncClient = class {
   // ----------------------------------------------------------------
   // Watch + snapshots
   // ----------------------------------------------------------------
+  /**
+   * Keep the device RECORDING this tool, without asking it to stream.
+   *
+   * A dashboard watches for as long as its panel is open; this client is
+   * request/response, so it used to watch and unwatch around every single
+   * read. That works for a tool whose state just IS (the query cache, the env
+   * table) and is useless for one that records a timeline: the unwatch drops
+   * the device's subscriber count to zero, which stops capture, so nothing is
+   * ever recorded between two reads. The list comes back empty and reads as
+   * "the app made no requests" — a wrong conclusion that is very expensive to
+   * chase, because everything about the app looks fine.
+   *
+   * Capture-mode watches are held for the life of the connection and released
+   * on disconnect (the broker also drops them for us). They cost the device's
+   * ring buffer, not the socket: no snapshot is pushed, and reads still go
+   * through `request-devtool-state`.
+   */
   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 });
+    this.watching.set(key, { toolId, targetDeviceId });
+    this.sendWatch(toolId, targetDeviceId);
+  }
+  sendWatch(toolId, targetDeviceId) {
+    this.socket?.emit("devtool-watch", {
+      toolId,
+      targetDeviceId,
+      watching: true,
+      stream: false
+    });
+  }
+  /**
+   * Re-arm every held watch after a reconnect.
+   *
+   * The broker tracks watches per SOCKET, so a reconnect (broker restart, a
+   * dropped wifi link) silently discards all of ours while `watching` still
+   * says we hold them — `ensureWatching` would then short-circuit forever and
+   * the device would never record again. Silent and permanent: the exact
+   * failure this whole capture-mode change exists to remove.
+   */
+  rearmWatches() {
+    for (const { toolId, targetDeviceId } of this.watching.values()) {
+      this.sendWatch(toolId, targetDeviceId);
+    }
   }
   /** Stop streaming a tool (releases the device-side backpressure). */
   unwatch(toolId, targetDeviceId) {
@@ -236,26 +280,25 @@ var SyncClient = class {
     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.
+   * Get a tool's current state: arm capture (once, for the connection), ask
+   * for state explicitly, and resolve with the snapshot that comes back.
+   * Falls back to the last cached snapshot if the request times out.
+   *
+   * The capture watch is deliberately NOT released afterwards — see
+   * `ensureWatching`. It costs the device nothing on the socket, and dropping
+   * it is what made every timeline tool look permanently empty from here.
    */
   async getSnapshot(toolId, deviceId, opts = {}) {
     const target = this.resolveDevice(deviceId);
     const key = snapKey(target, toolId);
-    const wasWatching = this.watching.has(key);
     this.ensureWatching(toolId, target);
-    try {
-      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?)`);
-    } finally {
-      if (!wasWatching) this.unwatch(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) => {
@@ -330,7 +373,7 @@ var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 
 // src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/tools/generic.ts
 var import_zod = require("zod");
@@ -341,7 +384,7 @@ var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
 
 // src/version.ts
-var VERSION = "7.0.16" ? "7.0.16" : "0.0.0-dev";
+var VERSION = "7.0.18" ? "7.0.18" : "0.0.0-dev";
 var PACKAGE_NAME = "@buoy-gg/mcp";
 
 // src/update/checkForUpdate.ts
@@ -1342,6 +1385,60 @@ function truncate(v, n = 600) {
   const s = typeof v === "string" ? v : JSON.stringify(v);
   return s.length > n ? `${s.slice(0, n)}\u2026(+${s.length - n} chars)` : s;
 }
+var MAX_BODY_FETCHES = 8;
+async function resolveBodies(sync, rows, target, max = MAX_BODY_FETCHES) {
+  const needed = rows.filter(
+    (e) => e.id && (e.requestBodyOmitted === true && e.requestData === void 0 || e.responseBodyOmitted === true && e.responseData === void 0)
+  );
+  const bodies = /* @__PURE__ */ new Map();
+  if (needed.length === 0) return { bodies, skipped: 0 };
+  const take = needed.slice(0, max);
+  const settled = await Promise.allSettled(
+    take.map(
+      (e) => sync.callAction(NETWORK_TOOL_ID, "getEventBody", { id: e.id }, target)
+    )
+  );
+  settled.forEach((r, i) => {
+    const id = take[i].id;
+    const body = r.status === "fulfilled" ? r.value : null;
+    bodies.set(id, body ? { ...body } : { unresolved: true });
+  });
+  return { bodies, skipped: needed.length - take.length };
+}
+async function captureDiagnosis(sync, target) {
+  let status = null;
+  try {
+    status = await sync.callAction(
+      NETWORK_TOOL_ID,
+      "getCaptureStatus",
+      {},
+      target
+    );
+  } catch {
+    return "The network tool has captured nothing yet.";
+  }
+  if (!status || status.capturing !== false) {
+    return "The device IS capturing, so nothing has been requested since it started.";
+  }
+  return "The device is NOT capturing. Reading from here arms capture, so the very next read should see traffic \u2014 trigger it and call again. This is not an app or interception problem. (If it stays off, the device is on a Buoy older than the capture-mode watch: open the Network panel on the device or in Buoy Desktop to record.)";
+}
+function skippedNote(skipped) {
+  return skipped > 0 ? `
+
+_${skipped} more withheld ${skipped === 1 ? "body was" : "bodies were"} not fetched (cap ${MAX_BODY_FETCHES} per listing, they are large). Get one in full with its id._` : "";
+}
+function bodyLines(e, fetched) {
+  const got = e.id ? fetched.get(e.id) : void 0;
+  const label = (inline, resolved, omitted) => {
+    const value = inline ?? resolved;
+    if (value !== void 0 && value !== null) return truncate(value);
+    if (!omitted) return "(none)";
+    return got?.unresolved ? "(withheld \u2014 the device did not answer getEventBody)" : "(none)";
+  };
+  return `
+   \u2514\u2500 request: ${label(e.requestData, got?.requestData, e.requestBodyOmitted)}
+   \u2514\u2500 response: ${label(e.responseData, got?.responseData, e.responseBodyOmitted)}`;
+}
 function formatRow(index, e, markers) {
   const where = e.path || e.url;
   const bits = [
@@ -1395,6 +1492,7 @@ function registerNetworkTools(server, sync) {
 The developer pins/saves a request from the Network tool (long-press a row, or the pin/bookmark buttons in the request detail header), or you can with network_action.`
             );
           }
+          const kept = args.includeBodies ? await resolveBodies(sync, rows2.map((r) => r.event), target) : { bodies: /* @__PURE__ */ new Map(), skipped: 0 };
           const body2 = rows2.map((r, i) => {
             const marks = [r.pinned ? "\u{1F4CC} pinned" : "", r.saved ? "\u{1F516} saved" : ""].filter(Boolean).join(" ");
             const stale = r.event.id?.startsWith("saved:") ? " \xB7 from an earlier app run" : "";
@@ -1402,12 +1500,7 @@ The developer pins/saves a request from the Network tool (long-press a row, or t
             let out = formatRow(i + 1, r.event, marks);
             out += `
    \u2514\u2500 key \`${r.key}\`${stale}${trunc}`;
-            if (args.includeBodies) {
-              out += `
-   \u2514\u2500 request: ${truncate(r.event.requestData)}`;
-              out += `
-   \u2514\u2500 response: ${truncate(r.event.responseData)}`;
-            }
+            if (args.includeBodies) out += bodyLines(r.event, kept.bodies);
             return out;
           }).join("\n");
           return text3(
@@ -1415,23 +1508,19 @@ The developer pins/saves a request from the Network tool (long-press a row, or t
 
 ${body2}
 
-_These are snapshots: they survive Clear, the 500-request cap and app restarts. Remove one with network_action({action:"remove", key}). Ids starting \`saved:\` are from an earlier run of the app._`
+_These are snapshots: they survive Clear, the 500-request cap and app restarts. Remove one with network_action({action:"remove", key}). Ids starting \`saved:\` are from an earlier run of the app._${skippedNote(kept.skipped)}`
           );
         }
         const rows = events.filter((e) => matchesStatus(e, args.status)).filter((e) => !pattern || (e.url ?? "").toLowerCase().includes(pattern)).slice(0, limit);
         if (rows.length === 0) {
-          const why = events.length === 0 ? "The network tool has captured nothing yet (is it enabled, and has the app made a request?)." : "No request matched the filter.";
+          const why = events.length === 0 ? await captureDiagnosis(sync, target) : "No request matched the filter.";
           return text3(`No requests on ${target}. ${why}`);
         }
+        const live = args.includeBodies ? await resolveBodies(sync, rows, target) : { bodies: /* @__PURE__ */ new Map(), skipped: 0 };
         const body = rows.map((e, i) => {
           const marks = [pinnedIds.has(e.id) ? "\u{1F4CC}" : "", savedIds.has(e.id) ? "\u{1F516}" : ""].filter(Boolean).join("");
           let out = formatRow(i + 1, e, marks);
-          if (args.includeBodies) {
-            out += `
-   \u2514\u2500 request: ${truncate(e.requestData)}`;
-            out += `
-   \u2514\u2500 response: ${truncate(e.responseData)}`;
-          }
+          if (args.includeBodies) out += bodyLines(e, live.bodies);
           return out;
         }).join("\n");
         const keptNote = saved.length > 0 ? ` \xB7 ${saved.length} kept (flagged:'any' to list)` : "";
@@ -1440,7 +1529,7 @@ _These are snapshots: they survive Clear, the 500-request cap and app restarts.
 
 ${body}
 
-_\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_action({action:"pin", id:"${rows[0].id}"})._`
+_\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_action({action:"pin", id:"${rows[0].id}"})._${skippedNote(live.skipped)}`
         );
       } catch (e) {
         return fail4(errMsg4(e));
@@ -2326,8 +2415,147 @@ _Tail of recent logs. Use get_snapshot('console') for full args/stacks._`);
   );
 }
 
-// src/tools/packs/screenshot.ts
+// src/tools/packs/timeMachine.ts
 var import_zod12 = require("zod");
+var TIME_MACHINE_TOOL_ID = "time-machine";
+var text11 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail12 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg12 = (e) => e instanceof Error ? e.message : String(e);
+function kb(bytes) {
+  return bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} KB`;
+}
+function formatOutcome(outcome) {
+  const lines = Object.entries(outcome.results).map(([sid, r]) => {
+    const skips = r.skipped.slice(0, 3).map((s) => `
+    \xB7 ${s.id}: ${s.reason}`).join("");
+    const warns = r.warnings.slice(0, 3).map((w) => `
+    \u26A0 ${w}`).join("");
+    return `  ${r.ok ? "\u2713" : "\u2715"} ${sid} \u2014 applied ${r.applied}${r.skipped.length ? `, skipped ${r.skipped.length}` : ""}${skips}${warns}`;
+  });
+  return `Restored "${outcome.snapshotName}" (${outcome.mode}${outcome.willReload ? ", app reloading" : ""}):
+${lines.join("\n")}`;
+}
+function registerTimeMachineTools(server, sync) {
+  server.registerTool(
+    "get_time_machine",
+    {
+      description: "List the app's Time Machine state snapshots (restore points) and which state sources (storage/redux/zustand/jotai/react-query) can currently be captured/restored. Use time_machine_action to capture a snapshot before driving a flow, then restore it to re-run the flow from the same state.",
+      inputSchema: {
+        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+      }
+    },
+    async (args) => {
+      try {
+        const target = sync.requireProDevice(args.deviceId);
+        const { payload } = await sync.getSnapshot(TIME_MACHINE_TOOL_ID, target);
+        const p = payload ?? {};
+        const snapshots = p.snapshots ?? [];
+        const providers = p.providers ?? [];
+        const providerLines = providers.map((pr) => {
+          const cap = pr.canCapture ? pr.canRestore ? "capture+restore" : "capture only" : "unavailable";
+          return `- ${pr.label} (${pr.id}): ${cap}${pr.detail ? ` \u2014 ${pr.detail}` : ""}`;
+        });
+        const snapLines = snapshots.map((s) => {
+          const warnings = Object.values(s.sources).reduce((n, src) => n + src.warnings.length, 0);
+          const desc = s.baseline ? "baseline \u2014 restore wipes to fresh install (always reloads)" : `${kb(s.sizeBytes)} \xB7 ${Object.keys(s.sources).join(", ")}`;
+          return `- \`${s.id}\` **${s.name}** \u2014 ${new Date(s.createdAt).toISOString()} \xB7 ${desc}${warnings ? ` \xB7 \u26A0 ${warnings}` : ""}`;
+        });
+        const parts = [
+          `**Time Machine \u2014 ${snapshots.length} snapshot(s):**`,
+          snapLines.length ? snapLines.join("\n") : "_none yet \u2014 capture one with time_machine_action_",
+          `**Sources:**
+${providerLines.join("\n") || "_no providers registered_"}`
+        ];
+        if (p.lastOutcome) parts.push(`**Last restore:**
+${formatOutcome(p.lastOutcome)}`);
+        return text11(parts.join("\n\n"));
+      } catch (e) {
+        return fail12(errMsg12(e));
+      }
+    }
+  );
+  server.registerTool(
+    "time_machine_action",
+    {
+      description: "Manage Time Machine state snapshots: capture the app's current state as a named restore point, preview what restoring one would change (per-item added/removed/changed/won't-apply verdicts \u2014 check the blast radius BEFORE restoring), restore one (mode 'live' replaces state in place; 'reload' restores persisted storage then reloads the JS bundle \u2014 baselines always reload), capture_baseline (an empty wipe-to-fresh-install restore point), delete, or rename. The restore result reports per-source applied/skipped counts \u2014 check them rather than assuming success.",
+      inputSchema: {
+        action: import_zod12.z.enum(["capture", "capture_baseline", "preview", "restore", "delete", "rename"]).describe("What to do."),
+        id: import_zod12.z.string().optional().describe("Snapshot id (required for restore/delete/rename; from get_time_machine)."),
+        name: import_zod12.z.string().optional().describe("Snapshot name (for capture and rename)."),
+        mode: import_zod12.z.enum(["live", "reload"]).optional().describe("Restore mode. Default 'live'."),
+        excludeKeys: import_zod12.z.array(import_zod12.z.string()).optional().describe('Restore only: item keys to LEAVE UNTOUCHED, as "sourceId::itemKey" (itemKey = the key shown by the preview action, e.g. "query::[\\"pokemon\\"]" or "storage::async:@cart").'),
+        sourceIds: import_zod12.z.array(import_zod12.z.string()).optional().describe("Capture/restore only these source ids (default all)."),
+        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+      }
+    },
+    async (args) => {
+      try {
+        const target = sync.requireProDevice(args.deviceId);
+        const call = (action, params) => sync.callAction(TIME_MACHINE_TOOL_ID, action, params, target);
+        switch (args.action) {
+          case "capture": {
+            const result = await call("capture", { name: args.name ?? "", sourceIds: args.sourceIds });
+            const s = result.snapshot;
+            const warnings = Object.entries(s.sources).flatMap(([sid, src]) => src.warnings.map((w) => `
+  \u26A0 ${sid}: ${w}`)).join("");
+            return text11(`Captured \`${s.id}\` "${s.name}" \u2014 ${kb(s.sizeBytes)} \xB7 ${Object.keys(s.sources).join(", ")}${warnings}`);
+          }
+          case "capture_baseline": {
+            const result = await call("captureBaseline", {});
+            return text11(`Captured baseline \`${result.snapshot.id}\` \u2014 restoring it wipes app storage and reloads.`);
+          }
+          case "preview": {
+            if (!args.id) return fail12("preview requires `id` (from get_time_machine).");
+            const result = await call("preview", { id: args.id });
+            const lines = [];
+            let totalApplies = 0;
+            for (const src of result.sources) {
+              const counts = {};
+              for (const item of src.items) {
+                counts[item.verdict] = (counts[item.verdict] ?? 0) + 1;
+              }
+              const applies = (counts.added ?? 0) + (counts.removed ?? 0) + (counts.changed ?? 0) + (counts["too-large"] ?? 0);
+              totalApplies += applies;
+              const parts = Object.entries(counts).filter(([v]) => v !== "unchanged").map(([v, n]) => `${n} ${v}`);
+              lines.push(`- **${src.label}**: ${parts.length ? parts.join(", ") : "no changes"}${src.error ? ` \u2014 \u26A0 ${src.error}` : ""}`);
+              for (const item of src.items.filter((i) => i.verdict !== "unchanged").slice(0, 8)) {
+                lines.push(`    ${item.verdict === "added" ? "+" : item.verdict === "removed" ? "\u2212" : item.verdict === "wont-apply" ? "\u2298" : "\u2248"} ${item.label}${item.reason ? ` (${item.reason})` : ""}`);
+              }
+              for (const note of src.notes) lines.push(`    \xB7 ${note}`);
+            }
+            const head = totalApplies === 0 ? "**Restore would change NOTHING** (states identical or nothing applicable)." : `**Restore would apply ${totalApplies} change(s):**`;
+            return text11(`${head}
+${lines.join("\n")}`);
+          }
+          case "restore": {
+            if (!args.id) return fail12("restore requires `id` (from get_time_machine).");
+            const outcome = await call("restore", {
+              id: args.id,
+              mode: args.mode ?? "live",
+              excludeKeys: args.excludeKeys
+            });
+            return text11(formatOutcome(outcome));
+          }
+          case "delete": {
+            if (!args.id) return fail12("delete requires `id`.");
+            await call("delete", { id: args.id });
+            return text11(`Deleted snapshot \`${args.id}\`.`);
+          }
+          case "rename": {
+            if (!args.id || !args.name) return fail12("rename requires `id` and `name`.");
+            await call("rename", { id: args.id, name: args.name });
+            return text11(`Renamed \`${args.id}\` to "${args.name}".`);
+          }
+        }
+      } catch (e) {
+        return fail12(errMsg12(e));
+      }
+    }
+  );
+}
+
+// src/tools/packs/screenshot.ts
+var import_zod13 = require("zod");
 
 // src/capture/simctl.ts
 var import_node_child_process = require("child_process");
@@ -2407,8 +2635,8 @@ async function cropToBuffer(srcPath, full, region) {
 var TOOL_ID = "highlight-updates";
 var MARGIN_PT = 12;
 var CAPTURE_PADDING_PT = 6;
-var fail12 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg12 = (e) => e instanceof Error ? e.message : String(e);
+var fail13 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
 function reasonMessage(res, query) {
   switch (res.reason) {
     case "no-renders":
@@ -2438,10 +2666,10 @@ function registerScreenshotTools(server, sync) {
     {
       description: "Take a tight, cropped screenshot of a single React Native component running in the iOS Simulator \u2014 no manual coordinates needed. Give a testID, nativeID, accessibilityLabel, or component name in `query` (or an exact `nativeTag` from a previous call's candidates) and it locates the live component on-device (scrolling it into view), then captures + crops the Simulator framebuffer to just that component. The component must have rendered at least once since the app opened for it to be trackable \u2014 if nothing matches, navigate to the screen that renders it and retry. iOS Simulator only, and the MCP server must be running on the same Mac as the booted Simulator (uses `xcrun simctl` + `sips`). Requires Buoy Pro.",
       inputSchema: {
-        query: import_zod12.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
-        nativeTag: import_zod12.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
-        scrollIntoView: import_zod12.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
-        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        query: import_zod13.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
+        nativeTag: import_zod13.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
+        scrollIntoView: import_zod13.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
+        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -2461,11 +2689,11 @@ function registerScreenshotTools(server, sync) {
           target
         );
         if (!res.matched || !res.rect || !res.screen) {
-          return fail12(reasonMessage(res, args.query) + candidatesText(res.candidates));
+          return fail13(reasonMessage(res, args.query) + candidatesText(res.candidates));
         }
         const shot = await captureIosFramebuffer();
         if (!shot.ok || !shot.srcPath || !shot.width || !shot.height) {
-          return fail12(shot.error ?? "Screenshot capture failed.");
+          return fail13(shot.error ?? "Screenshot capture failed.");
         }
         const pxScale = shot.width / res.screen.width;
         const r = res.rect;
@@ -2481,7 +2709,7 @@ function registerScreenshotTools(server, sync) {
           }
         );
         if (!crop.ok || !crop.buffer) {
-          return fail12(crop.error ?? "Crop failed.");
+          return fail13(crop.error ?? "Crop failed.");
         }
         const label = res.componentName || "component";
         const idPart = res.testID ? ` (testID: "${res.testID}")` : "";
@@ -2494,21 +2722,21 @@ function registerScreenshotTools(server, sync) {
           ]
         };
       } catch (e) {
-        return fail12(errMsg12(e));
+        return fail13(errMsg13(e));
       }
     }
   );
 }
 
 // src/tools/packs/interact.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var TOOL_ID2 = "highlight-updates";
-var text11 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail13 = (message) => ({
+var text12 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail14 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg14 = (e) => e instanceof Error ? e.message : String(e);
 function formatElement(e) {
   let line = e.interactive ? "\u2022 " : "  ";
   line += e.name;
@@ -2528,8 +2756,8 @@ function registerInteractTools(server, sync) {
     {
       description: "List the interactive / labeled elements currently on screen \u2014 the app's live accessibility-style tree walked from the React fiber tree. Each row shows the component name, visible text/label, role, testID, a normalized tap point (tap: x,y in 0\u20131), and its #nativeTag. Rows marked with \u2022 are tappable (have an onPress). Use this to see what's on screen and pick something to tap with tap_element \u2014 no screenshot needed. Re-run after navigating or when the screen changes, since positions move. Requires Buoy Pro.",
       inputSchema: {
-        interactiveOnly: import_zod13.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
-        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        interactiveOnly: import_zod14.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
+        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -2539,16 +2767,16 @@ function registerInteractTools(server, sync) {
         const all = res?.elements ?? [];
         const elements = args.interactiveOnly ? all.filter((e) => e.interactive) : all;
         if (elements.length === 0) {
-          return text11(
+          return text12(
             "No elements found on screen. If the app just navigated, wait a moment and retry; make sure highlight-updates is enabled in the app."
           );
         }
         const header = `Screen ${res.screen.width}\xD7${res.screen.height} \u2014 ${elements.length} element${elements.length === 1 ? "" : "s"} (\u2022 = tappable). Tap with tap_element({ testID | query | nativeTag }).`;
-        return text11(`${header}
+        return text12(`${header}
 
 ${elements.map(formatElement).join("\n")}`);
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail14(errMsg14(e));
       }
     }
   );
@@ -2557,20 +2785,20 @@ ${elements.map(formatElement).join("\n")}`);
     {
       description: "Interact with an on-screen element by invoking its handler directly in JS (no screenshot, no coordinate math, works on real devices). Handles buttons (onPress + onLongPress), toggles/switches and sliders (onValueChange), and text inputs (onChangeText) \u2014 see each element's `control` in describe_screen. Identify the target with an exact `nativeTag` or `testID`, or a fuzzy `query`. Pass `longPress:true` to invoke onLongPress instead of onPress (elements that support it show {long-press} in describe_screen). For a toggle, pass `value:true/false` (omit to flip); for a slider, pass a numeric `value` (omit to jump to the far end); for a text input, pass `text`. If the element is off-screen it's scrolled into view first (scrollIntoView:false to skip). Call describe_screen first to see options + current values. Requires Buoy Pro.",
       inputSchema: {
-        nativeTag: import_zod13.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
-        testID: import_zod13.z.string().optional().describe("Exact testID of the element."),
-        query: import_zod13.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
-        value: import_zod13.z.union([import_zod13.z.number(), import_zod13.z.boolean()]).optional().describe("For a toggle: true/false (omit to flip). For a slider: the numeric value (omit to jump to the far end)."),
-        text: import_zod13.z.string().optional().describe("For a text input: the string to set via onChangeText."),
-        longPress: import_zod13.z.boolean().optional().describe("Invoke the element's onLongPress instead of onPress. Fails with a clear reason if the element has no onLongPress handler."),
-        scrollIntoView: import_zod13.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
-        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        nativeTag: import_zod14.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
+        testID: import_zod14.z.string().optional().describe("Exact testID of the element."),
+        query: import_zod14.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
+        value: import_zod14.z.union([import_zod14.z.number(), import_zod14.z.boolean()]).optional().describe("For a toggle: true/false (omit to flip). For a slider: the numeric value (omit to jump to the far end)."),
+        text: import_zod14.z.string().optional().describe("For a text input: the string to set via onChangeText."),
+        longPress: import_zod14.z.boolean().optional().describe("Invoke the element's onLongPress instead of onPress. Fails with a clear reason if the element has no onLongPress handler."),
+        scrollIntoView: import_zod14.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
+        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
       try {
         if (args.nativeTag == null && !args.testID && !args.query) {
-          return fail13("Provide one of: nativeTag, testID, or query (from describe_screen).");
+          return fail14("Provide one of: nativeTag, testID, or query (from describe_screen).");
         }
         const target = sync.requireProDevice(args.deviceId);
         const res = await sync.callAction(
@@ -2593,26 +2821,26 @@ ${elements.map(formatElement).join("\n")}`);
           const id = m.testID ? ` [testID=${m.testID}]` : m.nativeTag != null ? ` #${m.nativeTag}` : "";
           const scrolledNote = res.scrolled ? " (scrolled into view)" : "";
           const verb = m.via === "onValueChange" ? `Set "${label}"${id} \u2192 ${JSON.stringify(m.value)}` : m.via === "onChangeText" ? `Typed ${JSON.stringify(m.value)} into "${label}"${id}` : m.via === "onLongPress" ? `Long-pressed "${label}"${id}` : `Tapped "${label}"${id}`;
-          return text11(`${verb}${scrolledNote}.`);
+          return text12(`${verb}${scrolledNote}.`);
         }
         let msg = res?.reason ?? "Tap failed.";
         if (res?.candidates?.length) {
           msg += "\n\nTappable candidates:\n" + res.candidates.map((c) => `- ${c.name}${c.text ? ` "${c.text}"` : ""}${c.testID ? ` [testID=${c.testID}]` : ""}${c.nativeTag != null ? ` #${c.nativeTag}` : ""}`).join("\n");
         }
-        return fail13(msg);
+        return fail14(msg);
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail14(errMsg14(e));
       }
     }
   );
 }
 
 // src/tools/packs/jsThread.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var JS_TOP_TOOL_ID = "js-top";
-var text12 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail14 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg14 = (e) => e instanceof Error ? e.message : String(e);
+var text13 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail15 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg15 = (e) => e instanceof Error ? e.message : String(e);
 var SPARK_CHARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
 function sparkline(values) {
   const max = Math.max(1, ...values);
@@ -2683,9 +2911,9 @@ function registerJsThreadTools(server, sync) {
     {
       description: "Task Manager for the React Native JS thread: sample for a few seconds and return a ranked table of which task origins (timers, Promise chains, rAF callbacks, bridge call-ins) consumed JS-thread time \u2014 plus thread busy% and freeze (50ms+ block) attribution. Use when JS FPS is low and you need to know WHAT is eating the thread. To profile one specific interaction, pass clearFirst:true, then drive the UI with tap_element while the sample runs. Drill into a row with get_js_thread_origin_detail. Requires @buoy-gg/js-top on the device.",
       inputSchema: {
-        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        durationMs: import_zod14.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
-        clearFirst: import_zod14.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        durationMs: import_zod15.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
+        clearFirst: import_zod15.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
       }
     },
     async ({ deviceId, durationMs, clearFirst }) => {
@@ -2698,7 +2926,7 @@ function registerJsThreadTools(server, sync) {
           { durationMs: duration, clearFirst: clearFirst === true },
           target
         );
-        if (!snap) return fail14("Device returned no snapshot \u2014 is @buoy-gg/js-top installed in the app?");
+        if (!snap) return fail15("Device returned no snapshot \u2014 is @buoy-gg/js-top installed in the app?");
         const md = formatTopMarkdown(snap, duration);
         const slim = {
           busyPct: Math.round(snap.busyPct * 10) / 10,
@@ -2717,13 +2945,13 @@ function registerJsThreadTools(server, sync) {
             worstFreezeMs: r.worstFreezeMs
           }))
         };
-        return text12(`${md}
+        return text13(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail15(errMsg15(e));
       }
     }
   );
@@ -2732,8 +2960,8 @@ ${JSON.stringify(slim)}
     {
       description: 'Inspect one js-top task origin in depth: schedules vs runs, avg/max/total exclusive ms, a 5s activity sparkline, freeze attribution, and the captured scheduling site (caller function + stack frames). Pass a row `key` from get_js_thread_top\'s JSON (e.g. "interval|pollFeed" or "unattributed" for the system row).',
       inputSchema: {
-        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        key: import_zod14.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        key: import_zod15.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
       }
     },
     async ({ deviceId, key }) => {
@@ -2746,18 +2974,18 @@ ${JSON.stringify(slim)}
           target
         );
         if (!detail) {
-          return fail14(
+          return fail15(
             `Origin "${key}" is not tracked (cleared, evicted, or never existed). Re-run get_js_thread_top for current keys.`
           );
         }
         const md = formatDetailMarkdown(detail);
-        return text12(`${md}
+        return text13(`${md}
 
 \`\`\`json
 ${JSON.stringify(detail)}
 \`\`\``);
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail15(errMsg15(e));
       }
     }
   );
@@ -2766,27 +2994,27 @@ ${JSON.stringify(detail)}
     {
       description: "Reset the js-top task table, freeze history, and busy history on the device (fresh measurement window).",
       inputSchema: {
-        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async ({ deviceId }) => {
       try {
         const target = sync.requireProDevice(deviceId);
         await sync.callAction(JS_TOP_TOOL_ID, "clear", {}, target);
-        return text12("Cleared js-top stats.");
+        return text13("Cleared js-top stats.");
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail15(errMsg15(e));
       }
     }
   );
 }
 
 // src/tools/packs/images.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var IMAGES_TOOL_ID = "images";
-var text13 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail15 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg15 = (e) => e instanceof Error ? e.message : String(e);
+var text14 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail16 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg16 = (e) => e instanceof Error ? e.message : String(e);
 function uriTail(uri) {
   if (!uri) return "(no source)";
   const unstable = uri.match(/[?&]unstable_path=([^&?]+)/);
@@ -2874,9 +3102,9 @@ function registerImagesTools(server, sync) {
     {
       description: "Live image registry from the app: every RN <Image> and expo-image load with cache verdict (memory/disk/network), load ms, decoded vs displayed size with an oversize/upscale verdict and wasted-KB estimate, error details, and any active simulation overrides. Image HTTP never hits the JS network stack, so this is the only visibility into image loading. Requires @buoy-gg/images on the device.",
       inputSchema: {
-        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        limit: import_zod15.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
-        status: import_zod15.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
+        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        limit: import_zod16.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
+        status: import_zod16.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
       }
     },
     async ({ deviceId, limit, status }) => {
@@ -2889,7 +3117,7 @@ function registerImagesTools(server, sync) {
           { limit: capped, status },
           target
         );
-        if (!list) return fail15("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
+        if (!list) return fail16("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
         const md = formatListMarkdown(list, capped);
         const slim = {
           stats: list.stats,
@@ -2916,13 +3144,13 @@ function registerImagesTools(server, sync) {
             layoutShifts: r.layoutShifts
           }))
         };
-        return text13(`${md}
+        return text14(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail15(errMsg15(e));
+        return fail16(errMsg16(e));
       }
     }
   );
@@ -2931,9 +3159,9 @@ ${JSON.stringify(slim)}
     {
       description: "Act on one image from get_images (by id): hard_reload (bypass caches + refetch), retry, evict_disk (expo disk entry), flash (red border to locate it on screen), prove_savings (re-encode at displayed size as WebP ON DEVICE and return real byte savings + a previewable file:// uri), or simulation overrides \u2014 force_error (instant offline-safe failure), force_loading (request hangs forever), force_blank, swap_url (requires url), restore (remove override). Returns the record's state after the action so the effect is visible.",
       inputSchema: {
-        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        id: import_zod15.z.number().describe("Record id from get_images."),
-        action: import_zod15.z.enum([
+        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        id: import_zod16.z.number().describe("Record id from get_images."),
+        action: import_zod16.z.enum([
           "hard_reload",
           "retry",
           "evict_disk",
@@ -2945,7 +3173,7 @@ ${JSON.stringify(slim)}
           "swap_url",
           "restore"
         ]).describe("What to do."),
-        url: import_zod15.z.string().optional().describe("Replacement URL (swap_url only).")
+        url: import_zod16.z.string().optional().describe("Replacement URL (swap_url only).")
       }
     },
     async ({ deviceId, id, action, url }) => {
@@ -2953,8 +3181,8 @@ ${JSON.stringify(slim)}
         const target = sync.requireProDevice(deviceId);
         if (action === "prove_savings") {
           const savings = await sync.callAction(IMAGES_TOOL_ID, "proveSavings", { id }, target);
-          if (!savings) return fail15("Device returned nothing for proveSavings.");
-          if (!savings.ok) return fail15(savings.message);
+          if (!savings) return fail16("Device returned nothing for proveSavings.");
+          if (!savings.ok) return fail16(savings.message);
           const parts = [`**prove_savings** on #${id}: ${savings.message}`];
           if (savings.originalBytes != null)
             parts.push(`Original: ${Math.round(savings.originalBytes / 1024)}KB (${savings.originalBytesSource})`);
@@ -2966,11 +3194,11 @@ ${JSON.stringify(slim)}
             parts.push(`**Saved: ${Math.round(savings.savedBytes / 1024)}KB (${savings.savedPct}%)**`);
           if (savings.optimizedUri)
             parts.push(`Preview in place: image_action {id:${id}, action:"swap_url", url:"${savings.optimizedUri}"}`);
-          return text13(parts.join("\n"));
+          return text14(parts.join("\n"));
         }
         const entry = ACTION_MAP[action];
-        if (!entry) return fail15(`Unknown action: ${action}`);
-        if (action === "swap_url" && !url) return fail15("swap_url requires the `url` param.");
+        if (!entry) return fail16(`Unknown action: ${action}`);
+        if (action === "swap_url" && !url) return fail16("swap_url requires the `url` param.");
         const result = await sync.callAction(
           IMAGES_TOOL_ID,
           entry.action,
@@ -2990,9 +3218,9 @@ ${JSON.stringify(slim)}
           );
           if (detail.error) lines.push(`Error: ${detail.error}`);
         }
-        return text13(lines.join("\n"));
+        return text14(lines.join("\n"));
       } catch (e) {
-        return fail15(errMsg15(e));
+        return fail16(errMsg16(e));
       }
     }
   );
@@ -3001,12 +3229,12 @@ ${JSON.stringify(slim)}
     {
       description: "App-wide image simulation modes: network 'offline' (every NETWORK image load fails immediately, both libs \u2014 bundled assets still load; reload/remount on-screen images to see it), 'cold' (every image bypasses caches \u2014 first-launch behavior, nothing cleared), 'normal' to reset. blankImages renders every image without a source. massAction applies per-image simulations to everything mounted. Also clears the registry or expo caches when asked.",
       inputSchema: {
-        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        network: import_zod15.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
-        blankImages: import_zod15.z.boolean().optional().describe("Render all images without a source."),
-        massAction: import_zod15.z.enum(["error", "loading", "blank", "reload", "flash", "restore"]).optional().describe("Apply to EVERY mounted image at once: force error/loading/blank overrides, hard-reload all, flash all, or restore all overrides."),
-        clearRegistry: import_zod15.z.boolean().optional().describe("Clear the captured image log."),
-        clearExpoCaches: import_zod15.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
+        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        network: import_zod16.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
+        blankImages: import_zod16.z.boolean().optional().describe("Render all images without a source."),
+        massAction: import_zod16.z.enum(["error", "loading", "blank", "reload", "flash", "restore"]).optional().describe("Apply to EVERY mounted image at once: force error/loading/blank overrides, hard-reload all, flash all, or restore all overrides."),
+        clearRegistry: import_zod16.z.boolean().optional().describe("Clear the captured image log."),
+        clearExpoCaches: import_zod16.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
       }
     },
     async ({ deviceId, network, blankImages, massAction, clearRegistry, clearExpoCaches }) => {
@@ -3033,22 +3261,22 @@ ${JSON.stringify(slim)}
           const r = await sync.callAction(IMAGES_TOOL_ID, "clearExpoCaches", {}, target);
           done.push(r?.message ?? "expo caches cleared");
         }
-        if (done.length === 0) return fail15("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
-        return text13(`Applied: ${done.join(" \xB7 ")}`);
+        if (done.length === 0) return fail16("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
+        return text14(`Applied: ${done.join(" \xB7 ")}`);
       } catch (e) {
-        return fail15(errMsg15(e));
+        return fail16(errMsg16(e));
       }
     }
   );
 }
 
 // src/tools/packs/assets.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var ASSETS_TOOL_ID = "assets";
-var text14 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail16 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg16 = (e) => e instanceof Error ? e.message : String(e);
-function kb(bytes) {
+var text15 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail17 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg17 = (e) => e instanceof Error ? e.message : String(e);
+function kb2(bytes) {
   if (bytes == null || bytes <= 0) return "\u2013";
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
@@ -3056,7 +3284,7 @@ function kb(bytes) {
 }
 function sizeLabel(r) {
   if (r.sizeBytes == null) return "\u2013";
-  return r.sizeSource === "measured" ? kb(r.sizeBytes) : `~${kb(r.sizeBytes)}`;
+  return r.sizeSource === "measured" ? kb2(r.sizeBytes) : `~${kb2(r.sizeBytes)}`;
 }
 function scalesLabel(scales) {
   if (!scales.length) return "\u2013";
@@ -3079,9 +3307,9 @@ function formatListMarkdown2(list, limit) {
   const ss = list.scanStatus;
   lines.push(`## Asset inventory (${list.total} assets, showing ${Math.min(limit, list.records.length)}, largest first)`);
   lines.push("");
-  const kindBits = Object.entries(s.byKind).filter(([, v]) => v.count > 0).map(([k, v]) => `${v.count} ${k}${v.bytes > 0 ? ` (${kb(v.bytes)})` : ""}`);
+  const kindBits = Object.entries(s.byKind).filter(([, v]) => v.count > 0).map(([k, v]) => `${v.count} ${k}${v.bytes > 0 ? ` (${kb2(v.bytes)})` : ""}`);
   lines.push(
-    `${s.loaded} loaded \xB7 ${s.neverLoaded} never loaded \xB7 ` + (s.totalBytes > 0 ? `${kb(s.totalBytes)} measured (${s.measuredCount}/${s.total})` : "sizes not measured") + ` \xB7 ${kindBits.join(" \xB7 ")}`
+    `${s.loaded} loaded \xB7 ${s.neverLoaded} never loaded \xB7 ` + (s.totalBytes > 0 ? `${kb2(s.totalBytes)} measured (${s.measuredCount}/${s.total})` : "sizes not measured") + ` \xB7 ${kindBits.join(" \xB7 ")}`
   );
   if (ss.fontFamilies.length > 0) {
     lines.push(`Loaded font families: ${ss.fontFamilies.join(", ")}`);
@@ -3097,7 +3325,7 @@ function formatListMarkdown2(list, limit) {
   if (ins.neverLoaded.length) chips.push(`${ins.neverLoaded.length} never loaded`);
   if (ins.duplicates.length) {
     const wasted = ins.duplicates.reduce((sum, d) => sum + (d.wastedBytes ?? 0), 0);
-    chips.push(`${ins.duplicates.length} duplicate group(s)${wasted > 0 ? ` (${kb(wasted)} wasted)` : ""}`);
+    chips.push(`${ins.duplicates.length} duplicate group(s)${wasted > 0 ? ` (${kb2(wasted)} wasted)` : ""}`);
   }
   if (ins.overDecode.length) chips.push(`${ins.overDecode.length} decode larger than 2\xD7 the screen`);
   if (ins.webpCandidates.length) chips.push(`${ins.webpCandidates.length} WebP candidate(s)`);
@@ -3111,7 +3339,7 @@ function formatListMarkdown2(list, limit) {
   }
   const diff = list.diff;
   if (diff) {
-    const net = diff.netBytes == null ? "net unknown" : Math.abs(diff.netBytes) < 1024 ? "\xB10 net" : `${diff.netBytes >= 0 ? "+" : "\u2212"}${kb(Math.abs(diff.netBytes))} net`;
+    const net = diff.netBytes == null ? "net unknown" : Math.abs(diff.netBytes) < 1024 ? "\xB10 net" : `${diff.netBytes >= 0 ? "+" : "\u2212"}${kb2(Math.abs(diff.netBytes))} net`;
     lines.push("");
     lines.push(
       `**Since baseline** (${new Date(diff.baselineSavedAt).toISOString()}): ${diff.added.length} added \xB7 ${diff.removed.length} removed \xB7 ${diff.grown.length} grew \xB7 ${net}` + (diff.removed.length ? ` \u2014 removed: ${diff.removed.slice(0, 5).map((r) => `${r.name}.${r.type}`).join(", ")}${diff.removed.length > 5 ? "\u2026" : ""}` : "")
@@ -3138,10 +3366,10 @@ function registerAssetsTools(server, sync) {
     {
       description: "Bundled-asset inventory from the app: every asset (images, fonts, video, audio) with dimensions, @1x/@2x/@3x scale coverage, byte sizes (measured from the Metro server in dev), loaded vs never-loaded state, and audit findings \u2014 duplicates (by content hash), shipped-but-never-loaded, WebP candidates, images decoding larger than the screen, heavy GIFs/fonts, scale gaps \u2014 plus the change vs a saved baseline. This is what the app SHIPS; use get_images for what it RENDERS. Requires @buoy-gg/assets on the device.",
       inputSchema: {
-        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        limit: import_zod16.z.number().optional().describe("Max records to return (largest first). Default 40, max 500."),
-        kind: import_zod16.z.enum(["image", "font", "video", "audio", "data", "other"]).optional().describe("Only assets of this kind."),
-        unusedOnly: import_zod16.z.boolean().optional().describe("Only assets shipped in the bundle but never loaded at runtime.")
+        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        limit: import_zod17.z.number().optional().describe("Max records to return (largest first). Default 40, max 500."),
+        kind: import_zod17.z.enum(["image", "font", "video", "audio", "data", "other"]).optional().describe("Only assets of this kind."),
+        unusedOnly: import_zod17.z.boolean().optional().describe("Only assets shipped in the bundle but never loaded at runtime.")
       }
     },
     async ({ deviceId, limit, kind, unusedOnly }) => {
@@ -3154,7 +3382,7 @@ function registerAssetsTools(server, sync) {
           { limit: unusedOnly ? 500 : capped, kind, loadedOnly: false },
           target
         );
-        if (!list) return fail16("Device returned nothing \u2014 is @buoy-gg/assets installed in the app?");
+        if (!list) return fail17("Device returned nothing \u2014 is @buoy-gg/assets installed in the app?");
         if (unusedOnly) {
           list.records = list.records.filter((r) => !r.loaded).slice(0, capped);
         }
@@ -3178,13 +3406,13 @@ function registerAssetsTools(server, sync) {
             sizeSource: r.sizeSource
           }))
         };
-        return text14(`${md}
+        return text15(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail16(errMsg16(e));
+        return fail17(errMsg17(e));
       }
     }
   );
@@ -3193,9 +3421,9 @@ ${JSON.stringify(slim)}
     {
       description: "Drive the assets tool: rescan (re-walk the registry + merge the Metro bundle graph + refresh fonts + measure sizes \u2014 run this first if the inventory looks stale or empty), measure_sizes (re-measure byte sizes only), detail (full metadata for one asset by id: source dir, per-scale sizes, resolved URI, per-file graph paths), save_baseline (persist the current inventory for before/after comparison \u2014 save, make your change, then get_assets shows added/removed/grown/net bytes), clear_baseline, clear_records (wipe + rescan rebuilds).",
       inputSchema: {
-        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        action: import_zod16.z.enum(["rescan", "measure_sizes", "detail", "save_baseline", "clear_baseline", "clear_records"]).describe("What to do."),
-        id: import_zod16.z.number().optional().describe("Asset id from get_assets (detail only).")
+        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        action: import_zod17.z.enum(["rescan", "measure_sizes", "detail", "save_baseline", "clear_baseline", "clear_records"]).describe("What to do."),
+        id: import_zod17.z.number().optional().describe("Asset id from get_assets (detail only).")
       }
     },
     async ({ deviceId, action, id }) => {
@@ -3205,19 +3433,19 @@ ${JSON.stringify(slim)}
           case "rescan": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "rescan", {}, target);
             const ss = result?.scanStatus;
-            if (!ss) return fail16("Device returned nothing for rescan.");
-            return text14(
+            if (!ss) return fail17("Device returned nothing for rescan.");
+            return text15(
               `Rescan done: ${ss.registryCount} registered at runtime` + (ss.graphCount != null ? ` \xB7 ${ss.graphCount} in the bundle graph` : " \xB7 no bundle graph") + (ss.graphError ? ` (graph: ${ss.graphError})` : "") + ` \xB7 ${ss.fontFamilies.length} font families` + (ss.measuring ? " \xB7 size measurement running \u2014 get_assets in a moment" : "")
             );
           }
           case "measure_sizes": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "measureSizes", {}, target);
-            return text14(`Measured ${result?.measured ?? 0} of ${result?.total ?? 0} assets.`);
+            return text15(`Measured ${result?.measured ?? 0} of ${result?.total ?? 0} assets.`);
           }
           case "detail": {
-            if (id == null) return fail16("detail requires the `id` param (from get_assets).");
+            if (id == null) return fail17("detail requires the `id` param (from get_assets).");
             const detail = await sync.callAction(ASSETS_TOOL_ID, "getDetail", { id }, target);
-            if (!detail) return fail16(`Asset ${id} not found \u2014 re-run get_assets for current ids.`);
+            if (!detail) return fail17(`Asset ${id} not found \u2014 re-run get_assets for current ids.`);
             const lines = [
               `## ${detail.name}.${detail.type} (#${detail.id})`,
               "",
@@ -3226,50 +3454,50 @@ ${JSON.stringify(slim)}
             if (detail.width != null) lines.push(`- Dimensions: ${detail.width}\xD7${detail.height} logical \xB7 scales ${scalesLabel(detail.scales)}`);
             if (detail.sizesByScale) {
               for (const [scale, bytes] of Object.entries(detail.sizesByScale)) {
-                lines.push(`- Size @${scale}x: ${kb(bytes)}`);
+                lines.push(`- Size @${scale}x: ${kb2(bytes)}`);
               }
             }
             if (detail.sizeBytes != null) lines.push(`- Total: ${sizeLabel(detail)}`);
-            if (detail.estDecodedBytes) lines.push(`- Decoded memory: ~${kb(detail.estDecodedBytes)} (RGBA)`);
+            if (detail.estDecodedBytes) lines.push(`- Decoded memory: ~${kb2(detail.estDecodedBytes)} (RGBA)`);
             if (detail.hash) lines.push(`- Hash: ${detail.hash}`);
             if (detail.fileSystemLocation) lines.push(`- Source dir: ${detail.fileSystemLocation}`);
             if (detail.files?.length) lines.push(`- Files: ${detail.files.join(", ")}`);
             if (detail.uri) lines.push(`- Resolved URI: ${detail.uri}`);
-            return text14(lines.join("\n"));
+            return text15(lines.join("\n"));
           }
           case "save_baseline": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "saveBaseline", {}, target);
-            return text14(
+            return text15(
               `Baseline saved (${result?.assets ?? 0} assets). Make your change, then get_assets reports added/removed/grown/net bytes against it.`
             );
           }
           case "clear_baseline": {
             await sync.callAction(ASSETS_TOOL_ID, "clearBaseline", {}, target);
-            return text14("Baseline cleared.");
+            return text15("Baseline cleared.");
           }
           case "clear_records": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "clearRecords", {}, target);
-            return text14(result?.message ?? "Inventory cleared.");
+            return text15(result?.message ?? "Inventory cleared.");
           }
         }
       } catch (e) {
-        return fail16(errMsg16(e));
+        return fail17(errMsg17(e));
       }
     }
   );
 }
 
 // src/tools/packs/reload.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var APP_TOOL_ID = "app";
 var RELOAD_ACTION = "reloadApp";
 var DEFAULT_WAIT_MS = 3e4;
 var TEARDOWN_GRACE_MS = 1200;
 var PROBE_TIMEOUT_MS = 1500;
 var PROBE_INTERVAL_MS = 400;
-var text15 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail17 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg17 = (e) => e instanceof Error ? e.message : String(e);
+var text16 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail18 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg18 = (e) => e instanceof Error ? e.message : String(e);
 var delay3 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function ping(sync, deviceId, timeoutMs) {
   try {
@@ -3304,12 +3532,12 @@ function registerReloadTools(server, sync) {
     {
       description: "Reload the running app's JS bundle (Expo Go, dev client, or RN CLI) \u2014 the equivalent of shaking the device and hitting Reload, but from here. Use it to pick up a change Fast Refresh didn't apply, to clear leaked in-memory state before a measurement, or to re-run app startup. In dev builds it uses React Native's DevSettings.reload(); otherwise it falls back to expo-updates (if the app installs it). All in-memory state is lost. By default this waits for the app to come back up and reports how long the reload took. Works on any app running @buoy-gg/core \u2014 no particular tool package needed. Requires Buoy Pro.",
       inputSchema: {
-        strategy: import_zod17.z.enum(["auto", "dev-settings", "expo-updates"]).optional().describe(
+        strategy: import_zod18.z.enum(["auto", "dev-settings", "expo-updates"]).optional().describe(
           "Reload mechanism. 'auto' (default) uses DevSettings in dev builds and expo-updates otherwise. Force one only when debugging the reload itself."
         ),
-        wait: import_zod17.z.boolean().optional().describe("Wait for the app to come back before returning. Default true \u2014 turn off for fire-and-forget."),
-        timeoutMs: import_zod17.z.number().optional().describe("How long to wait for the app to reconnect, in ms. Default 30000."),
-        deviceId: import_zod17.z.string().optional().describe('Target device id (auto-selected if one is connected). Use "All" to reload every connected app.')
+        wait: import_zod18.z.boolean().optional().describe("Wait for the app to come back before returning. Default true \u2014 turn off for fire-and-forget."),
+        timeoutMs: import_zod18.z.number().optional().describe("How long to wait for the app to reconnect, in ms. Default 30000."),
+        deviceId: import_zod18.z.string().optional().describe('Target device id (auto-selected if one is connected). Use "All" to reload every connected app.')
       }
     },
     async (args) => {
@@ -3325,19 +3553,19 @@ function registerReloadTools(server, sync) {
         );
         const via = ack?.strategy ? ` via ${ack.strategy}` : "";
         if (args.wait === false) {
-          return text15(`Reload requested${via}. The app is restarting \u2014 its in-memory state is gone; re-read anything you cached.`);
+          return text16(`Reload requested${via}. The app is restarting \u2014 its in-memory state is gone; re-read anything you cached.`);
         }
         const elapsed = await waitForAppBack(sync, target, args.timeoutMs ?? DEFAULT_WAIT_MS, previousRealm);
         if (elapsed == null) {
-          return fail17(
+          return fail18(
             `Reload was accepted${via}, but the app hasn't reconnected yet. It may still be building the bundle (a cold Metro rebuild can take a while) \u2014 check the device, then run list_devices.`
           );
         }
-        return text15(
+        return text16(
           `Reloaded the app${via} \u2014 back and connected after ${(elapsed / 1e3).toFixed(1)}s. All in-memory state was reset, so re-read any state you cached before this.`
         );
       } catch (e) {
-        return fail17(errMsg17(e));
+        return fail18(errMsg18(e));
       }
     }
   );
@@ -3392,6 +3620,14 @@ measurement, re-running startup)? \`reload_app\` reloads the JS bundle \u2014 De
 builds, expo-updates otherwise \u2014 and waits for the app to reconnect. It wipes in-memory state, so
 re-read anything you cached.
 
+Testing a multi-step flow repeatedly (cart \u2192 checkout, login states, a bug that needs specific
+state)? \`time_machine_action\` captures the app's COMPLETE client state (storage, redux, zustand,
+jotai, react-query cache) as a named restore point and restores it in one call \u2014 capture once,
+drive the flow with \`tap_element\`, restore, repeat. \`get_time_machine\` lists restore points and
+which sources are restorable. Restore mode 'live' swaps state in place; 'reload' restores
+persisted storage then reloads the bundle (bulletproof; baselines = wipe to fresh install).
+Check the per-source applied/skipped results it returns \u2014 a partial restore is reported, not hidden.
+
 For everything else:
 - \`list_tool_actions\` to see what a tool can do,
 - \`get_snapshot\` ONLY when you need a tool's full current state (returns raw, heavy payloads),
@@ -3419,6 +3655,7 @@ function createMcpServer(sync) {
   registerStorageTools(server, sync);
   registerRoutesTools(server, sync);
   registerConsoleTools(server, sync);
+  registerTimeMachineTools(server, sync);
   registerScreenshotTools(server, sync);
   registerInteractTools(server, sync);
   registerJsThreadTools(server, sync);
@@ -3428,7 +3665,7 @@ function createMcpServer(sync) {
   return server;
 }
 var deviceIdField = {
-  deviceId: import_zod18.z.string().optional().describe(
+  deviceId: import_zod19.z.string().optional().describe(
     'Target device id (from list_devices). Omit to auto-select when exactly one device is connected. Use "All" to broadcast.'
   )
 };