@swmansion/argent 0.20.1-next.8 → 0.20.1-next.9

package/dist/tool-server.cjs

@@ -133798,89 +133798,130 @@ var ARGENT_PROFILER_PREFIX = "__argent_";
 function isArgentProfilerFunction(name) {
   return name.startsWith(ARGENT_PROFILER_PREFIX);
 }
-function buildCpuSampleIndex(cpuProfile, firstCommitTimestampMs) {
+function buildCpuSampleIndex(cpuProfile) {
   const { nodes, samples, timeDeltas, startTime, endTime } = cpuProfile;
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
   }
-  const cpuStartMs = startTime / 1e3;
-  let clockOffsetMs = 0;
-  if (firstCommitTimestampMs !== null && firstCommitTimestampMs > 0) {
-    const diff = firstCommitTimestampMs - cpuStartMs;
-    if (Math.abs(diff) > 1e3) {
-      clockOffsetMs = diff;
-    }
-  }
   const timestampsMs = new Float64Array(samples.length);
-  let accumulatedUs = startTime;
+  const intervalStartsMs = new Float64Array(samples.length);
+  let accumulatedUs = 0;
   for (let i = 0; i < samples.length; i++) {
-    accumulatedUs += timeDeltas[i] ?? 0;
-    timestampsMs[i] = accumulatedUs / 1e3 + clockOffsetMs;
+    const raw = timeDeltas[i];
+    const delta = Number.isFinite(raw) && (raw ?? 0) >= 0 ? raw : 0;
+    intervalStartsMs[i] = accumulatedUs / 1e3;
+    accumulatedUs += delta;
+    timestampsMs[i] = accumulatedUs / 1e3;
   }
   return {
+    childToParent: buildChildToParent(nodeMap),
     timestampsMs,
+    intervalStartsMs,
     sampleNodeIds: samples,
     nodeMap,
     durationMs: (endTime - startTime) / 1e3
   };
 }
+var IDLE_FRAME_NAMES = /* @__PURE__ */ new Set(["(idle)", "(program)", "(root)", "[idle]", "[root]"]);
+function isIdleFrame(name) {
+  return !name || IDLE_FRAME_NAMES.has(name);
+}
 function queryCpuWindow(index, startMs, endMs, topN2 = 5) {
-  const { timestampsMs, sampleNodeIds, nodeMap } = index;
+  const { timestampsMs, intervalStartsMs, sampleNodeIds, nodeMap } = index;
+  const n = timestampsMs.length;
+  const sampleRangeMs = {
+    start: n > 0 ? intervalStartsMs[0] : 0,
+    end: n > 0 ? timestampsMs[n - 1] : 0
+  };
+  const empty2 = {
+    hotspots: [],
+    samplesInWindow: 0,
+    coveredMs: 0,
+    idleMs: 0,
+    sampleRangeMs,
+    medianIntervalMs: 0,
+    maxIntervalMs: 0
+  };
+  if (n === 0) return empty2;
   let lo = 0;
-  let hi = timestampsMs.length;
+  let hi = n;
   while (lo < hi) {
     const mid = lo + hi >>> 1;
     if (timestampsMs[mid] < startMs) lo = mid + 1;
     else hi = mid;
   }
-  const selfHits = /* @__PURE__ */ new Map();
-  let totalSamples = 0;
-  for (let i = lo; i < timestampsMs.length; i++) {
-    if (timestampsMs[i] > endMs) break;
+  const selfMsByNode = /* @__PURE__ */ new Map();
+  const intervals = [];
+  let samplesInWindow = 0;
+  let coveredMs = 0;
+  let idleMs = 0;
+  let maxIntervalMs = 0;
+  for (let i = lo; i < n; i++) {
+    const from2 = intervalStartsMs[i];
+    if (from2 > endMs) break;
+    const overlap = Math.min(endMs, timestampsMs[i]) - Math.max(startMs, from2);
+    if (overlap <= 0) continue;
+    samplesInWindow++;
+    coveredMs += overlap;
+    intervals.push(timestampsMs[i] - from2);
+    if (timestampsMs[i] - from2 > maxIntervalMs) maxIntervalMs = timestampsMs[i] - from2;
     const nodeId = sampleNodeIds[i];
-    selfHits.set(nodeId, (selfHits.get(nodeId) ?? 0) + 1);
-    totalSamples++;
-  }
-  if (totalSamples === 0) return [];
-  const windowDurationMs = endMs - startMs;
-  const avgIntervalMs = totalSamples > 1 ? windowDurationMs / totalSamples : 1;
-  const childToParent = /* @__PURE__ */ new Map();
-  for (const node of nodeMap.values()) {
-    for (const childId of node.children ?? []) {
-      childToParent.set(childId, node.id);
+    const node = nodeMap.get(nodeId);
+    if (isIdleFrame(node?.callFrame.functionName)) {
+      idleMs += overlap;
+      continue;
     }
+    selfMsByNode.set(nodeId, (selfMsByNode.get(nodeId) ?? 0) + overlap);
   }
-  const totalHits = /* @__PURE__ */ new Map();
-  for (const [nodeId, hits] of selfHits) {
-    totalHits.set(nodeId, (totalHits.get(nodeId) ?? 0) + hits);
+  if (samplesInWindow === 0) return { ...empty2, sampleRangeMs };
+  intervals.sort((a, b) => a - b);
+  const medianIntervalMs = intervals[Math.floor(intervals.length / 2)] ?? 0;
+  const childToParent = index.childToParent ?? buildChildToParent(nodeMap);
+  const totalMsByNode = /* @__PURE__ */ new Map();
+  for (const [nodeId, ms] of selfMsByNode) {
+    totalMsByNode.set(nodeId, (totalMsByNode.get(nodeId) ?? 0) + ms);
     let current = nodeId;
+    const seen = /* @__PURE__ */ new Set([current]);
     while (childToParent.has(current)) {
       const parent = childToParent.get(current);
-      totalHits.set(parent, (totalHits.get(parent) ?? 0) + hits);
+      if (seen.has(parent)) break;
+      seen.add(parent);
+      totalMsByNode.set(parent, (totalMsByNode.get(parent) ?? 0) + ms);
       current = parent;
     }
   }
   const entries = [];
-  for (const [nodeId, hits] of selfHits) {
+  for (const [nodeId, ms] of selfMsByNode) {
     const node = nodeMap.get(nodeId);
     if (!node) continue;
     const name = node.callFrame.functionName;
-    if (!name || name === "(idle)" || name === "(program)" || name === "(root)" || name === "[idle]" || name === "[root]")
-      continue;
     if (isArgentProfilerFunction(name)) continue;
-    const selfMs = Math.round(hits * avgIntervalMs * 100) / 100;
-    const totalMs = Math.round((totalHits.get(nodeId) ?? hits) * avgIntervalMs * 100) / 100;
     entries.push({
       name,
-      selfMs,
-      totalMs,
+      selfMs: Math.round(ms * 100) / 100,
+      totalMs: Math.round((totalMsByNode.get(nodeId) ?? ms) * 100) / 100,
       url: node.callFrame.url || void 0,
       lineNumber: node.callFrame.lineNumber >= 0 ? node.callFrame.lineNumber : void 0
     });
   }
   entries.sort((a, b) => b.selfMs - a.selfMs);
-  return entries.slice(0, topN2);
+  return {
+    hotspots: entries.slice(0, topN2),
+    samplesInWindow,
+    coveredMs,
+    idleMs,
+    sampleRangeMs,
+    medianIntervalMs,
+    maxIntervalMs
+  };
+}
+function buildChildToParent(nodeMap) {
+  const childToParent = /* @__PURE__ */ new Map();
+  for (const node of nodeMap.values()) {
+    for (const childId of node.children ?? []) childToParent.set(childId, node.id);
+  }
+  return childToParent;
 }
 function correlateCpuWithCommits(summaries, index, topNPerCommit = 5) {
   if (!index) return summaries;
@@ -133888,28 +133929,35 @@ function correlateCpuWithCommits(summaries, index, topNPerCommit = 5) {
     if (summary.isMargin) return summary;
     const startMs = summary.timestampMs;
     const endMs = summary.timestampMs + summary.totalRenderMs;
-    const hotspots = queryCpuWindow(index, startMs, endMs, topNPerCommit);
+    const { hotspots } = queryCpuWindow(index, startMs, endMs, topNPerCommit);
     if (hotspots.length === 0) return summary;
     return { ...summary, cpuHotspots: hotspots };
   });
 }
 function serializeCpuSampleIndex(index) {
   return {
+    version: 2,
     timestampsMs: Array.from(index.timestampsMs),
+    intervalStartsMs: Array.from(index.intervalStartsMs),
     sampleNodeIds: index.sampleNodeIds,
     nodes: [...index.nodeMap.values()],
     durationMs: index.durationMs
   };
 }
 function deserializeCpuSampleIndex(raw) {
+  if (raw?.version !== 2 || !Array.isArray(raw.timestampsMs) || !Array.isArray(raw.nodes)) {
+    throw new Error("unsupported CPU sample index format");
+  }
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of raw.nodes) {
     nodeMap.set(node.id, node);
   }
   return {
     timestampsMs: new Float64Array(raw.timestampsMs),
+    intervalStartsMs: new Float64Array(raw.intervalStartsMs ?? []),
     sampleNodeIds: raw.sampleNodeIds,
     nodeMap,
+    childToParent: buildChildToParent(nodeMap),
     durationMs: raw.durationMs
   };
 }
@@ -134212,8 +134260,7 @@ async function runPipeline(input, options) {
     hotCommitIndices,
     input.sessionMeta.unattributedByCommit
   );
-  const firstCommitTs = preprocessed.length > 0 ? preprocessed[0].timestamp : null;
-  const cpuSampleIndex = input.flamegraph ? buildCpuSampleIndex(input.flamegraph, firstCommitTs) : null;
+  const cpuSampleIndex = input.flamegraph ? buildCpuSampleIndex(input.flamegraph) : null;
   const hotCommitSummaries = correlateCpuWithCommits(rawHotCommitSummaries, cpuSampleIndex);
   const preprocessedCommitTree = { ...input.commitTree, commits: preprocessed };
   const reduceOutput = reduce(
@@ -140619,8 +140666,12 @@ init_zod();
 init_src();
 var import_fs18 = require("fs");
 var timeWindowSchema = external_exports.object({
-  start: external_exports.coerce.number().describe("Start of window in ms (performance.now clock)"),
-  end: external_exports.coerce.number().describe("End of window in ms (performance.now clock)")
+  start: external_exports.coerce.number().describe(
+    "Start of window in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+  ),
+  end: external_exports.coerce.number().describe(
+    "End of window in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+  )
 });
 var zodSchema53 = external_exports.object({
   port: external_exports.coerce.number().default(8081).describe("Metro server port"),
@@ -140630,7 +140681,9 @@ var zodSchema53 = external_exports.object({
   mode: external_exports.enum(["top_functions", "time_window", "call_tree", "component_cpu"]).describe(
     "Query mode: top_functions (global hotspots), time_window (CPU in a time range), call_tree (callers/callees of a function), component_cpu (CPU during a component's commits)"
   ),
-  time_window_ms: timeWindowSchema.optional().describe("Time window filter for time_window mode (ms, performance.now clock)"),
+  time_window_ms: timeWindowSchema.optional().describe(
+    "Time window filter for time_window mode (ms since profiling started \u2014 the same clock profiler-commit-query prints)"
+  ),
   component_name: external_exports.string().optional().describe("Component name for component_cpu mode"),
   function_name: external_exports.string().optional().describe("Function name for call_tree mode"),
   top_n: external_exports.coerce.number().int().positive().default(15).describe("Number of results to return (default 15)"),
@@ -140663,31 +140716,60 @@ async function getIndex(sessionPaths) {
   }
   const cpuProfile = await readCpuProfile(sessionPaths.cpuProfilePath);
   let commitTree = null;
-  let firstCommitTs = null;
   if (sessionPaths.commitsPath) {
     const onDisk = await readCommitTree(sessionPaths.commitsPath);
     commitTree = { commits: onDisk.commits };
-    firstCommitTs = onDisk.commits[0]?.timestamp ?? null;
   }
-  return { index: buildCpuSampleIndex(cpuProfile, firstCommitTs), commitTree };
+  return { index: buildCpuSampleIndex(cpuProfile), commitTree };
+}
+function explainEmptyWindow(res, startMs, endMs) {
+  const range = `${res.sampleRangeMs.start.toFixed(1)}\u2013${res.sampleRangeMs.end.toFixed(1)}ms`;
+  const window2 = `${startMs.toFixed(1)}\u2013${endMs.toFixed(1)}ms`;
+  if (res.sampleRangeMs.end === 0 && res.samplesInWindow === 0) {
+    return "_The CPU profile contains no samples. Sampling produced no data for this session \u2014 that is a capture failure, not a measurement of idleness._";
+  }
+  if (endMs < res.sampleRangeMs.start || startMs > res.sampleRangeMs.end) {
+    return `_No CPU samples exist in ${window2} \u2014 that is outside the recorded sample range (${range}). This is a coverage gap, not a measurement: nothing can be concluded about CPU cost here. Sample times are ms since profiling started, the same clock \`profiler-commit-query\` prints._`;
+  }
+  if (res.samplesInWindow > 0) {
+    return `_${res.samplesInWindow} sample(s) covering ${res.coveredMs.toFixed(1)}ms fell inside ${window2}, and all of them were idle \u2014 the JS thread was not executing during this window. Native or UI-thread work would not appear here; use \`native-profiler-start\` for that._`;
+  }
+  return `_No CPU samples fell inside ${window2} (${(endMs - startMs).toFixed(1)}ms wide), although it lies within the recorded range (${range}). The sampler runs roughly every ${res.medianIntervalMs > 0 ? res.medianIntervalMs.toFixed(1) : "13"}ms, so a window this narrow can contain none at all. **Absence of samples is not evidence that this commit was cheap.** Widen the window, or use \`mode=component_cpu\`._`;
+}
+function coverageNote(res, startMs, endMs) {
+  const widthMs = endMs - startMs;
+  const lines = [
+    `**Window:** ${startMs.toFixed(1)}ms \u2192 ${endMs.toFixed(1)}ms (${widthMs.toFixed(1)}ms)`,
+    `**Samples:** ${res.samplesInWindow} covering ${res.coveredMs.toFixed(1)}ms` + (res.idleMs > 0 ? `, of which ${res.idleMs.toFixed(1)}ms idle` : "") + ` \u2014 sampling interval ~${res.medianIntervalMs.toFixed(1)}ms. Self-times sum to sampled coverage, not to the window width.`
+  ];
+  if (widthMs > 0 && widthMs < 3 * res.medianIntervalMs) {
+    lines.push(
+      `> This window is narrower than ~3 sampling intervals, so every figure carries \xB11 sample (\u2248${res.medianIntervalMs.toFixed(1)}ms).`
+    );
+  }
+  if (res.maxIntervalMs > 50 && res.maxIntervalMs > 5 * res.medianIntervalMs) {
+    lines.push(
+      `> The sampler stalled for ${res.maxIntervalMs.toFixed(1)}ms inside this window; that whole gap is attributed to whichever function was caught by the sample that ended it.`
+    );
+  }
+  return lines.join("\n\n");
 }
 function renderTopFunctions(index, topN2, startMs, endMs) {
-  const windowStart = startMs ?? index.timestampsMs[0];
-  const windowEnd = endMs ?? index.timestampsMs[index.timestampsMs.length - 1];
-  const hotspots = queryCpuWindow(index, windowStart, windowEnd, topN2);
-  if (hotspots.length === 0) return "_No CPU hotspots found in the specified range._";
+  const windowStart = startMs ?? index.intervalStartsMs[0] ?? 0;
+  const windowEnd = endMs ?? index.timestampsMs[index.timestampsMs.length - 1] ?? 0;
+  const res = queryCpuWindow(index, windowStart, windowEnd, topN2);
+  if (res.hotspots.length === 0) return explainEmptyWindow(res, windowStart, windowEnd);
   const header = "| Function | Self (ms) | Total (ms) | Location |";
   const sep7 = "|---|---|---|---|";
-  const rows = hotspots.map((hs) => {
+  const rows = res.hotspots.map((hs) => {
     const loc = hs.url ? `${shortenUrl(hs.url)}${hs.lineNumber != null ? `:${hs.lineNumber}` : ""}` : "\u2014";
     return `| \`${hs.name}\` | ${hs.selfMs} | ${hs.totalMs} | ${loc} |`;
   });
-  const rangeNote = startMs != null ? `**Window:** ${startMs.toFixed(1)}ms \u2192 ${endMs.toFixed(1)}ms
-
-` : "";
   return `## CPU Hotspots
 
-${rangeNote}${header}
+${coverageNote(res, windowStart, windowEnd)}
+
+${header}
 ${sep7}
 ${rows.join("\n")}`;
 }
@@ -140817,7 +140899,7 @@ function renderComponentCpu(index, commitTree, componentName, topN2) {
   }
   const aggregated = /* @__PURE__ */ new Map();
   for (const window2 of commitWindows.values()) {
-    const hotspots = queryCpuWindow(index, window2.start, window2.end, 50);
+    const { hotspots } = queryCpuWindow(index, window2.start, window2.end, 50);
     for (const hs of hotspots) {
       const existing = aggregated.get(hs.name);
       if (existing) {
@@ -140871,6 +140953,10 @@ Requires react-profiler-stop (and ideally react-profiler-analyze) to have been c
 Modes:
 - top_functions: Global CPU hotspots ranked by self-time. Optional time_window_ms to filter.
 - time_window: CPU breakdown for a specific time range (e.g. during a slow commit or hang).
+
+Self-times are the summed sampling intervals of the samples that landed in the window, so they
+measure sampled coverage rather than the window's width and do not change if you widen the query.
+Every table states how many samples it covers and how much of that was idle.
 - call_tree: For a given function_name, show its callees and optionally callers.
 - component_cpu: For a given component_name, aggregate CPU activity across all its commits.
 Use when investigating JS CPU hotspots or correlating CPU cost with specific components.
@@ -140956,8 +141042,12 @@ Fails if no CPU profile is stored \u2014 run react-profiler-stop first.`,
 init_zod();
 init_src();
 var timeRangeSchema = external_exports.object({
-  start: external_exports.coerce.number().describe("Start of range in ms (performance.now clock)"),
-  end: external_exports.coerce.number().describe("End of range in ms (performance.now clock)")
+  start: external_exports.coerce.number().describe(
+    "Start of range in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+  ),
+  end: external_exports.coerce.number().describe(
+    "End of range in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+  )
 });
 var zodSchema54 = external_exports.object({
   port: external_exports.coerce.number().default(8081).describe("Metro server port"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.20.1-next.8",
+  "version": "0.20.1-next.9",
   "mcpName": "io.github.software-mansion/argent",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",