sparkforensics-server 0.6.0 → 0.8.1

package/vendor-core/comparability.js

@@ -0,0 +1,234 @@
+// The facts that decide whether two runs can be read against each other: what configuration and
+// plan they share, how much data they handled, the capacity each had, and how those figures
+// bridge the wall-clock difference. Built once per comparison, so every surface reports the same.
+import { allocatedCoreMs, computeAllocation, lastObservedTimestamp } from './allocation.js';
+import { buildEffectiveConf } from './effective-conf.js';
+import { MAX_NORMALIZE_PATTERN_LENGTH, MAX_NORMALIZE_PATTERNS } from './stage-alignment.js';
+import { totalOutputRows, withEarlierAttempts } from './run-totals.js';
+                                                             
+                                                           
+                                        
+
+/** A configuration key whose value differs between the runs. A side that does not set the key is
+ * null. */
+                                                                                                  
+
+                                    
+                                                                                                
+                                   
+                        
+                                                                                                
+                                                                                            
+                                
+                                                                                                   
+                        
+                                                                        
+                         
+ 
+
+                                    
+                                                            
+                 
+                                                     
+                                                                        
+                    
+ 
+
+/** One data figure of both runs. `relativeDifference` is (candidate - baseline) / baseline, null
+ * when either side is unmeasured or the baseline is 0 and the candidate is not. */
+                                                                                                                      
+
+                                      
+                           
+                           
+                            
+                                                                                               
+                                         
+                        
+ 
+
+                                        
+                                                                           
+                                                                            
+ 
+
+                                                                                                         
+
+/** wall clock = task time / (mean executors x cores x task time's share of allocated core time),
+ * so for runs with equal executor cores the wall-clock ratio is the task-time ratio over the
+ * product of the other two. `explainedWallClock` is that quotient. */
+                                  
+                          
+                         
+                              
+                                      
+                                    
+ 
+
+                                
+                                                                                       
+                    
+                          
+                          
+                              
+                                  
+                                                                                  
+                           
+                                   
+ 
+
+                                       
+                                                                                                
+                                 
+                                                                                                      
+                           
+                                                                                   
+                    
+ 
+
+/** Keys the cluster sets per run (application id, start time, driver address). Two runs of one job
+ * always differ here, so they never count as a configuration difference. */
+const RUN_IDENTITY_CONF = /^spark\.(app\.(id|startTime|submitTime)|driver\.(host|port)|yarn\.app\.id|ui\.port)$/;
+
+/** Compiles the caller's ignore patterns, matched against configuration keys. Throws on a
+ * non-string or empty pattern, an over-long one, an invalid one, or too many. */
+export function compileConfIgnorePatterns(patterns                               )           {
+  if (!patterns || patterns.length === 0) return [];
+  if (patterns.length > MAX_NORMALIZE_PATTERNS) {
+    throw new Error(`At most ${MAX_NORMALIZE_PATTERNS} ignore patterns are accepted, got ${patterns.length}.`);
+  }
+  return patterns.map((source) => {
+    if (typeof source !== 'string' || source.length === 0) throw new Error('An ignore pattern must be a non-empty string.');
+    if (source.length > MAX_NORMALIZE_PATTERN_LENGTH) {
+      throw new Error(`Ignore pattern "${source.slice(0, 40)}..." is ${source.length} characters; the limit is ${MAX_NORMALIZE_PATTERN_LENGTH}.`);
+    }
+    try {
+      return new RegExp(source);
+    } catch (e) {
+      throw new Error(`Ignore pattern "${source}" is not a valid regular expression: ${(e         ).message}`);
+    }
+  });
+}
+
+function compareConf(baseSnap                 , candSnap                 , ignore          , userPattern         )                    {
+  const base = buildEffectiveConf(baseSnap.app, { userPattern });
+  const cand = buildEffectiveConf(candSnap.app, { userPattern });
+  if (base == null || cand == null) return { equal: null, differences: [], ignoredKeys: [], withheldKeys: [] };
+  const withheld = new Set([...base.maskedKeys, ...cand.maskedKeys]);
+  const keys = [...new Set([...Object.keys(base.values), ...Object.keys(cand.values)])].filter((key) => !withheld.has(key)).sort();
+  const differences                   = [];
+  const ignoredKeys           = [];
+  for (const key of keys) {
+    const baseline = base.values[key] ?? null;
+    const candidate = cand.values[key] ?? null;
+    if (baseline === candidate) continue;
+    if (RUN_IDENTITY_CONF.test(key) || ignore.some((pattern) => pattern.test(key))) ignoredKeys.push(key);
+    else differences.push({ key, baseline, candidate });
+  }
+  return { equal: differences.length === 0, differences, ignoredKeys, withheldKeys: [...withheld].sort() };
+}
+
+function comparePlan(alignment                                                 )                    {
+  const unmatched = { baseline: alignment.unmatched.baseStageIds.length, candidate: alignment.unmatched.candStageIds.length };
+  return {
+    equal: unmatched.baseline === 0 && unmatched.candidate === 0 && alignment.replanned.length === 0,
+    unmatched,
+    replanned: alignment.replanned.length,
+  };
+}
+
+function relativeDifference(baseline               , candidate               )                {
+  if (baseline == null || candidate == null) return null;
+  if (baseline === 0) return candidate === 0 ? 0 : null;
+  return (candidate - baseline) / Math.abs(baseline);
+}
+
+function figure(baseline               , candidate               )               {
+  return { baseline, candidate, relativeDifference: relativeDifference(baseline, candidate) };
+}
+
+/** Whether two measured values sit within `noiseBand` of the baseline. A baseline of 0 only
+ * matches a candidate of 0. */
+export function withinBand(baseline        , candidate        , noiseBand        )          {
+  if (baseline === 0) return candidate === 0;
+  return Math.abs(candidate - baseline) / Math.abs(baseline) < noiseBand;
+}
+
+function compareVolume(
+  baseStages         , candStages         , metrics                                                                           , noiseBand        ,
+)                      {
+  const row = (key        ) => metrics.find((m) => m.key === key);
+  const inputBytes = figure(row('inputBytes')?.baseline ?? null, row('inputBytes')?.candidate ?? null);
+  const outputBytes = figure(row('outputBytes')?.baseline ?? null, row('outputBytes')?.candidate ?? null);
+  const outputRows = figure(totalOutputRows(baseStages), totalOutputRows(candStages));
+  const verdicts            = [];
+  for (const fig of [inputBytes, outputBytes]) {
+    if (fig.baseline != null && fig.candidate != null) verdicts.push(withinBand(fig.baseline, fig.candidate, noiseBand));
+  }
+  if (outputRows.baseline != null && outputRows.candidate != null) verdicts.push(outputRows.baseline === outputRows.candidate);
+  const outputMeasured = [outputRows, outputBytes].some((fig) => fig.baseline != null && fig.candidate != null);
+  return { inputBytes, outputRows, outputBytes, equal: !outputMeasured ? null : verdicts.every(Boolean) };
+}
+
+function ratio(baseline               , candidate               )                {
+  return baseline == null || candidate == null || baseline === 0 ? null : candidate / baseline;
+}
+
+function factor(baseline               , candidate               )               {
+  return { baseline, candidate, ratio: ratio(baseline, candidate) };
+}
+
+function runWindow(snap                 )                          {
+  const start = snap.app?.startTime;
+  const end = snap.app?.endTime ?? (snap.executors ? lastObservedTimestamp(snap) : null);
+  return start != null && end != null && end >= start ? [start, end] : null;
+}
+
+/** The comparability facts of a comparison. `metrics` are the comparison's own rows, so the
+ * volume and bridge figures are the ones the metrics table shows. */
+export function buildComparability(
+  baseSnap                 , candSnap                 ,
+  alignment                                                 ,
+  metrics                                                                           ,
+  { ignoreConf, confRedactRegex, noiseBand }                      ,
+)                {
+  const attempts = (snap                 )          => withEarlierAttempts([...snap.stages.values()]);
+  const allocation = (snap                 ) => (snap.executors ? computeAllocation(snap) : null);
+  const baseAlloc = allocation(baseSnap), candAlloc = allocation(candSnap);
+  const row = (key        ) => metrics.find((m) => m.key === key);
+  const share = (snap                 , runTimeMs               )                => {
+    const allocated = snap.executors ? allocatedCoreMs(snap) : null;
+    return runTimeMs != null && allocated != null ? runTimeMs / allocated : null;
+  };
+  const taskTime = factor(row('executorRunTime')?.baseline ?? null, row('executorRunTime')?.candidate ?? null);
+  const meanExecutors = factor(baseAlloc?.executorsMean ?? null, candAlloc?.executorsMean ?? null);
+  const taskShare = factor(share(baseSnap, taskTime.baseline), share(candSnap, taskTime.candidate));
+  const parts = [taskTime.ratio, meanExecutors.ratio, taskShare.ratio];
+  const explainedWallClock = parts.every((r)              => r != null && r > 0)
+    ? parts[0]  / (parts[1]  * parts[2] )
+    : null;
+
+  const baseWindow = runWindow(baseSnap), candWindow = runWindow(candSnap);
+  const overlapMs = baseWindow && candWindow
+    ? Math.max(0, Math.min(baseWindow[1], candWindow[1]) - Math.max(baseWindow[0], candWindow[0]))
+    : null;
+
+  return {
+    noiseBand,
+    conf: compareConf(baseSnap, candSnap, compileConfIgnorePatterns(ignoreConf), confRedactRegex),
+    plan: comparePlan(alignment),
+    volume: compareVolume(attempts(baseSnap), attempts(candSnap), metrics, noiseBand),
+    capacity: {
+      baseline: { meanExecutors: baseAlloc?.executorsMean ?? null, peakExecutors: baseAlloc?.executorsPeak ?? null },
+      candidate: { meanExecutors: candAlloc?.executorsMean ?? null, peakExecutors: candAlloc?.executorsPeak ?? null },
+    },
+    overlapMs,
+    wallClockBridge: {
+      wallClock: factor(row('wallClock')?.baseline ?? null, row('wallClock')?.candidate ?? null),
+      taskTime,
+      meanExecutors,
+      taskShareOfAllocation: taskShare,
+      explainedWallClock,
+    },
+  };
+}

package/vendor-core/comparison-output.js

@@ -1,6 +1,7 @@
 import { buildComparison,                                             } from './run-comparison.js';
 import { comparisonVerdict,                            } from './comparison-verdict.js';
 import { redactComparison } from './redact.js';
+                                                       
                                                     
 
                                                                                              
@@ -8,10 +9,11 @@ import { redactComparison } from './redact.js';
 // The comparison a surface reports: the CLI's `comparison` object and the shared part of MCP
 // compare_runs. A field added here reaches every surface.
 // `stagePairs` is the one large field (a row per paired stage), so the `summary` view leaves it out.
-                                                                 
+// `generator` is the build that wrote the output, present when the surface supplies it.
+                                                                                              
                            
-                                                                                            
-                                                                                                           
+                                                                                                                             
+                                                                                                                             
                                                    
 
 /** `full` carries every field (the CLI); `summary` leaves out `stagePairs` (MCP, which returns them
@@ -19,9 +21,14 @@ import { redactComparison } from './redact.js';
                                                 
 
 /** The reported projection of a comparison. Key order is the CLI's JSON order. */
-export function comparisonOutput(comparison                   , view                 = 'full')                   {
+export function comparisonOutput(
+  comparison                   , view                 = 'full', generator                  ,
+)                   {
   return {
+    ...(generator ? { generator } : {}),
     verdict: comparisonVerdict(comparison),
+    baselineApp: comparison.baselineApp,
+    candidateApp: comparison.candidateApp,
     confidence: comparison.confidence,
     reason: comparison.reason,
     matchedCoverage: comparison.matchedCoverage,
@@ -34,6 +41,7 @@ export function comparisonOutput(comparison                   , view
     replanned: comparison.replanned,
     bookkeepingStageIds: comparison.bookkeepingStageIds,
     executionAlignment: comparison.executionAlignment,
+    comparability: comparison.comparability,
   };
 }
 
@@ -42,9 +50,9 @@ export function comparisonOutput(comparison                   , view
  * and Markdown; `output` is the projection to serialize. */
 export function buildComparisonOutput(
   baseline                    , candidate                    ,
-  { redact, normalizePath, view }                                                               = {},
+  { redact, normalizePath, ignoreConf, confRedactRegex, noiseBand, view, generator }                                                                                            = {},
 )                                                              {
-  const built = buildComparison(baseline, candidate, { normalizePath });
+  const built = buildComparison(baseline, candidate, { normalizePath, ignoreConf, confRedactRegex, noiseBand });
   const comparison = redact ? redactComparison(built) : built;
-  return { comparison, output: comparisonOutput(comparison, view) };
+  return { comparison, output: comparisonOutput(comparison, view, generator) };
 }

package/vendor-core/comparison-verdict.js

@@ -1,6 +1,7 @@
 import { formatDuration, typeTag } from './format-utils.js';
 import { TAG_HELP } from './finding-tag-help.js';
-import { NEUTRAL_METRIC_KEYS,                        } from './run-comparison.js';
+import { DEFAULT_NOISE_BAND, isEscalation, NEUTRAL_METRIC_KEYS,                        } from './run-comparison.js';
+                                                        
 
 /** The slice of a comparison metric row the verdict reads. */
                                 
@@ -10,15 +11,27 @@ import { NEUTRAL_METRIC_KEYS,                        } from './run-comparison.js
                            
                        
                                                                                     
+                                                                                        
+                        
  
 
-/** The slice of a finding-category delta the verdict reads. */
+/** The slice of the comparability block the verdict reads. */
+                                                                                                                                  
+
+/** The slice of an introduced or resolved finding row the verdict reads. */
                                   
                
                     
                     
  
 
+/** The slice of a changed finding row the verdict reads. */
+                                
+               
+                         
+                         
+ 
+
 /** How many of a run's ended jobs failed, counted as `summarizeRunOutcome`
  * counts them. */
                                     
@@ -29,7 +42,9 @@ import { NEUTRAL_METRIC_KEYS,                        } from './run-comparison.js
                        
  
 
-                                                                     
+/** `equivalent`: configuration, plan and output agree, so a time difference is a difference in
+ * capacity or scheduling. `mixed`: wall clock and cost moved opposite ways. */
+                                                                                              
 
                                         
                 
@@ -40,17 +55,58 @@ import { NEUTRAL_METRIC_KEYS,                        } from './run-comparison.js
 /** A change under this share of the baseline's value reads as "about the same", for
  * run time and cost metrics alike: run-to-run noise on a shared cluster easily
  * moves a job a percent or two. */
-export const SAME_CHANGE_SHARE = 0.02;
+export const SAME_CHANGE_SHARE = DEFAULT_NOISE_BAND;
 
 function measured(metric               )                                                                    {
   return metric.baseline != null && metric.candidate != null;
 }
 
 function movedPastNoise(metric                                                         )          {
+  if (metric.withinNoise !== undefined) return !metric.withinNoise;
   if (metric.baseline === 0) return metric.candidate !== 0;
   return Math.abs(metric.candidate - metric.baseline) / Math.abs(metric.baseline) >= SAME_CHANGE_SHARE;
 }
 
+const percent = (share        )         => `${Math.round(Math.abs(share) * 100)}%`;
+const times = (ratio        )         => `×${ratio.toFixed(2)}`;
+
+/** The facts a time difference rests on: the factors of the wall-clock bridge that moved past the
+ * noise band, each stated for both runs. */
+function bridgeReasons(comparability                      )           {
+  const { wallClockBridge: bridge, noiseBand } = comparability;
+  const moved = (ratio               )          => ratio != null && Math.abs(ratio - 1) >= noiseBand;
+  const reasons           = [];
+  const { meanExecutors, taskTime, taskShareOfAllocation: share } = bridge;
+  if (moved(meanExecutors.ratio)) reasons.push(`executors averaged ${meanExecutors.baseline .toFixed(1)} in the baseline and ${meanExecutors.candidate .toFixed(1)} in the candidate`);
+  if (moved(taskTime.ratio)) reasons.push(`task time was ${formatDuration(taskTime.baseline )} in the baseline and ${formatDuration(taskTime.candidate )} in the candidate`);
+  if (moved(share.ratio)) reasons.push(`task time filled ${percent(share.baseline )} of allocated core time in the baseline and ${percent(share.candidate )} in the candidate`);
+  return reasons;
+}
+
+/** "Wall clock ×1.49 = task time ×0.82 / (mean executors ×0.57 × task share of allocation ×0.96)",
+ * candidate over baseline; null when a factor is unmeasured. */
+function bridgeSentence({ wallClockBridge: bridge }                      )                {
+  const { wallClock, taskTime, meanExecutors, taskShareOfAllocation: share } = bridge;
+  if (wallClock.ratio == null || taskTime.ratio == null || meanExecutors.ratio == null || share.ratio == null) return null;
+  return `Candidate over baseline: wall clock ${times(wallClock.ratio)} is task time ${times(taskTime.ratio)} divided by mean executors ${times(meanExecutors.ratio)} times task time's share of allocated core time ${times(share.ratio)}.`;
+}
+
+function configAndPlanAgree({ conf, plan }                      )          {
+  return conf.equal === true && plan.equal;
+}
+
+/** The cost metrics that moved past noise against the direction wall clock moved, as phrases such
+ * as "executor run-time is 18% lower". Empty when wall clock stayed within noise. */
+function opposingCost(wall                                                         , metrics                 )           {
+  if (!movedPastNoise(wall)) return [];
+  const wallUp = wall.candidate > wall.baseline;
+  return metrics
+    .filter((m) => m.key === 'executorRunTime' || m.key === 'allocatedCoreHours')
+    .filter(measured)
+    .filter((m) => m.baseline > 0 && movedPastNoise(m) && (m.candidate > m.baseline) !== wallUp)
+    .map((m) => `${m.label.toLowerCase()} is ${percent((m.candidate - m.baseline) / m.baseline)} ${m.candidate < m.baseline ? 'lower' : 'higher'}`);
+}
+
 /** Plain name for a finding type ("Memory and disk spill"), falling back to
  * its tag when the tag has no help entry. */
 function categoryName(type        )         {
@@ -58,13 +114,11 @@ function categoryName(type        )         {
   return TAG_HELP[tag]?.expansion ?? tag;
 }
 
-/** Net count change per displayed category name. Categories are tallied per
- * (rule, impact band), and several rules share one name (every Plan Advisor
- * type reads "Plan advisor", every stage-shape sub-rule "Stage shape"), so a
- * rule whose findings moved from critical to warning, or two rules under one
- * name moving opposite ways, would otherwise
- * read as both "introduced" and "resolved". Order follows first appearance,
- * introduced before resolved. */
+/** Net count change per displayed category name. Several rules share one name (every Plan Advisor
+ * type reads "Plan advisor", every stage-shape sub-rule "Stage shape"), so two rules under one
+ * name moving opposite ways net out rather than read as both "new" and "less frequent". Findings
+ * that only changed impact band are not in `introduced` or `resolved`, so they do not move a
+ * category. Order follows first appearance, introduced before resolved. */
 function netByCategory(findings                                                                )                      {
   const net = new Map                ();
   for (const item of [...findings.introduced, ...findings.resolved]) {
@@ -105,18 +159,18 @@ function failureHeadline(base                   , cand                   )
 }
 
 /** One plain answer to "did the candidate get better or worse than the baseline", from the
- * comparison's own whole-run metrics and finding-category tallies: run time
- * first, then which cost metrics moved each way past run-to-run noise, then which finding
- * categories appeared or went away. When either run had failed jobs, that
- * leads instead and run time becomes the first sentence. When either log is
- * incomplete, run time is stated as what each log covers, never as faster or
- * slower, and the tone stays neutral. Volume and count metrics (input, output,
- * tasks, executors) are left out because more or less of them is not
- * inherently better or worse. */
+ * comparison's whole-run metrics and finding-category tallies: run time, then the cost metrics
+ * that moved past run-to-run noise, then the finding categories that appeared or went away. Failed
+ * jobs lead when either run had any; an incomplete log states run time as what each log covers
+ * with a neutral tone. Volume and count metrics are left out (NEUTRAL_METRIC_KEYS). With the
+ * comparability block, runs that agree in configuration, plan and output read `equivalent`, and a
+ * wall clock that moved against the cost metrics reads `mixed`. The rules are in
+ * docs-site/user-guide/run-comparison.md. */
 export function summarizeComparison(
   metrics                 ,
-  findings                                                                ,
+  findings                                                                                           ,
   jobs                                                                ,
+  comparability                       ,
 )                        {
   const wall = metrics.find((metric) => metric.key === 'wallClock');
   let title = 'Run time could not be compared between the baseline and the candidate';
@@ -132,7 +186,7 @@ export function summarizeComparison(
   } else if (wall && wall.baseline != null && wall.baseline > 0 && wall.candidate != null) {
     const change = wall.candidate - wall.baseline;
     const share = change / wall.baseline;
-    if (Math.abs(share) < SAME_CHANGE_SHARE) {
+    if (!movedPastNoise({ ...wall, baseline: wall.baseline, candidate: wall.candidate })) {
       title = 'The candidate took about as long as the baseline';
       tone = 'same';
     } else {
@@ -142,12 +196,36 @@ export function summarizeComparison(
     }
   }
 
+  const sentences           = [];
+  const failure = jobs ? failureHeadline(jobs.baseline, jobs.candidate) : null;
+  if (comparability && !failure && incompleteRuns.length === 0 && wall && measured(wall) && wall.baseline > 0) {
+    const change = wall.candidate - wall.baseline;
+    const drift = movedPastNoise(wall)
+      ? `Time differs by ${formatDuration(Math.abs(change))} (${percent(change / wall.baseline)})`
+      : 'The candidate took about as long as the baseline';
+    if (configAndPlanAgree(comparability) && comparability.volume.equal !== false) {
+      const outputAgrees = comparability.volume.equal === true;
+      const gap = movedPastNoise(wall);
+      const reasons = gap ? bridgeReasons(comparability) : [];
+      const lead = outputAgrees ? 'Same configuration, plan and output' : 'Same configuration and plan. Output was not compared';
+      const explanation = reasons.length > 0 ? `: ${reasons.join(', ')}` : gap ? ', and no measured factor explains it' : '';
+      title = `${lead}. ${drift}${explanation}.`;
+      if (outputAgrees && (!gap || reasons.length > 0)) tone = 'equivalent';
+      const bridge = gap ? bridgeSentence(comparability) : null;
+      if (bridge) sentences.push(bridge);
+    } else {
+      const opposed = opposingCost(wall, metrics);
+      if (opposed.length > 0) {
+        title = `The candidate finished ${formatDuration(Math.abs(change))} ${change < 0 ? 'faster' : 'slower'} than the baseline (${percent(change / wall.baseline)}), while ${opposed.join(' and ')}`;
+        tone = 'mixed';
+      }
+    }
+  }
+
   const cost = metrics.filter((metric) => metric.key !== 'wallClock' && !NEUTRAL_METRIC_KEYS.has(metric.key)).filter(measured);
   const moved = cost.filter(movedPastNoise);
   const worse = moved.filter((metric) => metric.direction === 'regression').map((metric) => metric.label);
   const better = moved.filter((metric) => metric.direction === 'improvement').map((metric) => metric.label);
-  const sentences           = [];
-  const failure = jobs ? failureHeadline(jobs.baseline, jobs.candidate) : null;
   if (failure) {
     sentences.push(`${title}.`);
     title = failure.title;
@@ -167,11 +245,13 @@ export function summarizeComparison(
   const resolved = namesWhere(net, (change) => change < 0);
   if (introduced.length > 0) sentences.push(`New or more frequent in the candidate: ${introduced.join(', ')}.`);
   if (resolved.length > 0) sentences.push(`Less frequent in the candidate: ${resolved.join(', ')}.`);
+  const escalated = [...new Set((findings.changed ?? []).filter(isEscalation).map((c) => categoryName(c.type)))];
+  if (escalated.length > 0) sentences.push(`More severe in the candidate: ${escalated.join(', ')}.`);
   return { title, tone, sentences };
 }
 
 /** The comparison verdict for a core comparison result: the one the dashboard's comparison page
  * leads with, and the one the CLI's --baseline report and MCP compare_runs carry. */
-export function comparisonVerdict(result                                                                 )                        {
-  return summarizeComparison(result.metrics, result.findings, result.jobOutcomes);
+export function comparisonVerdict(result                                                                                                            )                        {
+  return summarizeComparison(result.metrics, result.findings, result.jobOutcomes, result.comparability);
 }

package/vendor-core/core-source-hash.txt

@@ -1 +1 @@
-9c33274bcae34f425c7d625bdea9cfacdb400f333bc3a5ced9c86a0e75094916
+06b1ffacd20e0b5e1d7b6a19ed645fb088c6049114893b77cf4662261d610924

package/vendor-core/core-time-series.js

@@ -65,7 +65,6 @@ export function computeCoreTimeSeries(intervals            , {
     return { mode: 'coreCount', histogram };
   }
 
-  // bucketBy === 'time'
   if (segments.length === 0) {
     return { mode: 'time', bucketWidthMs, startTime: null, endTime: null, buckets: [] };
   }

package/vendor-core/core-usage-locality.js

@@ -105,7 +105,7 @@ export function buildLocalityChart(
     const point                     = { t: Math.round((t - start) / 1000) };
     // The series averages each bucket over its full width, so a last bucket
     // that runs past the series' own end (or a run shorter than one bucket)
-    // reads diluted: a 10s stage in a 60s bucket showed well under its busy
+    // reads diluted: a 10s stage in a 60s bucket shows well under its busy
     // cores. Rescale to the part of the bucket the series actually covers.
     const coveredMs = Math.min(bucketWidthMs, seriesEnd - t);
     const scale = bucketWidthMs / coveredMs;