sparkforensics-mcp 0.4.0 → 0.5.0

package/vendor-core/event-handlers.js

@@ -22,8 +22,9 @@ import { assertNever } from './assert-never.js';
 import { finalizeStage } from './stage-quantiles.js';
 import { MAX_FAILURE_DETAILS_PER_STAGE, extractTaskFailureDetail, taskFailureKey,                        } from './task-failure.js';
 import { computeRunAggregates } from './run-aggregates.js';
+import { parseSparkMemoryMB } from './spark-memory.js';
              
-                                                                                        
+                                                                                                            
                  
 
 // Internal parser-state shapes: the real runtime objects the handlers build and mutate, not the
@@ -129,6 +130,8 @@ const MAX_TASK_SAMPLES = 20;
                           
                      
                       
+                                                                                                
+                               
  
 
                        
@@ -149,12 +152,29 @@ const MAX_TASK_SAMPLES = 20;
                           
                      
                       
+                                                                      
+                               
                                 
                       
                                   
                            
                                       
                                     
+                                                                                                        
+                         
+                                                                                                  
+                                                                                       
+                        
+                              
+                                                                                       
+                                             
+                                                                                       
+                                                                                             
+                                                                                              
+                                                     
+                                             
+                                                              
+                                  
                                                         
                                                                                            
                                                         
@@ -198,6 +218,9 @@ const MAX_TASK_SAMPLES = 20;
                          
                                                                               
                        
+                                                                                               
+                                                                                  
+                                   
                                                
                                       
                                         
@@ -391,6 +414,7 @@ export function createState()              {
     jobs: new Map(),
     executors: { added: [], removed: [] },
     skippedLines: 0,
+    unreadableSqlStarts: new Set(),
     accumState: new Map(),
     rddInfo: new Map(),
     rddBlocks: new Map(),
@@ -432,23 +456,7 @@ export function normalizeSparkProperties(
   return map;
 }
 
-// Parse a Spark memory-size string to MiB. Spark's JVM-memory configs use bytesConf(ByteUnit.MiB),
-// so a bare number means MiB. A k/m/g/t suffix sets the unit (trailing "b" redundant); a lone "b"
-// ("10b") means bytes.
-export function parseSparkMemoryMB(value         )                {
-  if (value == null) return null;
-  const m = String(value).trim().toLowerCase().match(/^([\d.]+)\s*([kmgt]?)(b?)$/);
-  if (!m) return null;
-  const n = parseFloat(m[1]);
-  if (!Number.isFinite(n)) return null;
-  switch (m[2]) {
-    case 'k': return Math.round(n / 1024);
-    case 'g': return Math.round(n * 1024);
-    case 't': return Math.round(n * 1024 * 1024);
-    case 'm': return Math.round(n);
-    default: return m[3] === 'b' ? Math.round(n / (1024 * 1024)) : Math.round(n);
-  }
-}
+export { parseSparkMemoryMB };
 
 // Derive an allocated-resource summary from the Spark config map. Absent keys degrade to null,
 // not guessed defaults.
@@ -533,29 +541,11 @@ function internTaskFailure(stage             , endReason
   return detail;
 }
 
-export function accumulateTask(event                                    , state             )       {
-  const stageId = event['Stage ID'];
-  const stage = state.stages.get(stageId);
-  if (!stage) return null;
-  // Late TaskEnd for a stage whose StageCompleted already freed taskAttempts (finalizeStage): its
-  // stats are already baked into the finalized stage, don't re-add. The one exception is a losing
-  // speculative attempt, whose wasted time the finalized stage never saw.
-  if (stage.taskAttempts === null) {
-    accountLateSpeculativeLoser(event, stage);
-    return null;
-  }
-
-  state.evidenceInputs.taskRecords++;
-
-  const accumulables = event['Task Info']?.Accumulables ?? [];
-  for (const acc of accumulables) {
-    if (!state.taskAccumStages.has(acc.ID)) state.taskAccumStages.set(acc.ID, new Set());
-    state.taskAccumStages.get(acc.ID) .add(stageId);
-  }
+// 'Task Info' and its Failed/Killed/Speculative fields are optional in the schema; Partial<>
+// lets the {} fallback type-check while reads below default via ??/||.
+                                                                                         
 
-  // 'Task Info' and its Failed/Killed/Speculative fields are optional in the schema; Partial<>
-  // lets the {} fallback type-check while reads below default via ??/||.
-                                                                                           
+function taskRecordOf(event                                    , failure                          )             {
   const info              = event['Task Info'] ?? {};
   const m = event['Task Metrics'] ?? {};
   const sr = m['Shuffle Read Metrics'] ?? {};
@@ -566,14 +556,14 @@ export function accumulateTask(event                                    , state
   const duration = (info['Finish Time'] ?? 0) - (info['Launch Time'] ?? 0);
   const failed = !!(info['Failed'] || info['Killed']);
 
-  const record             = {
+  return {
     duration, failed,
     taskId: info['Task ID'] ?? null,
     attemptNumber: info['Attempt Number'] ?? 0,
     launchTime: info['Launch Time'] ?? 0,
     finishTime: info['Finish Time'] ?? 0,
     reason: event['Task End Reason']?.['Reason'] ?? null,
-    failure: failed ? internTaskFailure(stage, event['Task End Reason']) : null,
+    failure,
     speculative: info['Speculative'] === true,
     host: info['Host'] ?? '',
     executorId: info['Executor ID'] ?? '',
@@ -589,7 +579,37 @@ export function accumulateTask(event                                    , state
     executorCpuTime: m['Executor CPU Time'] ?? 0,
     inputBytes: inp['Bytes Read'] ?? 0,
     outputBytes: out['Bytes Written'] ?? 0,
+    outputRecords: out['Records Written'] ?? null,
   };
+}
+
+export function accumulateTask(event                                    , state             )       {
+  const stageId = event['Stage ID'];
+  const stage = state.stages.get(stageId);
+  if (!stage) return null;
+  // Late TaskEnd for a stage whose StageCompleted already freed taskAttempts (finalizeStage): the
+  // finalized stage's figures stay as posted. A losing speculative attempt adds the wasted time the
+  // finalized stage never saw; any other task of a failed or earlier attempt is work only the
+  // metrics block reads, from lateAttemptWork.
+  if (stage.taskAttempts === null) {
+    const earlierAttempt = (event['Stage Attempt ID'] ?? 0) !== stage.stageAttemptId;
+    if (!accountLateSpeculativeLoser(event, stage) && (stage.stageFailureReason != null || earlierAttempt)) {
+      stage.lateAttemptWork = mergeAttemptTotals(taskAttemptTotals(taskRecordOf(event, null)), stage.lateAttemptWork);
+    }
+    return null;
+  }
+
+  state.evidenceInputs.taskRecords++;
+
+  const accumulables = event['Task Info']?.Accumulables ?? [];
+  for (const acc of accumulables) {
+    if (!state.taskAccumStages.has(acc.ID)) state.taskAccumStages.set(acc.ID, new Set());
+    state.taskAccumStages.get(acc.ID) .add(stageId);
+  }
+
+  const info              = event['Task Info'] ?? {};
+  const failed = !!(info['Failed'] || info['Killed']);
+  const record = taskRecordOf(event, failed ? internTaskFailure(stage, event['Task End Reason']) : null);
 
   // Dedupe only when Index is present (always true for real logs). Without it every event is a
   // distinct task, preserving behavior for fixtures that omit Index.
@@ -614,9 +634,11 @@ export function accumulateTask(event                                    , state
         stage.retryTaskSamples.push(taskRecordToSample(existing));
       }
     }
+    stage.lateAttemptWork = mergeAttemptTotals(discardedAttemptTotals(existing), stage.lateAttemptWork);
     stage.taskAttempts.set(key, record);
     if (record.speculative) stage.speculativeWinners.add(key);
   } else {
+    stage.lateAttemptWork = mergeAttemptTotals(discardedAttemptTotals(record), stage.lateAttemptWork);
     // Non-winning duplicate (both failed, or a race where a winner is
     // already recorded): its time is waste, its metrics are discarded.
     if (existing.speculative || record.speculative) {
@@ -639,14 +661,16 @@ export function accumulateTask(event                                    , state
 // its time as speculation waste, pairing it the same way accumulateTask does: the late attempt is
 // the speculative copy itself, or the original that a speculative winner beat. Every other stat
 // of a late attempt stays excluded, as the finalized stage already posted them.
-function accountLateSpeculativeLoser(event                                    , stage             )       {
+function accountLateSpeculativeLoser(event                                    , stage             )          {
   const info = event['Task Info'];
-  if (info?.['Index'] == null) return;
+  if (info?.['Index'] == null) return false;
   const key = `${event['Stage Attempt ID'] ?? 0}:${info['Index']}`;
-  if (info['Speculative'] !== true && !stage.speculativeWinners.has(key)) return;
+  if (info['Speculative'] !== true && !stage.speculativeWinners.has(key)) return false;
   stage.speculationWasteMs += (info['Finish Time'] ?? 0) - (info['Launch Time'] ?? 0);
   stage.speculationWastedAttempts++;
   stage.lateSpeculationWaste = true;
+  stage.lateAttemptWork = mergeAttemptTotals(discardedAttemptTotals(taskRecordOf(event, null)), stage.lateAttemptWork);
+  return true;
 }
 
 export function resolvePlanTree(
@@ -853,10 +877,63 @@ export function endJob(event                                   , state
   return { type: 'job', data: { ...job } };
 }
 
+const SUMMED_ATTEMPT_FIELDS = [
+  'taskCount', 'failedTasks', 'wastedAttempts', 'executorRunTime', 'executorCpuTime', 'jvmGCTime',
+  'memoryBytesSpilled', 'diskBytesSpilled', 'shuffleReadBytes', 'shuffleWriteBytes', 'inputBytes', 'outputBytes',
+]         ;
+
+const addNullable = (a               , b               )                => (a == null ? b : b == null ? a : a + b);
+
+function mergeAttemptTotals(a                    , b                           )                     {
+  if (b == null) return a;
+  const totals = {
+    outputRecords: addNullable(a.outputRecords, b.outputRecords),
+    peakExecutionMemoryMax: Math.max(a.peakExecutionMemoryMax, b.peakExecutionMemoryMax),
+    durationMs: addNullable(a.durationMs, b.durationMs),
+  }                      ;
+  for (const field of SUMMED_ATTEMPT_FIELDS) totals[field] = a[field] + b[field];
+  return totals;
+}
+
+// One task's work; a late task adds no stage duration.
+function taskAttemptTotals(t            )                     {
+  return {
+    taskCount: 1, failedTasks: t.failed ? 1 : 0, wastedAttempts: 0,
+    executorRunTime: t.executorRunTime, executorCpuTime: t.executorCpuTime, jvmGCTime: t.gcTime,
+    memoryBytesSpilled: t.memSpilled, diskBytesSpilled: t.diskSpilled,
+    shuffleReadBytes: t.shuffleRead, shuffleWriteBytes: t.shuffleWrite,
+    inputBytes: t.inputBytes, outputBytes: t.outputBytes, outputRecords: t.outputRecords,
+    peakExecutionMemoryMax: t.peakExecMem, durationMs: null,
+  };
+}
+
+// A task attempt the stage's figures drop because another attempt of the same task won (a retry
+// after a failure, a speculative twin): its CPU, run time and I/O were still spent, so the
+// metrics block counts them, but the task itself is already counted once.
+function discardedAttemptTotals(t            )                     {
+  return { ...taskAttemptTotals(t), taskCount: 0, failedTasks: 0 };
+}
+
+// The replaced record's finalized attempt added to the attempts it had already folded. An attempt resubmitted before its StageCompleted was never finalized, so its
+// tasks are not counted.
+function foldEarlierAttempts(replaced                         )                            {
+  if (!replaced) return null;
+  if (replaced.taskAttempts !== null) return replaced.earlierAttempts;
+  const attempt                     = {
+    ...Object.fromEntries(SUMMED_ATTEMPT_FIELDS.map((field) => [field, replaced[field]]))                                                                  ,
+    outputRecords: replaced.outputRecords,
+    peakExecutionMemoryMax: replaced.peakExecutionMemoryMax ?? 0,
+    durationMs: replaced.submittedAt > 0 && replaced.completedAt >= replaced.submittedAt
+      ? replaced.completedAt - replaced.submittedAt : null,
+  };
+  return mergeAttemptTotals(attempt, replaced.earlierAttempts);
+}
+
 export function submitStage(event                                           , state             )       {
   state.evidenceInputs.stageSubmissions++;
   const info = event['Stage Info'];
   const id = info['Stage ID'];
+  const replaced = state.stages.get(id);
   state.stages.set(id, {
     id, name: info['Stage Name'] ?? '', details: info['Details'] ?? '',
     submittedAt: info['Submission Time'] ?? 0, completedAt: 0,
@@ -864,13 +941,18 @@ export function submitStage(event                                           , st
     shuffleReadBytes: 0, shuffleWriteBytes: 0, fetchWaitTime: 0,
     memoryBytesSpilled: 0, diskBytesSpilled: 0,
     jvmGCTime: 0, executorRunTime: 0, executorCpuTime: 0,
-    inputBytes: 0, outputBytes: 0,
+    inputBytes: 0, outputBytes: 0, outputRecords: null,
     sqlExecutionId: state.stageToSqlExec.get(id) ?? null,
     parentIds: info['Parent IDs'] ?? [],
     hostStats: new Map(),
     speculativeTasks: 0,
     failureReasons: new Map(),
     stageFailureReason: null,
+    stageAttemptId: info['Stage Attempt ID'] ?? 0,
+    stageAttempts: (replaced?.stageAttempts ?? 0) + 1,
+    failedStageAttempts: replaced?.failedStageAttempts ?? 0,
+    earlierAttempts: foldEarlierAttempts(replaced),
+    lateAttemptWork: replaced?.lateAttemptWork ?? null,
     taskAttempts: new Map(),
     failureDetails: new Map(),
     retryTaskSamples: [],
@@ -1164,6 +1246,8 @@ export function processEvent(event            , state             )          {
       // every stage-duration figure becomes the epoch timestamp itself (a "47-year" stage).
       if (!stage.submittedAt && info['Submission Time'] != null) stage.submittedAt = info['Submission Time'];
       stage.stageFailureReason = info['Failure Reason'] ?? null;
+      // A duplicate StageCompleted of an already-finalized attempt is not another failed attempt.
+      if (stage.stageFailureReason != null && stage.taskAttempts !== null) stage.failedStageAttempts++;
       // finalizeStage keeps its `stage` parameter typed as a loose Record (see that module); bridge
       // StageRecord's more precise shape across that boundary with an explicit cast.
       return finalizeStage(
@@ -1363,6 +1447,18 @@ export function dispatchLine(
 const BLOCK_UPDATED_PREFIX = '{"Event":"SparkListenerBlockUpdated",';
 const RDD_BLOCK_ID_FRAGMENT = '"Block ID":"rdd_';
 
+const SQL_START_EVENT = 'org.apache.spark.sql.execution.ui.SparkListenerSQLExecutionStart';
+const SQL_START_ID = /"executionId":(\d+)/;
+
+// Records the execution id of a skipped SQL start line, when the line's head still names it: a
+// line cut off mid-plan fails JSON.parse but keeps its leading fields.
+function noteUnreadableSqlStart(line        , state             )       {
+  const head = line.slice(0, 300);
+  if (!head.includes(`${SQL_START_EVENT}"`)) return;
+  const id = SQL_START_ID.exec(head);
+  if (id) state.unreadableSqlStarts.add(Number(id[1]));
+}
+
 function parseAndDispatch(line        , state             , emit                        )       {
   if (line.startsWith(BLOCK_UPDATED_PREFIX) && !line.includes(RDD_BLOCK_ID_FRAGMENT)) return;
   let parsed         ;
@@ -1370,6 +1466,7 @@ function parseAndDispatch(line        , state             , emit
     parsed = parseTaskEnd(line) ?? JSON.parse(stripPlanDescription(line));
   } catch {
     state.skippedLines++;
+    noteUnreadableSqlStart(line, state);
     return;
   }
   // A real Spark event log carries many event types this tool never modeled (BlockManagerAdded,
@@ -1382,6 +1479,7 @@ function parseAndDispatch(line        , state             , emit
   const result = SparkEventSchema.safeParse(parsed);
   if (!result.success) {
     state.skippedLines++;
+    if (eventType === SQL_START_EVENT) noteUnreadableSqlStart(line, state);
     return;
   }
   if (result.data.Event === 'org.apache.spark.sql.execution.ui.SparkListenerSQLExecutionEnd') {
@@ -1428,14 +1526,29 @@ export function collectLateSpeculationWaste(
   return out;
 }
 
+// Late work of every stage a failed attempt's late TaskEnd added to, re-posted once before `done`:
+// the stage message posted at completion predates it.
+export function collectLateAttemptWork(state             )                                  {
+  const out = new Map                            ();
+  for (const [id, stage] of state.stages) {
+    if (stage.lateAttemptWork != null) out.set(id, stage.lateAttemptWork);
+  }
+  return out;
+}
+
 export function emitParseCompletion(state             , emit                        , linesProcessed        )       {
   // Executions that never ended keep their latest AQE update, as they did before it was deferred.
   for (const executionId of [...state.pendingAdaptiveUpdates.keys()]) flushAdaptiveUpdate(executionId, state, emit);
   emit({ type: 'progress', pct: 1, linesProcessed });
+  emit({ type: 'stageLateAttemptWork', data: collectLateAttemptWork(state) });
   emit({ type: 'runAggregates', data: computeRunAggregates(state.taskStore) });
   emit({ type: 'stageSpeculationWaste', data: collectLateSpeculationWaste(state) });
   emit({ type: 'stageExecutorMetrics', data: collectStageExecutorMetrics(state) });
   emit(appMessage(state));
-  emit({ type: 'done', skippedLines: state.skippedLines });
+  emit({
+    type: 'done',
+    skippedLines: state.skippedLines,
+    ...(state.unreadableSqlStarts.size > 0 ? { unreadableSqlExecutions: [...state.unreadableSqlStarts].sort((a, b) => a - b) } : {}),
+  });
   state.accumState.clear();
 }

package/vendor-core/event-schemas.js

@@ -201,6 +201,7 @@ export const StageSubmittedEventSchema = z.object({
   Event: z.literal('SparkListenerStageSubmitted'),
   'Stage Info': z.object({
     'Stage ID': z.number(),
+    'Stage Attempt ID': z.number().optional(),
     'Stage Name': z.string().optional(),
     Details: z.string().optional(),
     'Submission Time': z.number().optional(),
@@ -311,6 +312,7 @@ export const TaskEndEventSchema = z.object({
     }).optional(),
     'Output Metrics': z.object({
       'Bytes Written': z.number().optional(),
+      'Records Written': z.number().optional(),
     }).optional(),
   }).optional(),
 });

package/vendor-core/evidence-report.js

@@ -8,24 +8,25 @@ import {
 } from './threshold-overrides.js';
 import { getThresholdSummary } from './threshold-summary.js';
 import {
-  typeTag, formatBytes, formatCores, formatDuration, formatRawWaste, formatWallClockRange, IMPACT_BAND_ORDER, readsAsZero,
+  typeTag, formatBytes, formatCores, formatDuration, formatWallClockRange, IMPACT_BAND_ORDER,
 } from './format-utils.js';
 import { findingName, titleCase } from './finding-names.js';
 import { redactReport, redactRunModel } from './redact.js';
 import { formatTaskFailureHeadline,                       } from './task-failure.js';
 import { findingActionLabel } from './finding-action-label.js';
 import { matchesFindingFilterCriteria, singleStageId } from './finding-filter-predicate.js';
-import { buildRecommendationRollup, isEligible, isRealFinding, rankFindings,                  } from './recommendation-rollup.js';
+import { buildRecommendationRollup, isEligible, isRealFinding, rankFindings, resourceGroupTotal,                  } from './recommendation-rollup.js';
 import { checkCoverage, isCleanRun } from './check-coverage.js';
 import { buildRunVerdict, stepCopyRecommendation, stepCopyText,                      } from './run-verdict.js';
 import {
   estimateProvenance, impactEstimateFigure, impactFigure, rawWasteMeaning, savingsMeaning,
 } from './impact-format.js';
 import { computeRunShape,               } from './run-shape.js';
+import { extractWriteTargets,                         } from './write-targets.js';
 import { detectorInfoByType } from './detector-docs.js';
              
                                                                                                                      
-                  
+                               
                     
 
 export const EVIDENCE_SCHEMA_VERSION         = 5;
@@ -43,9 +44,11 @@ export const EVIDENCE_SCHEMA_VERSION         = 5;
                                                                                         
                                                                                             
                                                           
-                                                                                                  
-                                                                                                 
-                                                              
+                                                                                       
+                             
+                                                                                    
+                                                                                           
+                   
                       
                                                                        
                                   
@@ -165,6 +168,8 @@ export const EVIDENCE_SCHEMA_VERSION         = 5;
                                                     
                      
                          
+                                                                                              
+                                   
                                        
                                  
                                    
@@ -244,6 +249,7 @@ function findingRow(f         )             {
     recommendation: f.recommendation ?? null,
     detectorVersion: f.detectorVersion ?? 1,
     evidence: projectEvidence(f),
+    remediation: f.remediation ?? [],
     actionLabel: findingActionLabel(f),
   }              ;
   // Threshold/confidence provenance, only when the detector emitted it.
@@ -311,15 +317,14 @@ function buildRecommendations(
       };
     }
     if (group.kind === 'resource') {
-      const text = formatRawWaste({ value: group.total, unit: group.unit });
-      const shown = readsAsZero(text) ? null : text;
+      const shown = resourceGroupTotal(group);
       return {
         ...base,
         kind: 'resource',
         unit: group.unit,
         total: group.total,
         impact: shown,
-        impactMeaning: shown ? rawWasteMeaning(group.unit) : null,
+        impactMeaning: shown ? rawWasteMeaning(representative.impactEstimate?.rawWaste) : null,
       };
     }
     return {
@@ -495,6 +500,9 @@ function buildJson(
     // Order follows DETECTORS (stable) => byte-stable serialization.
     detectors: tunedDetectorCatalog(thresholds),
     findings: rows,
+    writeTargets: extractWriteTargets(sql ?? new Map(), {
+      skippedLines: appModel.skippedLines, unreadableSqlExecutions: appModel.unreadableSqlExecutions,
+    }),
     recommendations,
     cleanChecks,
     notRunChecks,
@@ -581,7 +589,7 @@ function renderVerdict(verdict             )           {
       lines.push(`${i + 1}. [${step.tag}] ${step.text}`);
       if (step.relatedTypes.length > 0) {
         const related = step.relatedTypes.map(findingName).join(', ');
-        lines.push(`   - Also flagged here: ${related}. These often share this cause, so the same fix may clear them too.`);
+        lines.push(`   - Also flagged here, likely the same cause: ${related}.`);
       }
     });
     if (verdict.remainingPlaces > 0) {

package/vendor-core/finding-generic-recommendation.js

@@ -1,5 +1,6 @@
 import { presentationOf } from './finding-presentation.js';
-                                          
+import { pathBasename } from './format-utils.js';
+                                                     
 
 /** A generic, type-level recommendation sentence for a finding: the shape of the fix, with no
  * instance data (numbers, stage ids, host names, file counts, config values), from its type's
@@ -12,3 +13,21 @@ import { presentationOf } from './finding-presentation.js';
 export function coreFindingGenericRecommendation(finding         )                     {
   return presentationOf(finding.type)?.genericRecommendation(finding);
 }
+
+/** What a duplicatePlanSubtree finding measured, for the detector's recommendation and the
+ * Redundant Plan Subtree row, which shows it beside the fix its card states once. */
+export function duplicateSubtreeDetail(f                                                                                          )         {
+  const touching = f.sampleRelation ? ` (touching ${f.sampleRelation})` : '';
+  return `A ${f.subtreeSize}-node subtree rooted at ${pathBasename(f.rootName)} repeats ${f.value}x in this plan${touching}`;
+}
+
+export const DUPLICATE_SUBTREE_DIFFERING_NOTE = 'Their filters, columns or scanned tables differ, so the repeats may compute different data.';
+
+/** Reader-facing names for slowHost's per-executor dimensions, for the detector's recommendation
+ * and the Slow Executor Host row. */
+export const SLOW_HOST_DIMENSION_LABEL                                                                  = {
+  taskTime: 'task time',
+  inputBytes: 'input read',
+  shuffleBytes: 'shuffle read and write',
+  storageMemory: 'storage memory',
+};

package/vendor-core/finding-names.js

@@ -25,3 +25,10 @@ export function recommendationText(finding         )         {
   if (text) return text;
   return findingName(finding.type);
 }
+
+/** A recommendation's two halves: detectors write "<measurement>: <fix>", split at the last ": "
+ * since a measurement can quote an error with colons. Text with no split has no `measured`. */
+export function recommendationParts(text        )                                           {
+  const at = text.lastIndexOf(': ');
+  return at > 0 ? { measured: text.slice(0, at), fix: text.slice(at + 2) } : { measured: null, fix: text };
+}