sparkforensics-mcp 0.2.2 → 0.2.4

package/vendor-core/parser-worker.js

@@ -2,9 +2,10 @@ import { Gunzip } from './vendor/fflate.js';
 import { createLz4BlockDecoder } from './lz4-block.js';
 import { Decompress as ZstdDecompress } from './vendor/fzstd.js';
 import { createSnappyBlockDecoder } from './snappy-block.js';
-import { createState, dispatchLine, buildChunkDecoder, emitParseCompletion,                  } from './event-handlers.js';
+import { createState, dispatchLine, buildChunkDecoder, emitParseCompletion,                                   } from './event-handlers.js';
 import { TASK_FIELD_NAMES } from './stage-quantiles.js';
 import { runParseFromUrl, sniffCodec } from './shs-fetch.js';
+import { createWorkerZstdDecoders } from './zstd-worker-client.js';
 
 export {
   buildChunkDecoder, createState, normalizeSparkProperties, parseSparkMemoryMB, extractResources,
@@ -34,7 +35,9 @@ const MIN_PROGRESS_STEPS = 100;
 const PROGRESS_EMIT_LINES = 300;
 
                                      
-                                                     
+// zstdDecoder replaces the vendored fzstd for zstd input; the Node CLI/MCP path passes
+// cli/native-zstd.ts's native-zlib decoder, which a browser bundle can't import.
+                                                                                       
 
 // Minimal shape streamFile/runParse/runParseFiles read off `file` (name, size,
 // slice(start,end).arrayBuffer()): narrower than the full DOM `File`. A real
@@ -59,6 +62,12 @@ const PROGRESS_EMIT_LINES = 300;
 // without touching the vendored files (mirrors shs-fetch.ts's shim).
                                                                            
                                                                                            
+// A Node decoder, or the browser's decompress worker (zstd-worker-client.ts), may decompress off
+// the calling thread: streamFile awaits each push, and calls cancel() when it abandons the stream.
+                                                                            
+                                                                 
+                  
+  
 
 // Stream one File's (possibly compressed) bytes through the codec dispatch,
 // in `chunkSize` slices, invoking `onChunk` with each decompressed buffer as
@@ -69,6 +78,7 @@ export async function streamFile(
   file            ,
   onChunk                                           ,
   chunkSize        ,
+  zstdDecoder                     ,
 )                {
   const header = new Uint8Array(await file.slice(0, Math.min(8, file.size)).arrayBuffer());
   const codec = sniffCodec(header);
@@ -81,7 +91,10 @@ export async function streamFile(
   let currentPct = 0;
   const gunzip = codec === 'gz' ? new (Gunzip                                   )((inflated) => onChunk(inflated, currentPct)) : null;
   const lz4 = codec === 'lz4' ? createLz4BlockDecoder((inflated) => onChunk(inflated, currentPct)) : null;
-  const zstd = codec === 'zstd' ? new (ZstdDecompress                                   )((inflated) => onChunk(inflated, currentPct)) : null;
+  const onZstdChunk = (inflated            ) => onChunk(inflated, currentPct);
+  const zstd                                        = codec !== 'zstd' ? null
+    : zstdDecoder ? zstdDecoder(onZstdChunk)
+      : new (ZstdDecompress                                   )(onZstdChunk);
   const snappy = codec === 'snappy' ? createSnappyBlockDecoder((inflated) => onChunk(inflated, currentPct)) : null;
 
   // A fixed read size gives too few progress checkpoints on smaller files
@@ -91,17 +104,22 @@ export async function streamFile(
   const stepSize = Math.max(1, Math.min(chunkSize, Math.ceil(file.size / MIN_PROGRESS_STEPS)));
 
   let offset = 0;
-  while (offset < file.size) {
-    const start = offset;
-    const slice = new Uint8Array(await file.slice(start, start + stepSize).arrayBuffer());
-    offset += stepSize;
-    const final = offset >= file.size;
-    currentPct = start / file.size;
-    if (gunzip) gunzip.push(slice, final);
-    else if (lz4) lz4.push(slice);
-    else if (zstd) zstd.push(slice, final);
-    else if (snappy) snappy.push(slice);
-    else onChunk(slice, currentPct);
+  try {
+    while (offset < file.size) {
+      const start = offset;
+      const slice = new Uint8Array(await file.slice(start, start + stepSize).arrayBuffer());
+      offset += stepSize;
+      const final = offset >= file.size;
+      currentPct = start / file.size;
+      if (gunzip) gunzip.push(slice, final);
+      else if (lz4) lz4.push(slice);
+      else if (zstd) await zstd.push(slice, final);
+      else if (snappy) snappy.push(slice);
+      else onChunk(slice, currentPct);
+    }
+  } catch (e) {
+    zstd?.cancel?.();
+    throw e;
   }
   if (lz4) lz4.end();
   if (snappy) snappy.end();
@@ -115,7 +133,7 @@ export async function streamFile(
 export async function runParse(
   file            ,
   state             ,
-  { emit = (msg         ) => self.postMessage(msg), chunkSize = CHUNK_SIZE }          = {},
+  { emit = (msg         ) => self.postMessage(msg), chunkSize = CHUNK_SIZE, zstdDecoder }          = {},
 )                {
   if (file.size === 0) {
     emit({ type: 'error', message: 'File is empty.' });
@@ -123,10 +141,13 @@ export async function runParse(
   }
 
   const decoder = buildChunkDecoder();
+  const joined               = [];
   let linesProcessed = 0;
   const feed = (bytes            , pct         ) => {
-    for (const line of decoder.decode(bytes)) {
-      dispatchLine(line, state, emit);
+    joined.length = 0;
+    const lines = decoder.decode(bytes, joined);
+    for (let i = 0, j = 0; i < lines.length; i++) {
+      dispatchLine(lines[i], state, emit, joined[j]?.index === i ? joined[j++] : undefined);
       linesProcessed++;
       if (linesProcessed % PROGRESS_EMIT_LINES === 0) {
         emit({ type: 'progress', pct: pct ?? null, linesProcessed });
@@ -135,7 +156,7 @@ export async function runParse(
   };
 
   try {
-    await streamFile(file, feed, chunkSize);
+    await streamFile(file, feed, chunkSize, zstdDecoder);
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
     emit({ type: 'error', message: `Could not decompress "${file.name}": ${message}` });
@@ -163,7 +184,7 @@ export async function runParse(
 export async function runParseFiles(
   files              ,
   state             ,
-  { emit = (msg         ) => self.postMessage(msg), chunkSize = CHUNK_SIZE }          = {},
+  { emit = (msg         ) => self.postMessage(msg), chunkSize = CHUNK_SIZE, zstdDecoder }          = {},
 )                {
   if (files.length === 0) {
     emit({ type: 'error', message: 'Rolling event-log directory contained no event files.' });
@@ -171,13 +192,16 @@ export async function runParseFiles(
   }
 
   const decoder = buildChunkDecoder();
+  const joined               = [];
   let linesProcessed = 0;
   const totalSize = files.reduce((sum, f) => sum + f.size, 0);
   let bytesBeforeCurrentFile = 0;
   let currentFileSize = 0;
   const feed = (bytes            , pct         ) => {
-    for (const line of decoder.decode(bytes)) {
-      dispatchLine(line, state, emit);
+    joined.length = 0;
+    const lines = decoder.decode(bytes, joined);
+    for (let i = 0, j = 0; i < lines.length; i++) {
+      dispatchLine(lines[i], state, emit, joined[j]?.index === i ? joined[j++] : undefined);
       linesProcessed++;
       if (linesProcessed % PROGRESS_EMIT_LINES === 0) {
         const overallPct = totalSize > 0 ? (bytesBeforeCurrentFile + (pct ?? 0) * currentFileSize) / totalSize : null;
@@ -189,7 +213,7 @@ export async function runParseFiles(
   for (const file of files) {
     currentFileSize = file.size;
     try {
-      await streamFile(file, feed, chunkSize);
+      await streamFile(file, feed, chunkSize, zstdDecoder);
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
       emit({ type: 'error', message: `Could not decompress "${file.name}": ${message}` });
@@ -216,17 +240,25 @@ const isWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof Wor
 
 if (isWorker) {
   let workerState                     = null;
+  // Dropped zstd files decompress in a second worker, overlapping with parsing here. The
+  // `new Worker(new URL(...))` stays inline for Vite's worker detection (see ingest.ts). The SHS
+  // path (runParseFromUrl) decodes whole zip entries synchronously and keeps in-thread fzstd.
+  const zstdDecoder = createWorkerZstdDecoders(
+    () => new Worker(new URL('./zstd-worker.js', import.meta.url), { type: 'module' }),
+    (onChunk) => new (ZstdDecompress                                   )(onChunk),
+    { onFallback: (reason) => console.warn(`zstd: decompressing on the parse worker: ${reason}`) },
+  );
 
   self.onmessage = async ({ data }                                     ) => {
     if (data.type === 'parse') {
       workerState = createState();
-      await runParse(data.file, workerState);
+      await runParse(data.file, workerState, { zstdDecoder });
     } else if (data.type === 'parseFromUrl') {
       workerState = createState();
       await runParseFromUrl(data.request, workerState);
     } else if (data.type === 'parseFiles') {
       workerState = createState();
-      await runParseFiles(data.files, workerState);
+      await runParseFiles(data.files, workerState, { zstdDecoder });
     } else if (data.type === 'getTaskData') {
       const { stageId, reqId } = data;
       const stored = workerState?.taskStore.get(stageId) ?? new Float64Array(0);

package/vendor-core/plan-summary.js

@@ -45,7 +45,7 @@ function pushLongFilterWarning(result             , len        )       {
 }
 
 // Stable relation-identity key for a scan node: "<format>:<relation>" (e.g.
-// "delta:mx.t_emp_whitelist", "parquet:business_prd.sales", "jdbc:dw.d_producto")
+// "delta:mx.store_map", "parquet:warehouse.sales", "jdbc:dw.dim_product")
 // or null when the node is internal Delta metadata / a non-scan / un-nameable.
 // The single source of truth for scan identity, shared by `visitScan` (summary)
 // and the `cachingOpportunity` detector so the regexes live in one place.
@@ -55,6 +55,10 @@ export function scanRelationId(name        , detail        )                {
   //    Delta tables). All catalog tables surface as `spark_catalog.<db>.<table>`.
   let format = null, table = null;
   const nameM = name.match(/^Scan\s+(parquet|orc|csv|json)\s+(spark_catalog\.\S+)$/i);
+  // Fast reject: every branch below that returns a key needs this name match, a FileScan
+  // detail or a JDBCRelation detail. Most plan nodes (Project, Filter, joins) have none, and
+  // their long details otherwise pay every regex below.
+  if (!nameM && !/FileScan/i.test(detail) && !detail.includes('JDBCRelation')) return null;
   if (nameM) { format = nameM[1].toLowerCase(); table = nameM[2]; }
   else {
     const detM = detail.match(/FileScan\s+(parquet|orc|csv|json)\s+(spark_catalog\.[^[\s]+)\[/i);

package/vendor-core/run-comparison.js

@@ -1,5 +1,6 @@
 import { computeWallClock } from './wall-clock.js';
 import { normalizeDetail } from './detectors.js';
+import { cyrb53 } from './string-hash.js';
 import { captureSnapshot } from './session-snapshot.js';
                                                                                    
                                                              
@@ -35,21 +36,6 @@ export function normalizeStageName(name        )         {
     .trim();
 }
 
-// cyrb53: fast, non-cryptographic, deterministic 53-bit string hash. Not a
-// security boundary; 53 bits keeps collision risk negligible at the per-node,
-// per-stage call volume planTreeIdentity/sqlNodeIdentity put through it.
-function cyrb53(str        , seed = 0)         {
-  let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
-  for (let i = 0; i < str.length; i++) {
-    const ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
-}
-
 // Bottom-up, order-independent structural identity of a resolved plan tree:
 // each node folds its normalized name/detail with its children's digests
 // (children sorted, so AQE picking a different broadcast side still matches),

package/vendor-core/shs-fetch.js

@@ -3,7 +3,7 @@ import { createLz4BlockDecoder } from './lz4-block.js';
 import { Decompress as ZstdDecompress } from './vendor/fzstd.js';
 import { createSnappyBlockDecoder } from './snappy-block.js';
 import { buildProxyRequestUrl, isShsErrorCode } from './shs-request.js';
-import { dispatchLine, buildChunkDecoder, emitParseCompletion,                  } from './event-handlers.js';
+import { dispatchLine, buildChunkDecoder, emitParseCompletion,                                   } from './event-handlers.js';
 import { ShsProxyErrorBodySchema } from './shs-schemas.js';
 import { naturalCompare, reassembleRollingEntries } from './rolling-log-reassembly.js';
 
@@ -36,8 +36,14 @@ export function sniffCodec(bytes            )
 // without touching the vendored files.
                                                                            
                                                                                            
+// Like parser-worker.ts's RunOpts.zstdDecoder, but synchronous: decodeEntry never awaits push(),
+// so its result is typed `undefined` (not `void`, which would also accept an async decoder's
+// Promise). Node callers pass cli/native-zstd.ts's createNativeZstdDecoder (nodeArchiveCodecs).
+                                                                                                                            
 
-function decodeEntry(name        , raw            , onChunk                             )       {
+function decodeEntry(
+  name        , raw            , onChunk                             , zstdDecoder                     ,
+)       {
   const codec = sniffCodec(raw);
   if (codec === 'lz4' || name.endsWith('.lz4')) {
     const lz4 = createLz4BlockDecoder(onChunk);
@@ -46,7 +52,7 @@ function decodeEntry(name        , raw            , onChunk
   } else if (codec === 'gz' || name.endsWith('.gz')) {
     new (Gunzip                                   )(onChunk).push(raw, true);
   } else if (codec === 'zstd' || name.endsWith('.zstd') || name.endsWith('.zst')) {
-    new (ZstdDecompress                                   )(onChunk).push(raw, true);
+    (zstdDecoder ? zstdDecoder(onChunk) : new (ZstdDecompress                                   )(onChunk)).push(raw, true);
   } else if (codec === 'snappy' || name.endsWith('.snappy')) {
     const snappy = createSnappyBlockDecoder(onChunk);
     snappy.push(raw);
@@ -138,7 +144,9 @@ export async function runParseFromUrl(
   decodeShsArchive(zipBytes, state, emit);
 }
 
-export function decodeShsArchive(zipBytes            , state             , emit        )       {
+export function decodeShsArchive(
+  zipBytes            , state             , emit        , { zstdDecoder }                                       = {},
+)       {
   let entries                            ;
   try {
     entries = unzipSync(zipBytes);
@@ -165,18 +173,21 @@ export function decodeShsArchive(zipBytes            , state             , emit
   }
 
   const decoder = buildChunkDecoder();
+  const joined               = [];
   let linesProcessed = 0;
   for (const name of names) {
     try {
       decodeEntry(name, entries[name], (bytes) => {
-        for (const line of decoder.decode(bytes)) {
-          dispatchLine(line, state, emit);
+        joined.length = 0;
+        const lines = decoder.decode(bytes, joined);
+        for (let i = 0, j = 0; i < lines.length; i++) {
+          dispatchLine(lines[i], state, emit, joined[j]?.index === i ? joined[j++] : undefined);
           linesProcessed++;
           if (linesProcessed % 2000 === 0) {
             emit({ type: 'progress', pct: null, linesProcessed });
           }
         }
-      });
+      }, zstdDecoder);
     } catch {
       emitShsError(emit, 'invalid-event-log');
       return;

package/vendor-core/shs-load.js

@@ -2,6 +2,7 @@ import { validateShsRequest } from './shs-request.js';
 import { fetchShsEventLog } from './proxy.js';
 import { decodeShsArchive } from './parser-worker.js';
 import { collectViaDispatch } from './cli/collect-run.js';
+import { nodeArchiveCodecs } from './cli/native-zstd.js';
 import { deriveEvidenceAvailability } from './evidence-availability.js';
 import { mcpError } from './mcp-error.js';
                                            
@@ -18,7 +19,7 @@ export const DEFAULT_IDLE_TIMEOUT_MS = envInt('SPARKFORENSICS_SHS_TIMEOUT_MS', 3
 
 function collectShsAppModel(zipBytes            )                                                        {
   return collectViaDispatch(
-    (state, emit) => decodeShsArchive(zipBytes, state, emit),
+    (state, emit) => decodeShsArchive(zipBytes, state, emit, nodeArchiveCodecs),
     (msg) => {
       const m = msg                                       ;
       return mcpError(m?.code ?? 'invalid-event-log', m?.message ?? 'Failed to decode SHS archive.');

package/vendor-core/stage-quantiles.js

@@ -135,16 +135,26 @@ export function finalizeStage(
   const { p50: spillMemP50, p95: spillMemP95, max: spillMemMax } = computeFieldQuantiles(arr, FIELDS.MEM_SPILLED);
   const { p50: spillDiskP50, p95: spillDiskP95, max: spillDiskMax } = computeFieldQuantiles(arr, FIELDS.DISK_SPILLED);
 
-  // Straggler count: tasks with duration > 4 * P50.
+  // Straggler count: tasks with duration > 4 * P50, their summed excess over P50, and the longest
+  // task that isn't one.
   const stragglerThreshold = 4 * p50;
   let stragglerCount = 0;
+  let stragglerExcessMs = 0;
+  let longestNonStragglerMs = 0;
   const taskArrCount = arr.length / FIELDS.STRIDE;
   if (p50 > 0) {
     for (let i = 0; i < taskArrCount; i++) {
-      if (arr[i * FIELDS.STRIDE + FIELDS.DURATION] > stragglerThreshold) stragglerCount++;
+      const duration = arr[i * FIELDS.STRIDE + FIELDS.DURATION];
+      if (duration > stragglerThreshold) { stragglerCount++; stragglerExcessMs += duration - p50; }
+      else if (duration > longestNonStragglerMs) longestNonStragglerMs = duration;
     }
   }
 
+  const peakConcurrentTasks = computePeakConcurrentTasks(arr);
+  const tailReplayRecoveryMs = stragglerCount > 0
+    ? computeTailReplayRecoveryMs(arr, p50, peakConcurrentTasks)
+    : 0; // no task over 4x P50: both replays schedule the same durations
+
   const hostStatsArr = [...hostStats.entries()].map(
     ([host, s]) => ({ host, taskCount: s.taskCount, totalDuration: s.totalDuration })
   );
@@ -160,9 +170,12 @@ export function finalizeStage(
 
   const data                          = {
     ...stage,
-    hostStats: hostStatsArr, executorStats: executorStatsArr, failureReasons: failureReasonsArr, localityStats: localityStatsArr, stragglerCount,
+    hostStats: hostStatsArr, executorStats: executorStatsArr, failureReasons: failureReasonsArr, localityStats: localityStatsArr, stragglerCount, stragglerExcessMs, longestNonStragglerMs,
+    tailReplayRecoveryMs,
     failedTaskSamples,
     peakExecutionMemoryMax,
+    taskActiveMs: computeTaskActiveMs(arr),
+    peakConcurrentTasks,
     taskDurationP50: p50,
     taskDurationP95: p95,
     taskDurationMax: max,
@@ -178,6 +191,101 @@ export function finalizeStage(
   return { type: 'stage', data };
 }
 
+// Wall-clock time during which at least one of the stage's tasks was running: the union of its
+// [launch, finish) intervals. A stage's submittedAt..completedAt window also covers time it sat
+// open with no task running (waiting for a free slot, or between retried tasks), which no
+// task-level fix can compress. Tasks missing either timestamp are skipped.
+export function computeTaskActiveMs(arr              )         {
+  const taskCount = arr.length / FIELDS.STRIDE;
+  const intervals                     = [];
+  for (let i = 0; i < taskCount; i++) {
+    const launch = arr[i * FIELDS.STRIDE + FIELDS.LAUNCH_TIME];
+    const finish = arr[i * FIELDS.STRIDE + FIELDS.FINISH_TIME];
+    if (launch > 0 && finish > launch) intervals.push([launch, finish]);
+  }
+  intervals.sort((a, b) => a[0] - b[0]);
+  let activeMs = 0, start = -Infinity, end = -Infinity;
+  for (const [launch, finish] of intervals) {
+    if (launch > end) {
+      if (end > start) activeMs += end - start;
+      start = launch;
+      end = finish;
+    } else if (finish > end) {
+      end = finish;
+    }
+  }
+  if (end > start) activeMs += end - start;
+  return activeMs;
+}
+
+// Most tasks running at once, over the same [launch, finish) intervals as computeTaskActiveMs: the
+// slots the stage actually got. A task finishing at the instant another launches frees its slot.
+export function computePeakConcurrentTasks(arr              )         {
+  const taskCount = arr.length / FIELDS.STRIDE;
+  const launches           = [];
+  const finishes           = [];
+  for (let i = 0; i < taskCount; i++) {
+    const launch = arr[i * FIELDS.STRIDE + FIELDS.LAUNCH_TIME];
+    const finish = arr[i * FIELDS.STRIDE + FIELDS.FINISH_TIME];
+    if (launch > 0 && finish > launch) { launches.push(launch); finishes.push(finish); }
+  }
+  launches.sort((a, b) => a - b);
+  finishes.sort((a, b) => a - b);
+  let peak = 0, running = 0, finished = 0;
+  for (const launch of launches) {
+    while (finished < finishes.length && finishes[finished] <= launch) { running--; finished++; }
+    running++;
+    if (running > peak) peak = running;
+  }
+  return peak;
+}
+
+// Wall-clock a tail fix recovers, replayed from the stage's own tasks: list scheduling (tasks in
+// launch order, each on the slot that frees first) over `slots` slots, once with the real
+// durations and once with every task over 4x P50 (the straggler definition above) capped at P50.
+// The difference is the claim; dev/eval-tail-replay.mjs keeps an independent copy as its ground
+// truth. Equal free times are interchangeable slots, so which one a min-heap picks can't change
+// the result. Equal launch times keep the task array's order.
+export function computeTailReplayRecoveryMs(arr              , p50        , slots        )         {
+  const taskCount = arr.length / FIELDS.STRIDE;
+  if (taskCount < 2 || !(p50 > 0)) return 0;
+  const order = new Uint32Array(taskCount);
+  for (let i = 0; i < taskCount; i++) order[i] = i;
+  order.sort((a, b) => arr[a * FIELDS.STRIDE + FIELDS.LAUNCH_TIME] - arr[b * FIELDS.STRIDE + FIELDS.LAUNCH_TIME] || a - b);
+  const free = new Float64Array(Math.max(1, Math.min(slots, taskCount)));
+  const capAboveMs = 4 * p50;
+  const actualEndMs = listScheduleEndMs(arr, order, free, Infinity, p50);
+  const fixedEndMs = listScheduleEndMs(arr, order, free, capAboveMs, p50);
+  return Math.max(0, actualEndMs - fixedEndMs);
+}
+
+// End of a list schedule over `free` (a min-heap of slot free times, reset here), each task's
+// duration replaced by `cappedMs` when over `capAboveMs`.
+function listScheduleEndMs(
+  arr              , order             , free              , capAboveMs        , cappedMs        ,
+)         {
+  free.fill(0);
+  const n = free.length;
+  let endMs = 0;
+  for (let t = 0; t < order.length; t++) {
+    const duration = arr[order[t] * FIELDS.STRIDE + FIELDS.DURATION];
+    const finish = free[0] + (duration > capAboveMs ? cappedMs : duration);
+    if (finish > endMs) endMs = finish;
+    // Replace the root (earliest free slot) and sift it down.
+    let i = 0;
+    for (;;) {
+      const left = 2 * i + 1;
+      if (left >= n) break;
+      const child = left + 1 < n && free[left + 1] < free[left] ? left + 1 : left;
+      if (free[child] >= finish) break;
+      free[i] = free[child];
+      i = child;
+    }
+    free[i] = finish;
+  }
+  return endMs;
+}
+
 export function computeFieldQuantiles(arr              , fieldIndex        )                                            {
   const taskCount = arr.length / FIELDS.STRIDE;
   if (taskCount === 0) return { p50: 0, p95: 0, max: 0 };

package/vendor-core/string-hash.js

@@ -0,0 +1,15 @@
+// cyrb53: fast, non-cryptographic, deterministic 53-bit string hash. Not a
+// security boundary; 53 bits keeps collision risk negligible at the per-node
+// call volume the plan-identity digests (run-comparison.ts, detectors.ts) put
+// through it.
+export function cyrb53(str        , seed = 0)         {
+  let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
+}

package/vendor-core/types.js

@@ -77,11 +77,25 @@
                                                            
                      
                            
+                                                                                            
+                           
                  
                            
                            
                            
                                   
+                                                                                      
+                                                                           
+                        
+                                                                                        
+                             
+                                                                                         
+                                 
+                                                                                                  
+                                                                     
+                                
+                                                                                            
+                               
                                                         
                    
                          
@@ -107,7 +121,6 @@
                                
              
                              
-