@swmansion/argent 0.32.1-next.12 → 0.32.1-next.14

package/dist/tool-server.cjs

@@ -1709,6 +1709,8 @@ var init_failure_codes = __esm({
       REACT_PROFILER_START_FAILED: "REACT_PROFILER_START_FAILED",
       REACT_PROFILER_START_VERIFY_FAILED: "REACT_PROFILER_START_VERIFY_FAILED",
       REACT_PROFILER_SESSION_TORN_DOWN: "REACT_PROFILER_SESSION_TORN_DOWN",
+      REACT_PROFILER_SESSION_TAKEN_OVER: "REACT_PROFILER_SESSION_TAKEN_OVER",
+      REACT_PROFILER_STOP_IN_PROGRESS: "REACT_PROFILER_STOP_IN_PROGRESS",
       REACT_PROFILER_HOOK_ERROR: "REACT_PROFILER_HOOK_ERROR",
       REACT_PROFILER_ANALYZE_NO_DATA: "REACT_PROFILER_ANALYZE_NO_DATA",
       NATIVE_PROFILER_FACTORY_OPTIONS_MISSING: "NATIVE_PROFILER_FACTORY_OPTIONS_MISSING",
@@ -101186,7 +101188,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.32.1-next.12";
+    return "0.32.1-next.14";
   }
   return "0.0.0";
 }
@@ -146304,23 +146306,31 @@ var BOOTSTRAP_DEVTOOLS_BACKEND_SCRIPT = `
   });
 })()
 `;
-var HEARTBEAT_SCRIPT = `
+function buildHeartbeatScript(sessionId) {
+  return `
 (function(){
+  var o = globalThis.__ARGENT_PROFILER_OWNER__;
+  if (!o || o.sessionId !== ${JSON.stringify(sessionId)}) return;
   if (typeof globalThis.__argent_profilerHeartbeat === 'function') {
     try { globalThis.__argent_profilerHeartbeat(); } catch (_e) {}
   }
 })()
 `;
+}
 var READ_STATE_SCRIPT = `
 (function __argent_readState() {
   var h = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (!h) return JSON.stringify({ hookExists: false });
   var rendererInterfaceFound = false;
   var isRunning = false;
+  var rendererStartedAtEpochMs = [];
   if (h.rendererInterfaces && typeof h.rendererInterfaces.forEach === 'function') {
     h.rendererInterfaces.forEach(function (ri) {
       rendererInterfaceFound = true;
       if (ri && ri.__argent_isProfiling__ === true) isRunning = true;
+      if (ri && typeof ri.__argent_startedAtEpochMs__ === 'number') {
+        rendererStartedAtEpochMs.push(ri.__argent_startedAtEpochMs__);
+      }
     });
   }
   if (!rendererInterfaceFound) {
@@ -146333,6 +146343,7 @@ var READ_STATE_SCRIPT = `
     isRunning: isRunning,
     owner: globalThis.__ARGENT_PROFILER_OWNER__ || null,
     nowEpochMs: Date.now(),
+    rendererStartedAtEpochMs: rendererStartedAtEpochMs,
   });
 })()
 `;
@@ -146618,6 +146629,53 @@ var RESOLVE_FIBER_META_SCRIPT = `
 })()
 `;
 
+// ../tool-server/src/utils/react-profiler/session-ownership.ts
+var DEFAULT_STALE_THRESHOLD_MS = 5 * 6e4;
+var STOP_IN_PROGRESS_NOTE = "A react-profiler-stop is collecting this run. Wait for its result before you call react-profiler-start or react-profiler-stop.";
+var STALE_OWN_RUN_NOTE = "This recording was started through this tool-server, but its heartbeat is stale, so it may be left over from another agent or an earlier conversation. If you started it, call react-profiler-stop to collect it. If not, ask the user before you discard it with react-profiler-start { force: true }.";
+function classifyStaleness({
+  owner,
+  nowEpochMs,
+  staleThresholdMs = DEFAULT_STALE_THRESHOLD_MS
+}) {
+  if (!owner) {
+    return {
+      stale: false,
+      ageSeconds: null,
+      heartbeatAgeSeconds: null,
+      canReclaimWithoutForce: true
+    };
+  }
+  const ageMs = nowEpochMs - owner.startedAtEpochMs;
+  const heartbeatAgeMs = nowEpochMs - owner.lastHeartbeatEpochMs;
+  const stale = heartbeatAgeMs > staleThresholdMs;
+  return {
+    stale,
+    ageSeconds: Math.max(0, ageMs) / 1e3,
+    heartbeatAgeSeconds: Math.max(0, Math.round(heartbeatAgeMs / 1e3)),
+    canReclaimWithoutForce: stale
+  };
+}
+function takeoverOf(state3, run2) {
+  if (run2.sessionId === null) return void 0;
+  if (state3.isRunning) {
+    if (state3.owner?.sessionId === run2.sessionId) return void 0;
+    return { by: state3.owner?.sessionId ?? null, stillRecording: true };
+  }
+  const starts = state3.rendererStartedAtEpochMs ?? [];
+  if (starts.length === 0 || run2.profileStartWallMs === null) return void 0;
+  if (starts.includes(run2.profileStartWallMs)) return void 0;
+  return { by: null, stillRecording: false };
+}
+async function readTakeover(cdp, run2) {
+  try {
+    const raw = await cdp.evaluate(READ_STATE_SCRIPT);
+    return raw ? takeoverOf(JSON.parse(raw), run2) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // ../tool-server/src/blueprints/react-profiler-session.ts
 var REACT_PROFILER_SESSION_NAMESPACE = "ReactProfilerSession";
 var reactProfilerSessionBlueprint = {
@@ -146674,6 +146732,7 @@ var reactProfilerSessionBlueprint = {
       detectedArchitecture: null,
       sessionPaths: null,
       profilingActive: false,
+      stopping: false,
       scriptSources: /* @__PURE__ */ new Map(),
       anyCompilerOptimized: null,
       hotCommitIndices: null,
@@ -146744,13 +146803,16 @@ var reactProfilerSessionBlueprint = {
       );
     };
     cdp.events.on("disconnected", onDisconnected);
+    let runtimeReloaded = false;
     const onCdpEvent = (method) => {
       if (method !== "Runtime.executionContextDestroyed" && method !== "Runtime.executionContextsCleared") {
         return;
       }
-      if (state3.profilingActive) {
+      runtimeReloaded = true;
+      if (state3.profilingActive || state3.stopping) {
         state3.profilingActive = false;
         clearCachedProfilerPaths(state3.port, state3.deviceId);
+        recordLostProfilerRun(state3, "js_reload");
         stopSamplerInNextRuntime(cdp);
       }
       events.emit("terminated");
@@ -146763,13 +146825,23 @@ var reactProfilerSessionBlueprint = {
         cdp.events.off("scriptParsed", onScriptParsed);
         cdp.events.off("disconnected", onDisconnected);
         cdp.events.off("event", onCdpEvent);
-        if (state3.profilingActive) {
+        if (!runtimeReloaded && (state3.profilingActive || state3.sessionId !== null)) {
           state3.profilingActive = false;
-          await cdp.send("Runtime.evaluate", {
-            expression: STOP_FOR_TAKEOVER_SCRIPT,
-            returnByValue: true
-          }).catch(warnOnError("STOP_FOR_TAKEOVER_SCRIPT"));
-          await cdp.send("Profiler.stop").catch(ignore);
+          const takeover = cdp.isConnected() ? await readTakeover(cdp, state3) : void 0;
+          if (takeover) {
+            recordLostProfilerRun(state3, "taken_over", takeover.by);
+            if (takeover.by === null) await cdp.send("Profiler.stop").catch(ignore);
+          } else {
+            recordLostProfilerRun(
+              state3,
+              cdp.isConnected() ? "session_torn_down" : "cdp_disconnected"
+            );
+            await cdp.send("Runtime.evaluate", {
+              expression: STOP_FOR_TAKEOVER_SCRIPT,
+              returnByValue: true
+            }).catch(warnOnError("STOP_FOR_TAKEOVER_SCRIPT"));
+            await cdp.send("Profiler.stop").catch(ignore);
+          }
         }
         await cdp.send("Profiler.disable").catch(ignore);
       },
@@ -146815,6 +146887,36 @@ function clearCachedProfilerPaths(port, deviceId) {
     profilerPathsCache.delete(cacheKey(port, id));
   }
 }
+var lostRuns = /* @__PURE__ */ new Map();
+function findLostRun(port, deviceId) {
+  for (const id of deviceIdsOf(deviceId)) {
+    const entry = lostRuns.get(cacheKey(port, id));
+    if (entry) return entry;
+  }
+  return void 0;
+}
+function recordLostProfilerRun(run2, cause, takenOverBy) {
+  const prior = findLostRun(run2.port, run2.deviceId)?.run;
+  if (prior && prior.sessionId !== null && prior.sessionId === run2.sessionId) return;
+  clearLostProfilerRun(run2.port, run2.deviceId);
+  const entry = {
+    run: {
+      cause,
+      sessionId: run2.sessionId,
+      startedAtEpochMs: run2.profileStartWallMs,
+      lostAtEpochMs: Date.now(),
+      ...takenOverBy !== void 0 ? { takenOverBy } : {}
+    },
+    keys: deviceIdsOf(run2.deviceId).map((id) => cacheKey(run2.port, id))
+  };
+  for (const key2 of entry.keys) lostRuns.set(key2, entry);
+}
+function getLostProfilerRun(port, deviceId) {
+  return findLostRun(port, deviceId)?.run;
+}
+function clearLostProfilerRun(port, deviceId) {
+  for (const key2 of findLostRun(port, deviceId)?.keys ?? []) lostRuns.delete(key2);
+}
 
 // ../tool-server/src/tools/devices/boot-device.ts
 var import_node_child_process32 = require("node:child_process");
@@ -157339,10 +157441,11 @@ var VEGA_CONTENT_ROLES = /* @__PURE__ */ new Set([...CONTENT_ROLES, "button", "t
 function clampFinite(n) {
   return Number.isFinite(n) ? n : 0;
 }
+function fmtCoord(n) {
+  return clampFinite(n).toFixed(3);
+}
 function fmtFrame(f) {
-  return `(${clampFinite(f.x).toFixed(3)}, ${clampFinite(f.y).toFixed(3)}, ${clampFinite(
-    f.width
-  ).toFixed(3)}, ${clampFinite(f.height).toFixed(3)})`;
+  return `(${fmtCoord(f.x)},${fmtCoord(f.y)},${fmtCoord(f.width)},${fmtCoord(f.height)})`;
 }
 function escapeForLine(s) {
   return s.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
@@ -158757,30 +158860,6 @@ var crypto6 = __toESM(require("node:crypto"));
 init_zod();
 init_src2();
 
-// ../tool-server/src/utils/react-profiler/session-ownership.ts
-var DEFAULT_STALE_THRESHOLD_MS = 5 * 6e4;
-function classifyStaleness({
-  owner,
-  nowEpochMs,
-  staleThresholdMs = DEFAULT_STALE_THRESHOLD_MS
-}) {
-  if (!owner) {
-    return {
-      stale: false,
-      ageSeconds: null,
-      canReclaimWithoutForce: true
-    };
-  }
-  const ageMs = nowEpochMs - owner.startedAtEpochMs;
-  const heartbeatAgeMs = nowEpochMs - owner.lastHeartbeatEpochMs;
-  const stale = heartbeatAgeMs > staleThresholdMs;
-  return {
-    stale,
-    ageSeconds: Math.max(0, ageMs) / 1e3,
-    canReclaimWithoutForce: stale
-  };
-}
-
 // ../tool-server/src/utils/debugger/runtime-device.ts
 var import_node_crypto13 = require("node:crypto");
 var import_node_child_process43 = require("node:child_process");
@@ -158919,6 +158998,46 @@ function logicalDeviceWarning(deviceId, runtimeApp) {
 var NO_DEVTOOLS_HOOK_ERROR = "React DevTools hook (__REACT_DEVTOOLS_GLOBAL_HOOK__) is not present in this app's JavaScript runtime. React profiling requires a development build with React DevTools enabled. Likely causes: (1) the app is a release/production build \u2014 DevTools is stripped to reduce bundle size; (2) you connected to the wrong JS runtime; (3) this isn't a React (Native) app. Fix: rebuild in debug/dev mode (e.g. `npx react-native run-ios` without --configuration Release; for Expo, run a dev client). Once the app is running with DevTools attached, call react-profiler-start again.";
 var NO_RENDERERS_ATTACHED_ERROR = "React DevTools hook is present but no React renderer has registered yet. The hook is loaded but no fiber renderer has attached \u2014 typically because the app has not committed its first render, or the DevTools backend has not been bootstrapped on a bridgeless React Native dev build. Fix: ensure the app has rendered (interact with it once, then retry); if it stays empty, call react-profiler-start first \u2014 it will attempt to attach the DevTools backend automatically.";
 var UNKNOWN_DEVICE_NOTE = "Two or more devices share this Metro, and Argent could not tell which of them runs this app. So taps and swipes on that device still return a screenshot and an element tree, and the capture loads the app while the profiler records. To avoid this, run the app on its own Metro port.";
+function stopInProgress() {
+  return { already_running: true, mine: true, note: STOP_IN_PROGRESS_NOTE };
+}
+function describeTakeover(input2) {
+  const { owner, mine, ownRunWasActive, stale, heartbeatAgeSeconds } = input2;
+  if (!owner) {
+    return {
+      session_id: null,
+      reason: "unattributed",
+      note: "Stopped a running profiling session that had no owner record (likely a DevTools client outside argent) and started this one."
+    };
+  }
+  const id = owner.sessionId;
+  if (mine) {
+    return ownRunWasActive ? {
+      session_id: id,
+      reason: "forced",
+      note: `Discarded this tool-server's own running recording (session ${id}) because force: true was passed.`
+    } : {
+      session_id: id,
+      reason: "own_unsaved",
+      note: `Stopped this tool-server's earlier run (session ${id}), which the app kept recording after it was lost; it was not saved.`
+    };
+  }
+  return stale ? {
+    session_id: id,
+    reason: "stale",
+    heartbeat_age_seconds: heartbeatAgeSeconds,
+    note: `Took over session ${id} without force: its last heartbeat was ${heartbeatAgeSeconds} s ago (stale after ${DEFAULT_STALE_THRESHOLD_MS / 1e3} s), so its owner was presumed gone. Its recorded data was discarded.`
+  } : {
+    session_id: id,
+    reason: "forced",
+    heartbeat_age_seconds: heartbeatAgeSeconds,
+    note: `Took over session ${id} because force: true was passed. Its recorded data was discarded.`
+  };
+}
+function failedTakeoverText({ session_id, reason: reason2 }) {
+  const run2 = session_id ? `session ${session_id}` : "a recording with no owner record";
+  return `Before it failed, this start stopped ${run2} (reason: ${reason2}), and nothing is recording now.`;
+}
 function safeGetState(registry2, urn) {
   try {
     return registry2.getServiceState(urn);
@@ -158943,7 +159062,7 @@ function createReactProfilerStartTool(registry2) {
 Use when you need to profile a user interaction.
 On an iOS simulator or Android device, also call native-profiler-start in the same message with the same device_id, unless the user has said no to native profiling. profiler-combined-report then correlates the two.
 After starting, ask the user to perform the interaction to profile, then call react-profiler-stop.
-Returns { started_at, startedAtEpochMs, hermes_version, detected_architecture }. On Android, a warning names the apps with native network capture on (started by native-network-logs): their timings in the profile can differ. If another tool-server already owns the session, returns { already_running: true, owner, stale, how_to_reclaim } instead, without clobbering their data. BEFORE OVERTAKING with { force: true }, ask the user for approval first, as how_to_reclaim explains.
+Returns { started_at, startedAtEpochMs, hermes_version, detected_architecture }. On Android, a warning names the apps with native network capture on (started by native-network-logs): their timings in the profile can differ. If a session is already running, returns { already_running: true, mine, owner, \u2026 } instead, without clobbering its data, unless it is another tool-server's stale run, has no owner record, or is a lost run of this tool-server: start replaces those. mine: true means this tool-server started the run: if it is yours, call react-profiler-stop. With stale: true it may be another agent's: follow the note. Otherwise, BEFORE OVERTAKING with { force: true }, ask the user for approval first, as how_to_reclaim explains. A start that replaces a run reports it in took_over.
 Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot be established.`,
     zodSchema: zodSchema45,
     interaction: {
@@ -158984,6 +159103,7 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
         await disposeAndWait();
       }
       let api = await registry2.resolveService(psUrn);
+      if (api.stopping) return stopInProgress();
       if (!api.cdp.isConnected()) {
         await disposeAndWait();
         api = await registry2.resolveService(psUrn);
@@ -159070,6 +159190,13 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
           );
         }
       }
+      let tookOver;
+      const withTakeover = (message) => tookOver ? `${message} ${failedTakeoverText(tookOver)}` : message;
+      const rethrowWithTakeover = (err) => {
+        if (err instanceof Error) err.message = withTakeover(err.message);
+        throw err;
+      };
+      if (api.stopping) return stopInProgress();
       if (state3.isRunning) {
         const owner = state3.owner;
         const staleness = classifyStaleness({
@@ -159077,10 +159204,24 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
           nowEpochMs: state3.nowEpochMs,
           staleThresholdMs: DEFAULT_STALE_THRESHOLD_MS
         });
-        const canTakeOverSilently = staleness.canReclaimWithoutForce || params.force === true;
+        const lostRun = getLostProfilerRun(api.port, api.deviceId);
+        const mine = owner !== null && (api.sessionId !== null && owner.sessionId === api.sessionId || lostRun !== void 0 && lostRun.sessionId !== null && owner.sessionId === lostRun.sessionId);
+        if (mine && api.profilingActive && params.force !== true) {
+          return {
+            already_running: true,
+            mine: true,
+            owner,
+            age_seconds: staleness.ageSeconds,
+            stale: staleness.stale,
+            heartbeat_age_seconds: staleness.heartbeatAgeSeconds,
+            note: staleness.stale ? STALE_OWN_RUN_NOTE : "A recording started through this tool-server is still running: yours, unless another agent shares this tool-server. Call react-profiler-stop to collect it. To discard it and start over, call react-profiler-start again with { force: true }."
+          };
+        }
+        const canTakeOverSilently = mine || staleness.canReclaimWithoutForce || params.force === true;
         if (!canTakeOverSilently) {
           return {
             already_running: true,
+            mine: false,
             owner,
             age_seconds: staleness.ageSeconds,
             stale: staleness.stale,
@@ -159088,11 +159229,16 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
           };
         }
         await cdp.evaluate(STOP_FOR_TAKEOVER_SCRIPT).catch(ignore);
+        tookOver = describeTakeover({
+          owner,
+          mine,
+          ownRunWasActive: mine && api.profilingActive,
+          stale: staleness.stale,
+          heartbeatAgeSeconds: staleness.heartbeatAgeSeconds
+        });
       }
-      if (api.profilingActive) {
-        await cdp.send("Profiler.stop").catch(ignore);
-        api.profilingActive = false;
-      }
+      await cdp.send("Profiler.stop").catch(ignore);
+      api.profilingActive = false;
       const runtimeDevice = isLogicalKeyedDevice(api.deviceId) ? await findRuntimeDevice(cdp) : void 0;
       const sessionId = crypto6.randomUUID();
       const ownerPayload = {
@@ -159103,21 +159249,30 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
         lastHeartbeatEpochMs: 0
       };
       await cdp.send("Profiler.enable").catch(ignore);
-      await cdp.send("Profiler.start", { interval: params.sample_interval_us });
-      const startJson = await cdp.evaluate(buildStartScript(JSON.stringify(ownerPayload)));
+      await cdp.send("Profiler.start", { interval: params.sample_interval_us }).catch(rethrowWithTakeover);
+      const startJson = await cdp.evaluate(buildStartScript(JSON.stringify(ownerPayload))).catch(async (err) => {
+        await cdp.send("Profiler.stop").catch(ignore);
+        return rethrowWithTakeover(err);
+      });
       if (!startJson) {
-        throw new FailureError("Failed to start React profiler (no value returned from runtime).", {
-          error_code: FAILURE_CODES.REACT_PROFILER_NO_RUNTIME_DATA,
-          failure_stage: "react_profiler_start_runtime_start",
-          failure_area: "tool_server",
-          error_kind: "subprocess"
-        });
+        await cdp.send("Profiler.stop").catch(ignore);
+        throw new FailureError(
+          withTakeover("Failed to start React profiler (no value returned from runtime)."),
+          {
+            error_code: FAILURE_CODES.REACT_PROFILER_NO_RUNTIME_DATA,
+            failure_stage: "react_profiler_start_runtime_start",
+            failure_area: "tool_server",
+            error_kind: "subprocess"
+          }
+        );
       }
       const startResult = JSON.parse(startJson);
       if (!startResult.ok) {
         await cdp.send("Profiler.stop").catch(ignore);
         throw new FailureError(
-          `React profiler failed to start (${startResult.reason ?? "unknown"}${startResult.message ? `: ${startResult.message}` : ""})`,
+          withTakeover(
+            `React profiler failed to start (${startResult.reason ?? "unknown"}${startResult.message ? `: ${startResult.message}` : ""})`
+          ),
           {
             error_code: FAILURE_CODES.REACT_PROFILER_START_FAILED,
             failure_stage: "react_profiler_start_runtime_start",
@@ -159129,7 +159284,9 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
       if (startResult.isProfilingFlagSet !== true || startResult.ownerInstalled !== true) {
         await cdp.send("Profiler.stop").catch(ignore);
         throw new FailureError(
-          `React profiler failed to start (post-start verification failed: isProfilingFlagSet=${startResult.isProfilingFlagSet === true}, ownerInstalled=${startResult.ownerInstalled === true})`,
+          withTakeover(
+            `React profiler failed to start (post-start verification failed: isProfilingFlagSet=${startResult.isProfilingFlagSet === true}, ownerInstalled=${startResult.ownerInstalled === true})`
+          ),
           {
             error_code: FAILURE_CODES.REACT_PROFILER_START_VERIFY_FAILED,
             failure_stage: "react_profiler_start_verify",
@@ -159142,7 +159299,9 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
         await cdp.evaluate(STOP_FOR_TAKEOVER_SCRIPT).catch(ignore);
         await cdp.send("Profiler.stop").catch(ignore);
         throw new FailureError(
-          `The React profiler session for ${api.deviceId} was torn down while the profiler was starting, so nothing is recorded. One tool-server serves every agent using this argent install, so another agent may have run stop-all-simulator-servers. Call react-profiler-start again.`,
+          withTakeover(
+            `The React profiler session for ${api.deviceId} was torn down while the profiler was starting, so nothing is recorded. One tool-server serves every agent using this argent install, so another agent may have run stop-all-simulator-servers. Call react-profiler-start again.`
+          ),
           {
             error_code: FAILURE_CODES.REACT_PROFILER_SESSION_TORN_DOWN,
             failure_stage: "react_profiler_start_session_torn_down",
@@ -159153,6 +159312,7 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
       }
       const startedAtEpochMs = startResult.startedAtEpochMs ?? Date.now();
       clearCachedProfilerPaths(api.port, api.deviceId);
+      clearLostProfilerRun(api.port, api.deviceId);
       api.sessionPaths = null;
       api.profilingActive = true;
       api.anyCompilerOptimized = null;
@@ -159169,6 +159329,7 @@ Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot
         startedAtEpochMs,
         hermes_version: api.hermesVersion,
         detected_architecture: api.detectedArchitecture,
+        ...tookOver ? { took_over: tookOver } : {},
         ...warning ? { warning } : {},
         ...isLogicalKeyedDevice(api.deviceId) && !runtimeDevice ? { [RESULT_NOTE_KEY]: UNKNOWN_DEVICE_NOTE } : {}
       };
@@ -159239,6 +159400,55 @@ async function readCommitTree(path59) {
   return JSON.parse(json2);
 }
 
+// ../tool-server/src/utils/react-profiler/last-run.ts
+function savedSessionInfo(paths) {
+  return {
+    session_id: paths.sessionId,
+    commits_path: paths.commitsPath,
+    cpu_profile_path: paths.cpuProfilePath,
+    ...paths.loadedFromDisk ? { loaded_from_disk: true } : {}
+  };
+}
+function lostRunInfo(run2) {
+  return {
+    session_id: run2.sessionId,
+    cause: run2.cause,
+    lost_at: new Date(run2.lostAtEpochMs).toISOString(),
+    ...run2.takenOverBy !== void 0 ? { taken_over_by: run2.takenOverBy } : {}
+  };
+}
+function lostRunCauseText(cause, takenOverBy) {
+  switch (cause) {
+    case "js_reload":
+      return "a JS reload (Metro's `r`, a red-box Reload, debugger-reload-metro) ended it";
+    case "cdp_disconnected":
+      return "the debugger connection dropped while it was recording: the app crashed or was killed, Metro restarted, or another debugger took the connection";
+    case "session_torn_down":
+      return "its session was torn down mid-run, typically by stop-all-simulator-servers: the run rides on the device's JS-runtime debugger, which that teardown reaps, and one tool-server serves every agent using this argent install";
+    case "taken_over":
+      return takenOverBy ? `session ${takenOverBy} took it over, which discarded its data` : "another session took it over, which discarded its data";
+    case "stop_failed":
+      return "a react-profiler-stop, or a react-profiler-start that replaced it, failed partway (see the error it returned)";
+    case "ended_in_app":
+      return "it stopped recording in the app without a react-profiler-stop, most likely from outside argent";
+  }
+}
+function savedSessionText(paths) {
+  if (paths.loadedFromDisk) {
+    return `Session ${paths.sessionId} is loaded from disk: react-profiler-analyze and the profiler query tools read it.`;
+  }
+  return `Your last run was stopped and saved as session ${paths.sessionId}: react-profiler-analyze and the profiler query tools read it. After a tool-server restart, load it again with profiler-load { mode: "load_react", session_id: "${paths.sessionId}", device_id: <this run's device_id> }. Pass port too if this run passed one.`;
+}
+function lostRunText(lost) {
+  const which = lost.sessionId ? `Your last run (session ${lost.sessionId})` : "Your last run";
+  return `${which} was not saved: ${lostRunCauseText(lost.cause, lost.takenOverBy)}.`;
+}
+function lastRunText(saved, lost) {
+  if (lost) return lostRunText(lost);
+  if (saved) return savedSessionText(saved);
+  return null;
+}
+
 // ../tool-server/src/tools/profiler/react/react-profiler-stop.ts
 function normalizeChangeDescription(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -159308,6 +159518,15 @@ function flattenProfilingData(merged, displayNameById, fiberMeta) {
   }
   return { commits, totalCommits: flatCommitIndex, unattributedByCommit };
 }
+var COLLECT_TIMEOUT_MS = 6e4;
+function stopInProgressError() {
+  return new FailureError(STOP_IN_PROGRESS_NOTE, {
+    error_code: FAILURE_CODES.REACT_PROFILER_STOP_IN_PROGRESS,
+    failure_stage: "react_profiler_stop_in_progress",
+    failure_area: "tool_server",
+    error_kind: "not_found"
+  });
+}
 var zodSchema46 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
@@ -159322,8 +159541,11 @@ Stores the results for react-profiler-analyze or react-profiler-cpu-summary.
 Call react-profiler-start first, then exercise the app, then call this.
 Returns { duration_ms, sample_count, fiber_renders_captured, total_react_commits, hot_commit_indices }.
 If some fibers' display names could not be resolved (typically modals, tooltips or animations that unmounted before stop), it also returns { unattributed_ms, unattributed_fiber_count, unattributed_commit_count }: the work missing from the per-component breakdown. Per-commit durations stay correct.
-Fails if no active profiling session exists or the CDP connection was lost during recording.`,
+Fails if no active profiling session exists, another stop is running, the CDP connection was lost during recording, or another session took the run over.`,
     zodSchema: zodSchema46,
+    // Collection can outlast the MCP client's 30 s abort. The client would then
+    // resend the call, and the resend fails on the stop still collecting.
+    longRunning: true,
     interaction: {
       startedMsg: () => "Stopping React profiler",
       completedMsg: () => "Stopped React profiler",
@@ -159332,12 +159554,18 @@ Fails if no active profiling session exists or the CDP connection was lost durin
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
-      const psUrn = `${REACT_PROFILER_SESSION_NAMESPACE}:${metroPort(params)}:${canonicalDeviceId(params.device_id)}`;
+      const port = metroPort(params);
+      const deviceId = canonicalDeviceId(params.device_id) ?? params.device_id;
+      const psUrn = `${REACT_PROFILER_SESSION_NAMESPACE}:${port}:${deviceId}`;
       const snapshot = registry2.getSnapshot();
       const entry = snapshot.services.get(psUrn);
+      const lastRun = lastRunText(
+        getCachedProfilerPaths(port, deviceId),
+        getLostProfilerRun(port, deviceId)
+      );
       if (!entry || entry.state !== "RUNNING" /* RUNNING */) {
         throw new FailureError(
-          "No active profiling session. The session may have been lost to a Metro reload, or torn down by a stop-all-simulator-servers \u2014 this session rides on the device's JS-runtime debugger, which that teardown reaps, and one tool-server serves every agent using this argent install. Call react-profiler-start to begin a new session.",
+          lastRun ? `No active profiling session. ${lastRun} Call react-profiler-start to begin a new session.` : "No active profiling session. The session may have been lost to a Metro reload, or torn down by a stop-all-simulator-servers \u2014 this session rides on the device's JS-runtime debugger, which that teardown reaps, and one tool-server serves every agent using this argent install. Call react-profiler-start to begin a new session.",
           {
             error_code: FAILURE_CODES.REACT_PROFILER_NO_ACTIVE_SESSION,
             failure_stage: "react_profiler_stop_session_lookup",
@@ -159348,6 +159576,7 @@ Fails if no active profiling session exists or the CDP connection was lost durin
       }
       const api = await registry2.resolveService(psUrn);
       const cdp = api.cdp;
+      if (api.stopping) throw stopInProgressError();
       if (!api.cdp.isConnected()) {
         api.profilingActive = false;
         throw new FailureError(
@@ -159361,6 +159590,17 @@ Fails if no active profiling session exists or the CDP connection was lost durin
         );
       }
       if (!api.profilingActive) {
+        if (lastRun) {
+          throw new FailureError(
+            `No active profiling run to stop. ${lastRun} Call react-profiler-start to record a new one.`,
+            {
+              error_code: FAILURE_CODES.REACT_PROFILER_NO_ACTIVE_SESSION,
+              failure_stage: "react_profiler_stop_inactive",
+              failure_area: "tool_server",
+              error_kind: "not_found"
+            }
+          );
+        }
         throw new FailureError(
           "No active profiling run to stop. Either the run ended without its data (a JS reload ends it: Metro's `r`, a red-box Reload, debugger-reload-metro), or Hermes CPU sampling was never started \u2014 typically because react-profiler-start failed before reaching the sampler (often on release builds without React DevTools). After a reload, call react-profiler-start again. Otherwise check the error react-profiler-start returned, address the underlying cause (rebuild in dev mode, reconnect the debugger, etc.), then call react-profiler-start again.",
           {
@@ -159373,180 +159613,210 @@ Fails if no active profiling session exists or the CDP connection was lost durin
           }
         );
       }
-      api.profilingActive = false;
-      const cpuResult = await cdp.send("Profiler.stop");
-      if (!cpuResult?.profile) {
+      const takeover = await readTakeover(cdp, api);
+      if (takeover) {
+        recordLostProfilerRun(api, "taken_over", takeover.by);
+        if (takeover.by === null) await cdp.send("Profiler.stop").catch(() => {
+        });
+        api.profilingActive = false;
+        api.sessionId = null;
+        api.ownerToolServerPid = null;
+        const howTakeoversHappen = "A takeover happens when another agent or tool-server calls react-profiler-start with force, or once a run's heartbeat is 5 minutes old.";
+        const replacedBy = takeover.by ? `session ${takeover.by}` : "a recording with no owner record (a DevTools client outside argent)";
         throw new FailureError(
-          "Hermes Profiler.stop returned no profile data. The CPU sampler may have been reset between start and stop (Metro reload, debugger disconnect). Call react-profiler-start to begin a fresh session.",
+          takeover.stillRecording ? `This profiling run was taken over by ${replacedBy}, which is still recording. Its data was discarded at the takeover, so there is nothing to collect, and the other recording was left running. ${howTakeoversHappen} Ask the user before taking over with react-profiler-start { force: true }.` : `This profiling run was taken over by another session, which has since stopped. Its data was discarded at the takeover, so there is nothing to collect. ${howTakeoversHappen} Nothing is recording now: call react-profiler-start to record again.`,
           {
-            error_code: FAILURE_CODES.REACT_PROFILER_NO_CPU_PROFILE,
-            failure_stage: "react_profiler_stop_cpu_profile",
+            error_code: FAILURE_CODES.REACT_PROFILER_SESSION_TAKEN_OVER,
+            failure_stage: "react_profiler_stop_taken_over",
             failure_area: "tool_server",
-            error_kind: "unknown"
+            error_kind: "not_found"
           }
         );
       }
-      const profile = cpuResult.profile;
-      if (!Array.isArray(profile.samples) || !Array.isArray(profile.nodes) || !Array.isArray(profile.timeDeltas)) {
-        throw new FailureError(
-          "Hermes Profiler.stop returned a malformed profile (missing samples/nodes/timeDeltas). This usually means CPU sampling was never actually started for this session \u2014 most often a release build without React DevTools, or a Metro reload between start and stop. Call react-profiler-start on a dev build and retry.",
-          {
-            error_code: FAILURE_CODES.REACT_PROFILER_NO_CPU_PROFILE,
-            failure_stage: "react_profiler_stop_malformed_profile",
+      if (api.stopping) throw stopInProgressError();
+      api.profilingActive = false;
+      api.stopping = true;
+      try {
+        const cpuResult = await cdp.send("Profiler.stop", void 0, COLLECT_TIMEOUT_MS);
+        if (!cpuResult?.profile) {
+          throw new FailureError(
+            "Hermes Profiler.stop returned no profile data. The CPU sampler may have been reset between start and stop (Metro reload, debugger disconnect). Call react-profiler-start to begin a fresh session.",
+            {
+              error_code: FAILURE_CODES.REACT_PROFILER_NO_CPU_PROFILE,
+              failure_stage: "react_profiler_stop_cpu_profile",
+              failure_area: "tool_server",
+              error_kind: "unknown"
+            }
+          );
+        }
+        const profile = cpuResult.profile;
+        if (!Array.isArray(profile.samples) || !Array.isArray(profile.nodes) || !Array.isArray(profile.timeDeltas)) {
+          throw new FailureError(
+            "Hermes Profiler.stop returned a malformed profile (missing samples/nodes/timeDeltas). This usually means CPU sampling was never actually started for this session \u2014 most often a release build without React DevTools, or a Metro reload between start and stop. Call react-profiler-start on a dev build and retry.",
+            {
+              error_code: FAILURE_CODES.REACT_PROFILER_NO_CPU_PROFILE,
+              failure_stage: "react_profiler_stop_malformed_profile",
+              failure_area: "tool_server",
+              error_kind: "unknown"
+            }
+          );
+        }
+        const stopReadStr = await cdp.send(
+          "Runtime.evaluate",
+          { expression: STOP_AND_READ_SCRIPT, returnByValue: true },
+          COLLECT_TIMEOUT_MS
+        );
+        if (stopReadStr.exceptionDetails) {
+          throw new FailureError(
+            `Runtime exception while reading profiling data: ${stopReadStr.exceptionDetails.text ?? "unknown"}`,
+            {
+              error_code: FAILURE_CODES.REACT_PROFILER_RUNTIME_EXCEPTION,
+              failure_stage: "react_profiler_stop_runtime_read",
+              failure_area: "tool_server",
+              error_kind: "unknown"
+            }
+          );
+        }
+        const stopReadRaw = stopReadStr.result?.value;
+        if (!stopReadRaw) {
+          throw new FailureError("No profiling data returned from runtime.", {
+            error_code: FAILURE_CODES.REACT_PROFILER_NO_RUNTIME_DATA,
+            failure_stage: "react_profiler_stop_runtime_read",
             failure_area: "tool_server",
             error_kind: "unknown"
+          });
+        }
+        const stopRead = JSON.parse(stopReadRaw);
+        const merged = stopRead.live ?? { dataForRoots: [] };
+        const backendCommitCount = merged.dataForRoots.reduce(
+          (a, r) => a + (r.commitData?.length ?? 0),
+          0
+        );
+        let fiberMeta = {};
+        if (backendCommitCount > 0) {
+          try {
+            const metaStr = await cdp.send(
+              "Runtime.evaluate",
+              { expression: RESOLVE_FIBER_META_SCRIPT, returnByValue: true },
+              15e3
+            );
+            if (metaStr.result?.value) {
+              fiberMeta = JSON.parse(metaStr.result.value);
+            }
+          } catch {
           }
+        }
+        const {
+          commits: allCommits,
+          totalCommits,
+          unattributedByCommit
+        } = flattenProfilingData(merged, stopRead.displayNameById, fiberMeta);
+        const commitHeat = /* @__PURE__ */ new Map();
+        let anyCompilerOptimized = false;
+        for (const c of allCommits) {
+          const prev = commitHeat.get(c.commitIndex) ?? 0;
+          if (c.commitDuration > prev) commitHeat.set(c.commitIndex, c.commitDuration);
+          if (c.isCompilerOptimized) anyCompilerOptimized = true;
+        }
+        const ABSOLUTE_FLOOR_MS = 16;
+        const interestingKeys = [...commitHeat.keys()].filter(
+          (k) => (commitHeat.get(k) ?? 0) >= ABSOLUTE_FLOOR_MS
         );
-      }
-      const stopReadStr = await cdp.send("Runtime.evaluate", {
-        expression: STOP_AND_READ_SCRIPT,
-        returnByValue: true,
-        timeout: 6e4
-      });
-      if (stopReadStr.exceptionDetails) {
-        throw new FailureError(
-          `Runtime exception while reading profiling data: ${stopReadStr.exceptionDetails.text ?? "unknown"}`,
+        const hotSet = new Set(interestingKeys);
+        const marginSet = /* @__PURE__ */ new Set();
+        for (const ci of interestingKeys) {
+          if (commitHeat.has(ci - 1) && !hotSet.has(ci - 1)) marginSet.add(ci - 1);
+          if (commitHeat.has(ci + 1) && !hotSet.has(ci + 1)) marginSet.add(ci + 1);
+        }
+        const keepSet = /* @__PURE__ */ new Set([...hotSet, ...marginSet]);
+        const filteredCommits = interestingKeys.length === 0 ? [] : allCommits.filter((c) => keepSet.has(c.commitIndex));
+        api.anyCompilerOptimized = anyCompilerOptimized;
+        api.totalReactCommits = totalCommits;
+        api.hotCommitIndices = interestingKeys;
+        const commitTree = { commits: filteredCommits, hookNames: /* @__PURE__ */ new Map() };
+        const sessionTs = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, (m) => m === "T" ? "-" : "").slice(0, 15);
+        const debugDir = await getDebugDir();
+        const cpuProfilePath = await writeDumpCompact(
+          debugDir,
+          `react-profiler-${sessionTs}_cpu.json`,
+          profile
+        );
+        const commitsPath = await writeDumpCompact(
+          debugDir,
+          `react-profiler-${sessionTs}_commits.json`,
           {
-            error_code: FAILURE_CODES.REACT_PROFILER_RUNTIME_EXCEPTION,
-            failure_stage: "react_profiler_stop_runtime_read",
-            failure_area: "tool_server",
-            error_kind: "unknown"
+            commits: commitTree.commits,
+            meta: {
+              detectedArchitecture: api.detectedArchitecture,
+              anyCompilerOptimized: api.anyCompilerOptimized,
+              hotCommitIndices: api.hotCommitIndices,
+              totalReactCommits: api.totalReactCommits,
+              profileStartWallMs: api.profileStartWallMs,
+              projectRoot: api.projectRoot,
+              deviceId: api.deviceId,
+              port: api.port,
+              appName: api.appName,
+              deviceName: api.deviceName,
+              unattributedByCommit: unattributedByCommit.length > 0 ? unattributedByCommit : null
+            }
           }
         );
-      }
-      const stopReadRaw = stopReadStr.result?.value;
-      if (!stopReadRaw) {
-        throw new FailureError("No profiling data returned from runtime.", {
-          error_code: FAILURE_CODES.REACT_PROFILER_NO_RUNTIME_DATA,
-          failure_stage: "react_profiler_stop_runtime_read",
-          failure_area: "tool_server",
-          error_kind: "unknown"
-        });
-      }
-      const stopRead = JSON.parse(stopReadRaw);
-      const merged = stopRead.live ?? { dataForRoots: [] };
-      const backendCommitCount = merged.dataForRoots.reduce(
-        (a, r) => a + (r.commitData?.length ?? 0),
-        0
-      );
-      let fiberMeta = {};
-      if (backendCommitCount > 0) {
-        try {
-          const metaStr = await cdp.send("Runtime.evaluate", {
-            expression: RESOLVE_FIBER_META_SCRIPT,
-            returnByValue: true,
-            timeout: 15e3
-          });
-          if (metaStr.result?.value) {
-            fiberMeta = JSON.parse(metaStr.result.value);
+        const sessionPaths = {
+          sessionId: sessionTs,
+          debugDir,
+          cpuProfilePath,
+          commitsPath,
+          cpuSampleIndexPath: null,
+          detectedArchitecture: api.detectedArchitecture,
+          anyCompilerOptimized: api.anyCompilerOptimized,
+          hotCommitIndices: api.hotCommitIndices,
+          totalReactCommits: api.totalReactCommits
+        };
+        cacheProfilerPaths(api.port, sessionPaths, api.deviceId);
+        clearLostProfilerRun(api.port, api.deviceId);
+        api.sessionPaths = sessionPaths;
+        api.sessionId = null;
+        api.ownerToolServerPid = null;
+        api.disposeSession();
+        const duration_ms = (profile.endTime - profile.startTime) / 1e3;
+        const response = {
+          duration_ms,
+          sample_count: profile.samples.length,
+          fiber_renders_captured: allCommits.length
+        };
+        if (totalCommits > 0) {
+          response["total_react_commits"] = totalCommits;
+          response["hot_commit_indices"] = api.hotCommitIndices ?? [];
+          response["any_compiler_optimized"] = api.anyCompilerOptimized ?? false;
+          response["fiber_renders_analyzed"] = filteredCommits.length;
+          const hotCount = api.hotCommitIndices?.length ?? 0;
+          if (hotCount === 0) {
+            response["selection_note"] = "All commits below 16ms \u2014 app appears smooth (all-clear)";
+          } else if (hotCount < totalCommits) {
+            response["selection_note"] = `${hotCount} of ${totalCommits} commits at \u226516ms absolute floor`;
+          }
+          if (unattributedByCommit.length > 0) {
+            let totalMs = 0;
+            let totalFibers = 0;
+            for (const [, count2, ms] of unattributedByCommit) {
+              totalFibers += count2;
+              totalMs += ms;
+            }
+            response["unattributed_ms"] = Math.round(totalMs * 100) / 100;
+            response["unattributed_fiber_count"] = totalFibers;
+            response["unattributed_commit_count"] = unattributedByCommit.length;
+            if (stopRead.displayNameApiAvailable === false) {
+              response["unattributed_reason"] = "react-devtools backend in this app does not expose a recognized display-name accessor (neither getDisplayNameForElementID nor getDisplayNameForFiberID). The component breakdown is unavailable for this profiling session; commit-level timing data remains correct.";
+            }
           }
-        } catch {
         }
+        return response;
+      } catch (err) {
+        recordLostProfilerRun(api, "stop_failed");
+        throw err;
+      } finally {
+        api.stopping = false;
       }
-      const {
-        commits: allCommits,
-        totalCommits,
-        unattributedByCommit
-      } = flattenProfilingData(merged, stopRead.displayNameById, fiberMeta);
-      const commitHeat = /* @__PURE__ */ new Map();
-      let anyCompilerOptimized = false;
-      for (const c of allCommits) {
-        const prev = commitHeat.get(c.commitIndex) ?? 0;
-        if (c.commitDuration > prev) commitHeat.set(c.commitIndex, c.commitDuration);
-        if (c.isCompilerOptimized) anyCompilerOptimized = true;
-      }
-      const ABSOLUTE_FLOOR_MS = 16;
-      const interestingKeys = [...commitHeat.keys()].filter(
-        (k) => (commitHeat.get(k) ?? 0) >= ABSOLUTE_FLOOR_MS
-      );
-      const hotSet = new Set(interestingKeys);
-      const marginSet = /* @__PURE__ */ new Set();
-      for (const ci of interestingKeys) {
-        if (commitHeat.has(ci - 1) && !hotSet.has(ci - 1)) marginSet.add(ci - 1);
-        if (commitHeat.has(ci + 1) && !hotSet.has(ci + 1)) marginSet.add(ci + 1);
-      }
-      const keepSet = /* @__PURE__ */ new Set([...hotSet, ...marginSet]);
-      const filteredCommits = interestingKeys.length === 0 ? [] : allCommits.filter((c) => keepSet.has(c.commitIndex));
-      api.anyCompilerOptimized = anyCompilerOptimized;
-      api.totalReactCommits = totalCommits;
-      api.hotCommitIndices = interestingKeys;
-      const commitTree = { commits: filteredCommits, hookNames: /* @__PURE__ */ new Map() };
-      const sessionTs = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, (m) => m === "T" ? "-" : "").slice(0, 15);
-      const debugDir = await getDebugDir();
-      const cpuProfilePath = await writeDumpCompact(
-        debugDir,
-        `react-profiler-${sessionTs}_cpu.json`,
-        profile
-      );
-      const commitsPath = await writeDumpCompact(
-        debugDir,
-        `react-profiler-${sessionTs}_commits.json`,
-        {
-          commits: commitTree.commits,
-          meta: {
-            detectedArchitecture: api.detectedArchitecture,
-            anyCompilerOptimized: api.anyCompilerOptimized,
-            hotCommitIndices: api.hotCommitIndices,
-            totalReactCommits: api.totalReactCommits,
-            profileStartWallMs: api.profileStartWallMs,
-            projectRoot: api.projectRoot,
-            deviceId: api.deviceId,
-            port: api.port,
-            appName: api.appName,
-            deviceName: api.deviceName,
-            unattributedByCommit: unattributedByCommit.length > 0 ? unattributedByCommit : null
-          }
-        }
-      );
-      const sessionPaths = {
-        sessionId: sessionTs,
-        debugDir,
-        cpuProfilePath,
-        commitsPath,
-        cpuSampleIndexPath: null,
-        detectedArchitecture: api.detectedArchitecture,
-        anyCompilerOptimized: api.anyCompilerOptimized,
-        hotCommitIndices: api.hotCommitIndices,
-        totalReactCommits: api.totalReactCommits
-      };
-      cacheProfilerPaths(api.port, sessionPaths, api.deviceId);
-      api.sessionPaths = sessionPaths;
-      api.sessionId = null;
-      api.ownerToolServerPid = null;
-      api.disposeSession();
-      const duration_ms = (profile.endTime - profile.startTime) / 1e3;
-      const response = {
-        duration_ms,
-        sample_count: profile.samples.length,
-        fiber_renders_captured: allCommits.length
-      };
-      if (totalCommits > 0) {
-        response["total_react_commits"] = totalCommits;
-        response["hot_commit_indices"] = api.hotCommitIndices ?? [];
-        response["any_compiler_optimized"] = api.anyCompilerOptimized ?? false;
-        response["fiber_renders_analyzed"] = filteredCommits.length;
-        const hotCount = api.hotCommitIndices?.length ?? 0;
-        if (hotCount === 0) {
-          response["selection_note"] = "All commits below 16ms \u2014 app appears smooth (all-clear)";
-        } else if (hotCount < totalCommits) {
-          response["selection_note"] = `${hotCount} of ${totalCommits} commits at \u226516ms absolute floor`;
-        }
-        if (unattributedByCommit.length > 0) {
-          let totalMs = 0;
-          let totalFibers = 0;
-          for (const [, count2, ms] of unattributedByCommit) {
-            totalFibers += count2;
-            totalMs += ms;
-          }
-          response["unattributed_ms"] = Math.round(totalMs * 100) / 100;
-          response["unattributed_fiber_count"] = totalFibers;
-          response["unattributed_commit_count"] = unattributedByCommit.length;
-          if (stopRead.displayNameApiAvailable === false) {
-            response["unattributed_reason"] = "react-devtools backend in this app does not expose a recognized display-name accessor (neither getDisplayNameForElementID nor getDisplayNameForFiberID). The component breakdown is unavailable for this profiling session; commit-level timing data remains correct.";
-          }
-        }
-      }
-      return response;
     }
   };
 }
@@ -159562,7 +159832,7 @@ var zodSchema47 = external_exports.object({
 function createReactProfilerStatusTool(registry2) {
   return {
     id: "react-profiler-status",
-    description: `Check the state of the React profiler session without side effects. Use when resuming after an interruption (debugger disconnect, unexpected error, agent pause) to decide whether to continue with react-profiler-stop, start a new session, or reconnect the debugger. Returns { session_status, is_running, current_owner, note, \u2026 }: session_status is active, stopped, taken_over (e.g. this tool-server restarted after react-profiler-start) or no_react_runtime, and note says what to do next.`,
+    description: `Check the state of the React profiler session. Use when resuming after an interruption (debugger disconnect, unexpected error, agent pause) to decide whether to continue with react-profiler-stop, start a new session, or reconnect the debugger. Returns { session_status, is_running, current_owner, note, \u2026 }: session_status is active, saved, lost, taken_over, not_started or no_react_runtime, and note says what to do next.`,
     zodSchema: zodSchema47,
     readOnly: true,
     interaction: {
@@ -159574,7 +159844,19 @@ function createReactProfilerStatusTool(registry2) {
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
-      const psUrn = `${REACT_PROFILER_SESSION_NAMESPACE}:${metroPort(params)}:${params.device_id}`;
+      const port = metroPort(params);
+      const deviceId = canonicalDeviceId(params.device_id) ?? params.device_id;
+      const psUrn = `${REACT_PROFILER_SESSION_NAMESPACE}:${port}:${deviceId}`;
+      const saved = getCachedProfilerPaths(port, deviceId);
+      const lost = getLostProfilerRun(port, deviceId);
+      const lastRun = {
+        ...saved ? { saved_session: savedSessionInfo(saved) } : {},
+        ...lost ? { lost_run: lostRunInfo(lost) } : {}
+      };
+      const withLastRun = (note) => {
+        const text = lastRunText(saved, lost);
+        return text ? `${note} ${text}` : note;
+      };
       const noRuntime = (note) => ({
         hook_exists: false,
         renderer_interface_found: false,
@@ -159582,7 +159864,8 @@ function createReactProfilerStatusTool(registry2) {
         current_session_id: null,
         current_owner: null,
         session_status: "no_react_runtime",
-        note
+        note: withLastRun(note),
+        ...lastRun
       });
       let api;
       try {
@@ -159592,6 +159875,16 @@ function createReactProfilerStatusTool(registry2) {
           "Unable to resolve a React profiler session \u2014 the Hermes runtime may not be reachable. Reconnect the debugger and retry."
         );
       }
+      const stopInProgress2 = () => ({
+        hook_exists: true,
+        renderer_interface_found: true,
+        is_running: true,
+        current_session_id: api.sessionId,
+        current_owner: null,
+        session_status: "active",
+        note: STOP_IN_PROGRESS_NOTE
+      });
+      if (api.stopping) return stopInProgress2();
       const cdp = api.cdp;
       if (!cdp.isConnected()) {
         return noRuntime(
@@ -159616,61 +159909,119 @@ function createReactProfilerStatusTool(registry2) {
         );
       }
       const state3 = JSON.parse(stateJson);
+      if (api.stopping) return stopInProgress2();
       if (!state3.hookExists) {
-        return {
-          hook_exists: false,
-          renderer_interface_found: false,
-          is_running: false,
-          current_session_id: null,
-          current_owner: null,
-          session_status: "no_react_runtime",
-          note: "React DevTools hook not attached \u2014 debugger may be disconnected or the app isn't a dev build."
-        };
+        return noRuntime(
+          "React DevTools hook not attached \u2014 debugger may be disconnected or the app isn't a dev build."
+        );
       }
       if (!("rendererInterfaceFound" in state3) || !state3.rendererInterfaceFound) {
         return {
-          hook_exists: true,
-          renderer_interface_found: false,
-          is_running: false,
-          current_session_id: null,
-          current_owner: null,
-          session_status: "no_react_runtime",
-          note: "No React renderer attached yet \u2014 the app hasn't rendered its first commit."
+          ...noRuntime(
+            "No React renderer attached yet \u2014 the app hasn't rendered its first commit."
+          ),
+          hook_exists: true
         };
       }
       const owner = state3.owner;
-      const currentSessionId = owner?.sessionId ?? null;
-      if (!state3.isRunning) {
+      const inApp = {
+        hook_exists: true,
+        renderer_interface_found: true,
+        is_running: state3.isRunning,
+        current_session_id: owner?.sessionId ?? null,
+        current_owner: owner
+      };
+      const ownRunId = api.sessionId;
+      const recordingHere = api.profilingActive && ownRunId !== null;
+      const lostResponse = (sessionId, cause, stillRecording) => ({
+        ...inApp,
+        session_status: "lost",
+        note: `Your run${sessionId ? ` (session ${sessionId})` : ""} was not saved: ${lostRunCauseText(cause)}. ` + (stillRecording ? "The app is still recording it, but react-profiler-stop can no longer collect it. Call react-profiler-start: it stops that recording and starts a new run, no force needed." : cause === "ended_in_app" ? "Call react-profiler-stop to collect it. A react-profiler-start would discard it." : "Call react-profiler-start to record again."),
+        ...lastRun,
+        lost_run: { session_id: sessionId, cause }
+      });
+      if (state3.isRunning) {
+        if (owner && ownRunId !== null && owner.sessionId === ownRunId) {
+          if (recordingHere) {
+            const { stale, heartbeatAgeSeconds } = classifyStaleness({
+              owner,
+              nowEpochMs: state3.nowEpochMs
+            });
+            await cdp.evaluate(buildHeartbeatScript(ownRunId)).catch(() => {
+            });
+            return {
+              ...inApp,
+              session_status: "active",
+              stale,
+              heartbeat_age_seconds: heartbeatAgeSeconds,
+              note: stale ? STALE_OWN_RUN_NOTE : "A profiling session started through this tool-server is still running: yours, unless another agent shares this tool-server. Call react-profiler-stop to collect the data, or continue profiling."
+            };
+          }
+          return lostResponse(ownRunId, "stop_failed", true);
+        }
+        if (owner && lost && lost.sessionId === owner.sessionId) {
+          return {
+            ...inApp,
+            session_status: "lost",
+            note: `Your run (session ${owner.sessionId}) was not saved: ${lostRunCauseText(lost.cause, lost.takenOverBy)}. The app is still recording it, but react-profiler-stop can no longer collect it. Call react-profiler-start: it stops that recording and starts a new run, no force needed.`,
+            ...lastRun
+          };
+        }
+        const yoursReplaced = recordingHere || lost?.cause === "taken_over";
+        const yourRunId = ownRunId ?? lost?.sessionId ?? null;
+        if (!owner) {
+          return {
+            ...inApp,
+            session_status: "taken_over",
+            note: withLastRun(
+              (yoursReplaced ? "Your run was replaced: a profiling session is running in the app, but its ownership is unattributable" : "A profiling session is running but its ownership is unattributable") + " \u2014 likely started by a foreign DevTools client without our setup script, or cleared in a narrow window. Treat as lost and restart."
+            ),
+            ...lastRun
+          };
+        }
         return {
-          hook_exists: true,
-          renderer_interface_found: true,
-          is_running: false,
-          current_session_id: currentSessionId,
-          current_owner: owner,
-          session_status: "stopped",
-          note: "No profiling session is currently running. If you expected to be profiling, the session ended \u2014 call react-profiler-start to begin a new one; prior data is not recoverable."
+          ...inApp,
+          session_status: "taken_over",
+          note: yoursReplaced ? `Your run${yourRunId ? ` (session ${yourRunId})` : ""} was taken over by session ${owner.sessionId}, which is still recording. Your data was discarded at the takeover. Do not stop their run; ask the user before taking over with react-profiler-start { force: true }.` : withLastRun(
+            `Another profiling session (${owner.sessionId}) is running: another tool-server instance took over, or this tool-server restarted after react-profiler-start. Data from a run it replaced is lost at the takeover moment. Use react-profiler-start { force: true } to reclaim, after asking the user if the run may be someone else's.`
+          ),
+          ...lastRun
         };
       }
-      if (!owner) {
+      if (recordingHere) {
+        if (takeoverOf(state3, api)) {
+          return {
+            ...inApp,
+            session_status: "taken_over",
+            note: `Your run (session ${ownRunId}) was not saved: ${lostRunCauseText("taken_over")}. That session has since stopped too. Nothing is recording now; call react-profiler-start to record again.`,
+            ...lastRun,
+            lost_run: { session_id: ownRunId, cause: "taken_over" }
+          };
+        }
+        return lostResponse(ownRunId, "ended_in_app", false);
+      }
+      if (ownRunId !== null) return lostResponse(ownRunId, "stop_failed", false);
+      if (lost) {
+        const takenOver = lost.cause === "taken_over";
         return {
-          hook_exists: true,
-          renderer_interface_found: true,
-          is_running: true,
-          current_session_id: null,
-          current_owner: null,
-          session_status: "taken_over",
-          note: "A profiling session is running but its ownership is unattributable \u2014 likely started by a foreign DevTools client without our setup script, or cleared in a narrow window. Treat as lost and restart."
+          ...inApp,
+          session_status: takenOver ? "taken_over" : "lost",
+          note: lostRunText(lost) + (takenOver ? " That session has since stopped too. " : " ") + "Nothing is recording now; call react-profiler-start to record again.",
+          ...lastRun
+        };
+      }
+      if (saved) {
+        return {
+          ...inApp,
+          session_status: "saved",
+          note: `No profiling session is running. ${savedSessionText(saved)} A new react-profiler-start replaces it.`,
+          ...lastRun
         };
       }
-      const isMine = api.sessionId !== null && owner.sessionId === api.sessionId;
       return {
-        hook_exists: true,
-        renderer_interface_found: true,
-        is_running: true,
-        current_session_id: owner.sessionId,
-        current_owner: owner,
-        session_status: isMine ? "active" : "taken_over",
-        note: isMine ? "Your profiling session is still running. Call react-profiler-stop to collect the data, or continue profiling." : "A different profiling session is running (another tool-server instance took over, this process restarted after start, or a stop-all-simulator-servers reaped this device's JS-runtime debugger and took this session down with it, leaving the in-app owner behind). Data from the prior session is lost at the takeover moment. Use react-profiler-start { force: true } to reclaim."
+        ...inApp,
+        session_status: "not_started",
+        note: "No profiling session is running, and this tool-server has no run on record for this device: none was started since it launched. Call react-profiler-start to begin one."
       };
     }
   };
@@ -159717,13 +160068,6 @@ async function detectSessionContext(input2) {
       reactCompilerEnabled = true;
     }
   }
-  let strictModeEnabled = false;
-  const indexJs = await readFileSafe((0, import_path3.join)(projectRoot, "index.js"));
-  const indexTs = await readFileSafe((0, import_path3.join)(projectRoot, "index.ts"));
-  const indexSource = (indexJs ?? "") + (indexTs ?? "");
-  if (indexSource.includes("<StrictMode>") || indexSource.includes("StrictMode")) {
-    strictModeEnabled = true;
-  }
   let buildMode = "dev";
   if (input2.flamegraph) {
     for (const node2 of input2.flamegraph.nodes) {
@@ -159763,7 +160107,6 @@ async function detectSessionContext(input2) {
   }
   return {
     reactCompilerEnabled,
-    strictModeEnabled,
     buildMode,
     rnArchitecture,
     projectRoot,
@@ -160314,14 +160657,12 @@ function bestRootCause(votes, hookTypeNames) {
 }
 function enrich(input2) {
   const { sessionContext } = input2;
-  const strictMode = sessionContext.strictModeEnabled;
   const components = /* @__PURE__ */ new Map();
   for (const [name, acc] of input2.components) {
     const n = acc.n;
     if (n === 0) continue;
     const mean = acc.sum / n;
-    const totalRenderMs = n * mean;
-    const normalizedRenderCount = strictMode ? Math.ceil(n / 2) : n;
+    const totalRenderMs = acc.sum;
     const dr = dominantReason(acc.reasonHistogram);
     const dp = dr === "parent" ? topParent(acc.parentFreq) : void 0;
     const isCompilerOptimized = acc.compilerOptimizedCount > n / 2;
@@ -160329,7 +160670,6 @@ function enrich(input2) {
     const enriched = {
       name,
       n,
-      normalizedRenderCount,
       mean,
       min: acc.min === Infinity ? 0 : acc.min,
       max: acc.max === -Infinity ? 0 : acc.max,
@@ -160397,7 +160737,7 @@ var ACTIONABLE_REASONS = /* @__PURE__ */ new Set([
 ]);
 var MAX_FINDINGS = 20;
 var PARETO_THRESHOLD_PCT = 5e-3;
-var MIN_NORMALIZED_RENDERS = 3;
+var MIN_RENDERS = 3;
 var MIN_MAX_DURATION_MS = 30;
 function rank(input2) {
   const { sessionContext, recordingMs } = input2;
@@ -160406,7 +160746,7 @@ function rank(input2) {
     if (comp.isAnimated) continue;
     if (comp.isRecyclerChild) continue;
     if (!ACTIONABLE_REASONS.has(comp.dominantReason)) continue;
-    const passesRenderCount = comp.normalizedRenderCount >= MIN_NORMALIZED_RENDERS;
+    const passesRenderCount = comp.n >= MIN_RENDERS;
     const passesMaxDuration = comp.max >= MIN_MAX_DURATION_MS;
     if (!passesRenderCount && !passesMaxDuration) continue;
     candidates.push({ name, comp });
@@ -160419,7 +160759,7 @@ function rank(input2) {
     const topChangedHookNames = comp.hookTypeNames !== void 0 ? comp.topChangedHooks.map((idx) => comp.hookTypeNames[idx] ?? `hook[${idx}]`) : [];
     const finding = {
       component: name,
-      renders: comp.normalizedRenderCount,
+      renders: comp.n,
       totalMs: Math.round(comp.totalRenderMs * 10) / 10,
       avgMs: Math.round(comp.mean * 100) / 100,
       maxMs: Math.round(comp.max * 100) / 100,
@@ -160428,7 +160768,7 @@ function rank(input2) {
       topChangedHookNames
     };
     if (comp.isCompilerOptimized) finding.isCompilerOptimized = true;
-    if (sessionContext.reactCompilerEnabled && !comp.isCompilerOptimized && comp.normalizedRenderCount > 5) {
+    if (sessionContext.reactCompilerEnabled && !comp.isCompilerOptimized && comp.n > 5) {
       finding.compilerBailoutSuspected = true;
     }
     if (comp.parentTrigger !== void 0) finding.parentTrigger = comp.parentTrigger;
@@ -161623,13 +161963,14 @@ Fails if the React DevTools hook is not present in the runtime or the app is not
   // RN-only: queries the React DevTools backend hook on the live runtime.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: (params) => ({
-    profilerSession: `${REACT_PROFILER_SESSION_NAMESPACE}:${metroPort(params)}:${params.device_id}`
+    // Same key as react-profiler-start, so a forwarded logicalDeviceId reads its run.
+    profilerSession: `${REACT_PROFILER_SESSION_NAMESPACE}:${metroPort(params)}:${canonicalDeviceId(params.device_id)}`
   }),
   async execute(services, params) {
     const api = services.profilerSession;
     const cdp = api.cdp;
-    if (api.profilingActive && api.ownerToolServerPid === process.pid) {
-      await cdp.evaluate(HEARTBEAT_SCRIPT).catch(() => {
+    if (api.profilingActive && api.sessionId && api.ownerToolServerPid === process.pid) {
+      await cdp.evaluate(buildHeartbeatScript(api.sessionId)).catch(() => {
       });
     }
     async function evalRenders() {
@@ -161800,13 +162141,14 @@ Fails if the React DevTools hook is not present or no fiber roots have been comm
   // RN-only: walks the fiber tree via the React DevTools backend hook.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: (params) => ({
-    profilerSession: `${REACT_PROFILER_SESSION_NAMESPACE}:${metroPort(params)}:${params.device_id}`
+    // Same key as react-profiler-start, so a forwarded logicalDeviceId reads its run.
+    profilerSession: `${REACT_PROFILER_SESSION_NAMESPACE}:${metroPort(params)}:${canonicalDeviceId(params.device_id)}`
   }),
   async execute(services, params) {
     const api = services.profilerSession;
     const cdp = api.cdp;
-    if (api.profilingActive && api.ownerToolServerPid === process.pid) {
-      await cdp.evaluate(HEARTBEAT_SCRIPT).catch(() => {
+    if (api.profilingActive && api.sessionId && api.ownerToolServerPid === process.pid) {
+      await cdp.evaluate(buildHeartbeatScript(api.sessionId)).catch(() => {
       });
     }
     const script = buildFiberTreeScript(params.max_depth, params.filter ?? "");
@@ -169040,7 +169382,8 @@ async function loadReactSession(debugDir, sessionId, port, deviceId) {
     detectedArchitecture,
     anyCompilerOptimized,
     hotCommitIndices,
-    totalReactCommits
+    totalReactCommits,
+    loadedFromDisk: true
   };
   cacheProfilerPaths(port, sessionPaths, deviceId);
   const lines = [