shap-svg 0.2.4 → 0.3.0

package/dist/{chunk-UVIVTJK3.js → chunk-JQBQSWIU.js}

@@ -221,6 +221,10 @@ function parseExplanation(input, opts = {}) {
     nFeatures
   };
 }
+function sampleDisplayName(parsed, sampleIndex, words) {
+  var _a, _b;
+  return (_b = (_a = parsed.sampleLabels) == null ? void 0 : _a[sampleIndex]) != null ? _b : words.sampleFallback(sampleIndex + 1);
+}
 
 // src/core/order.ts
 function globalImportance(e) {
@@ -238,6 +242,9 @@ function orderFeatures(importance) {
 var MINUS = "\u2212";
 var EXPONENT_THRESHOLD = 1e-3;
 var PERCENT_DECIMALS = 2;
+function formatFixed(v, decimals) {
+  return Math.abs(v).toFixed(decimals);
+}
 function formatShapValue(v, decimals) {
   if (v === 0) return "0";
   return (v < 0 ? MINUS : "+") + magnitudeOf(v, decimals);
@@ -275,7 +282,21 @@ var shapLabels = {
   sampleFallback: (sampleNumber) => `Sample ${sampleNumber}`,
   baseValue: "E[f(X)]",
   modelOutput: "f(x)",
-  otherFeatures: (count, style) => style === "sum" ? `Sum of ${count} other features` : `${count} other features`
+  higher: "higher",
+  lower: "lower",
+  otherFeatures: (count, style) => style === "sum" ? `Sum of ${count} other features` : `${count} other features`,
+  absent: "Absent",
+  absentWithCount: (count) => `Absent (n = ${count})`,
+  principalComponent: (index, varianceRatio) => `SHAP PC${index} (${formatFixed(varianceRatio * 100, 0)}% of SHAP variance)`,
+  cumulativeShapValue: "Model output",
+  clusterDistance: "Clustering cutoff",
+  interactionScore: (score) => `interaction ${formatFixed(score, 2)}`,
+  weakInteraction: "no strong interaction found",
+  trend: "Median trend",
+  tableCaption: "Chart data",
+  componentTracksTotal: (r) => `tracks \u03A3\u03C6, r = ${formatFixed(r, 2)}`,
+  colorScale: (what) => `Colour: ${what}`,
+  suppliedComponent: (index) => `Dimension ${index}`
 };
 function resolveLabels(labels) {
   if (!labels) return shapLabels;
@@ -319,6 +340,140 @@ function collapseToDisplay(featureNames, importance, order, maxDisplay, faithful
   return { rows, collapsedCount: collapsed.length };
 }
 
+// src/core/hclust.ts
+var MAX_DISTANCE = 1;
+function absCorrelation(a, b) {
+  const n = a.length;
+  let meanA = 0;
+  let meanB = 0;
+  for (let i = 0; i < n; i++) {
+    meanA += a[i];
+    meanB += b[i];
+  }
+  meanA /= n;
+  meanB /= n;
+  let cov = 0;
+  let varA = 0;
+  let varB = 0;
+  for (let i = 0; i < n; i++) {
+    const da = a[i] - meanA;
+    const db = b[i] - meanB;
+    cov += da * db;
+    varA += da * da;
+    varB += db * db;
+  }
+  if (!(varA > 0) || !(varB > 0)) return 0;
+  return Math.min(1, Math.abs(cov / Math.sqrt(varA * varB)));
+}
+function correlationDistances(columns) {
+  const k = columns.length;
+  const out = Array.from({ length: k }, () => new Array(k).fill(0));
+  for (let i = 0; i < k; i++) {
+    for (let j = i + 1; j < k; j++) {
+      const distance = MAX_DISTANCE - absCorrelation(columns[i], columns[j]);
+      out[i][j] = distance;
+      out[j][i] = distance;
+    }
+  }
+  return out;
+}
+function averageLinkage(distances) {
+  const k = distances.length;
+  if (k < 2) return [];
+  const members = /* @__PURE__ */ new Map();
+  for (let i = 0; i < k; i++) members.set(i, [i]);
+  const between = (a, b) => {
+    let sum = 0;
+    for (const i of a) for (const j of b) sum += distances[i][j];
+    return sum / (a.length * b.length);
+  };
+  const linkage = [];
+  for (let step = 0; step < k - 1; step++) {
+    const ids = [...members.keys()].sort((a, b) => a - b);
+    let bestLeft = ids[0];
+    let bestRight = ids[1];
+    let bestDistance = Infinity;
+    for (let a = 0; a < ids.length; a++) {
+      for (let b = a + 1; b < ids.length; b++) {
+        const d = between(members.get(ids[a]), members.get(ids[b]));
+        if (d < bestDistance - 1e-12) {
+          bestDistance = d;
+          bestLeft = ids[a];
+          bestRight = ids[b];
+        }
+      }
+    }
+    const merged = [...members.get(bestLeft), ...members.get(bestRight)];
+    members.delete(bestLeft);
+    members.delete(bestRight);
+    members.set(k + step, merged);
+    linkage.push([bestLeft, bestRight, bestDistance, merged.length]);
+  }
+  return linkage;
+}
+function copheneticDistances(linkage) {
+  const k = linkage.length + 1;
+  const out = Array.from({ length: k }, () => new Array(k).fill(0));
+  const leaves = /* @__PURE__ */ new Map();
+  for (let i = 0; i < k; i++) leaves.set(i, [i]);
+  linkage.forEach((row, step) => {
+    const left = leaves.get(row[0]);
+    const right = leaves.get(row[1]);
+    for (const i of left) for (const j of right) {
+      out[i][j] = row[2];
+      out[j][i] = row[2];
+    }
+    leaves.set(k + step, [...left, ...right]);
+  });
+  return out;
+}
+function leafOrder(linkage, leafValues) {
+  var _a;
+  const k = linkage.length + 1;
+  if (k === 1) return [0];
+  const peak = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (let i = 0; i < k; i++) peak.set(i, (_a = leafValues[i]) != null ? _a : 0);
+  linkage.forEach((row, step) => {
+    var _a2, _b;
+    const id = k + step;
+    children.set(id, [row[0], row[1]]);
+    peak.set(id, Math.max((_a2 = peak.get(row[0])) != null ? _a2 : 0, (_b = peak.get(row[1])) != null ? _b : 0));
+  });
+  const out = [];
+  const walk = (id) => {
+    var _a2, _b;
+    const pair = children.get(id);
+    if (!pair) {
+      out.push(id);
+      return;
+    }
+    const [left, right] = pair;
+    const heavierFirst = ((_a2 = peak.get(left)) != null ? _a2 : 0) >= ((_b = peak.get(right)) != null ? _b : 0) ? [left, right] : [right, left];
+    walk(heavierFirst[0]);
+    walk(heavierFirst[1]);
+  };
+  walk(k + linkage.length - 1);
+  return out;
+}
+function relaxSortOrder(cophenetic, clusterOrder, cutoff, importanceOrder) {
+  const taken = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const index of importanceOrder) {
+    if (taken.has(index)) continue;
+    taken.add(index);
+    out.push(index);
+    for (const neighbour of clusterOrder) {
+      if (taken.has(neighbour)) continue;
+      if (cophenetic[index][neighbour] <= cutoff) {
+        taken.add(neighbour);
+        out.push(neighbour);
+      }
+    }
+  }
+  return out;
+}
+
 // src/core/ticks.ts
 var MINUS2 = "\u2212";
 var PX_TO_PT = 0.75;
@@ -375,6 +530,41 @@ function tickLabel(value, step, percent = false) {
 // src/core/barLayout.ts
 var POSITIVE_COLOR = "#ff0051";
 var NEGATIVE_COLOR = "#008bfb";
+var CLUSTERING_POOL = 50;
+function clusteredOrder(input) {
+  const { parsed, importanceOrder, mode, cutoff } = input;
+  const poolSize = Array.isArray(mode) ? mode.length + 1 : CLUSTERING_POOL;
+  const pool = importanceOrder.slice(0, Math.min(poolSize, importanceOrder.length));
+  let linkage;
+  if (Array.isArray(mode)) {
+    for (const row of mode) {
+      if (row.length !== 4) {
+        throw new RangeError("a clustering matrix must have rows of width 4");
+      }
+    }
+    linkage = mode;
+  } else {
+    const source = mode === "shap" ? parsed.values : parsed.data;
+    const columns = pool.map((j) => source.map((row) => row[j]));
+    linkage = averageLinkage(correlationDistances(columns));
+  }
+  if (linkage.length === 0) return { order: importanceOrder, linkage };
+  const importanceWithinPool = pool.map((_, position) => position);
+  const meanAbs = pool.map((j) => {
+    let sum = 0;
+    for (const row of parsed.values) sum += Math.abs(row[j]);
+    return sum / parsed.nSamples;
+  });
+  const clusterPositions = leafOrder(linkage, meanAbs);
+  const relaxed = relaxSortOrder(
+    copheneticDistances(linkage),
+    clusterPositions,
+    cutoff,
+    importanceWithinPool
+  );
+  const order = [...relaxed.map((position) => pool[position]), ...importanceOrder.slice(pool.length)];
+  return { order, linkage };
+}
 var BAR_THICKNESS_RATIO = 0.7;
 var AXIS_HEIGHT = 52;
 var TICK_LABEL_PT = 11;
@@ -1178,6 +1368,7 @@ function sampleColormap(name, t) {
   const blue = channel(lower, 5) + (channel(upper, 5) - channel(lower, 5)) * fraction;
   return `#${hexByte(red)}${hexByte(green)}${hexByte(blue)}`;
 }
+var UNCOLOURED = "#1f77b4";
 
 // src/core/colorBar.ts
 var ASPECT = 80;
@@ -1240,6 +1431,7 @@ function colorBarLayout(spec, position) {
       x: labelLeft + LABEL_PT * LABEL_BASELINE_EM,
       y: (y1 + y2) / 2,
       text: spec.label,
+      ...spec.labelParts ? { parts: spec.labelParts } : {},
       fontSize: LABEL_PT
     },
     right: Math.max(
@@ -1277,22 +1469,37 @@ function scalarFormatterLabels(locs) {
   });
   return order === 0 ? { labels } : { labels, offsetText: `1e${String(order).replace("-", MINUS3)}` };
 }
+function colorScaleTitleParts(title, taxon2) {
+  const at = title.indexOf(taxon2);
+  if (at < 0) return void 0;
+  return [
+    { text: title.slice(0, at) },
+    { text: taxon2, italic: true },
+    { text: title.slice(at + taxon2.length) }
+  ];
+}
 
 // src/core/tooltip.ts
-var CHAR_PX = 6.5;
+var GLYPH_PX = { body: 6.5, axis: 5.6 };
 var PADDING_X = 7;
 var OFFSET = 8;
 var RAISE = 24;
 function placeTooltip(opts) {
   const { anchorX, anchorY, lines, lineHeight, minWidth, chartWidth, chartHeight } = opts;
   const longest = lines.reduce((max, line) => Math.max(max, line.length), 0);
-  const width = Math.max(minWidth, longest * CHAR_PX + 2 * PADDING_X);
+  const width = Math.max(minWidth, longest * GLYPH_PX.body + 2 * PADDING_X);
   const height = lines.length * lineHeight + lineHeight * 0.6;
   const right = anchorX + OFFSET;
   const x = right + width <= chartWidth ? right : Math.max(0, anchorX - OFFSET - width);
   const y = Math.max(0, Math.min(anchorY - RAISE, chartHeight - height));
   return { x, y, width, height };
 }
+var runsToText = (runs) => runs.map((run) => run.text).join("");
+var namedValue = (name, value) => [
+  { text: name, italic: true },
+  { text: `: ${value}` }
+];
+var TOOLTIP_LINE_HEIGHT = 15;
 
 // src/core/beeswarmLayout.ts
 var BEESWARM_MISSING_COLOR = "#777777";
@@ -1741,6 +1948,686 @@ function heatmapLayout(valueRows, opts) {
   };
 }
 
+// src/core/stats.ts
+function pearson(a, b) {
+  const n = a.length;
+  if (n < 2) return 0;
+  let meanA = 0;
+  let meanB = 0;
+  for (let i = 0; i < n; i++) {
+    meanA += a[i];
+    meanB += b[i];
+  }
+  meanA /= n;
+  meanB /= n;
+  let cov = 0;
+  let varA = 0;
+  let varB = 0;
+  for (let i = 0; i < n; i++) {
+    const da = a[i] - meanA;
+    const db = b[i] - meanB;
+    cov += da * db;
+    varA += da * da;
+    varB += db * db;
+  }
+  if (!(varA > 0) || !(varB > 0)) return 0;
+  return cov / Math.sqrt(varA * varB);
+}
+
+// src/core/interactions.ts
+var MAX_WINDOW = 50;
+function interactionWindowSize(sampleCount) {
+  return Math.max(Math.min(Math.floor(sampleCount / 10), MAX_WINDOW), 1);
+}
+function eligibleInteractionFeature(column) {
+  return column.some((value) => Math.abs(value) >= 1e-8) && column.some((value) => value !== column[0]);
+}
+function interactionScores(featureIndex, values, data) {
+  var _a, _b;
+  const sampleCount = data.length;
+  const featureCount = (_b = (_a = data[0]) == null ? void 0 : _a.length) != null ? _b : 0;
+  const scores = new Array(featureCount).fill(0);
+  if (sampleCount < 2) return scores;
+  const order = Array.from({ length: sampleCount }, (_, i) => i).sort(
+    (a, b) => data[a][featureIndex] - data[b][featureIndex] || a - b
+  );
+  const sortedShap = order.map((i) => values[i][featureIndex]);
+  const window = interactionWindowSize(sampleCount);
+  const windowCount = Math.ceil(sampleCount / window);
+  for (let j = 0; j < featureCount; j++) {
+    if (j === featureIndex) continue;
+    const sortedOther = order.map((i) => data[i][j]);
+    if (!eligibleInteractionFeature(sortedOther)) continue;
+    let sum = 0;
+    for (let start = 0; start < sampleCount; start += window) {
+      const shapSlice = sortedShap.slice(start, start + window);
+      const otherSlice = sortedOther.slice(start, start + window);
+      sum += Math.abs(pearson(shapSlice, otherSlice));
+    }
+    scores[j] = sum / windowCount;
+  }
+  return scores;
+}
+function strongestInteraction(featureIndex, values, data) {
+  const scores = interactionScores(featureIndex, values, data);
+  let best = -1;
+  let bestScore = -1;
+  scores.forEach((score, index) => {
+    if (index === featureIndex) return;
+    const column = data.map((row) => row[index]);
+    if (eligibleInteractionFeature(column) && score > bestScore) {
+      bestScore = score;
+      best = index;
+    }
+  });
+  return best === -1 ? null : { index: best, score: bestScore };
+}
+
+// src/core/scatterLayout.ts
+var MIN_TREND_SAMPLES = 4;
+var FLAT_DOMAIN_FACTOR = 10;
+function scatterPoints(parsed, featureIndex) {
+  const absent = [];
+  const detected = [];
+  for (let i = 0; i < parsed.nSamples; i++) {
+    const point = {
+      sampleIndex: i,
+      value: parsed.data[i][featureIndex],
+      shap: parsed.values[i][featureIndex]
+    };
+    (point.value > 0 ? detected : absent).push(point);
+  }
+  detected.sort((a, b) => a.value - b.value || a.sampleIndex - b.sampleIndex);
+  return { absent, detected };
+}
+function logDomain(detected) {
+  if (detected.length === 0) return [1, 10];
+  const low = detected[0].value;
+  const high = detected[detected.length - 1].value;
+  if (low === high) return [low / FLAT_DOMAIN_FACTOR, high * FLAT_DOMAIN_FACTOR];
+  return [low, high];
+}
+function median(sorted) {
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+function binnedMedianTrend(detected) {
+  if (detected.length < MIN_TREND_SAMPLES) return [];
+  const window = interactionWindowSize(detected.length);
+  const out = [];
+  for (let start = 0; start < detected.length; start += window) {
+    const slice = detected.slice(start, start + window);
+    if (slice.length === 0) continue;
+    out.push({
+      value: median(slice.map((p) => p.value)),
+      shap: median([...slice.map((p) => p.shap)].sort((a, b) => a - b))
+    });
+  }
+  return out;
+}
+var MARGIN = { right: 24, top: 16, bottom: 56 };
+var ABSENT_BAND = 56;
+var ABSENT_GAP = 40;
+var DOT_RADIUS = 4;
+var TICK_LABEL_PT6 = 11;
+var Y_TITLE_X = 14;
+var sampleName = (parsed, sampleIndex, words) => sampleDisplayName(parsed, sampleIndex, words);
+function scatterTooltipLines(parsed, sampleIndex, featureIndex, colorFeatureIndex, words) {
+  const abundance = (index) => {
+    const value = parsed.data[sampleIndex][index];
+    return namedValue(
+      formatFeatureLabel(parsed.featureNames[index]),
+      value > 0 ? formatLevel(value) : words.absent
+    );
+  };
+  const lines = [
+    [{ text: sampleName(parsed, sampleIndex, words) }],
+    abundance(featureIndex)
+  ];
+  if (colorFeatureIndex !== null) lines.push(abundance(colorFeatureIndex));
+  lines.push([
+    {
+      text: `${words.shapValue}: ${formatShapValue(parsed.values[sampleIndex][featureIndex])}`
+    }
+  ]);
+  return lines;
+}
+function wrapToWidth(text, maxWidth) {
+  const words = text.split(" ");
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    const candidate = line ? `${line} ${word}` : word;
+    if (line && candidate.length * GLYPH_PX.axis > maxWidth) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = candidate;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+function scatterGeometry(input) {
+  var _a;
+  const {
+    parsed,
+    featureIndex,
+    width,
+    height,
+    colorFeature,
+    colorFeatureMinScore,
+    colorBar = true,
+    xScale,
+    trend,
+    colormap = "red_blue"
+  } = input;
+  const words = (_a = input.labels) != null ? _a : resolveLabels();
+  const { absent, detected } = scatterPoints(parsed, featureIndex);
+  const shapValues = parsed.values.map((row) => row[featureIndex]);
+  const shapMin = Math.min(0, ...shapValues);
+  const shapMax = Math.max(0, ...shapValues);
+  const domainMin = shapMin === shapMax ? shapMin - 1 : shapMin;
+  const domainMax = shapMin === shapMax ? shapMax + 1 : shapMax;
+  const plotTop = MARGIN.top;
+  const plotBottom = height - MARGIN.bottom;
+  const initialYTicks = niceTicks(
+    domainMin,
+    domainMax,
+    tickSpace(plotBottom - plotTop, TICK_LABEL_PT6)
+  );
+  const yStep = initialYTicks.step || 1;
+  const yMin = Math.floor(domainMin / yStep) * yStep;
+  const yMax = Math.ceil(domainMax / yStep) * yStep;
+  const yTickValues = niceTicks(
+    yMin,
+    yMax,
+    tickSpace(plotBottom - plotTop, TICK_LABEL_PT6)
+  ).ticks;
+  const yTickLabel = (value) => {
+    const normalized = Number(tickLabel(value, yStep).replace("\u2212", "-"));
+    return formatShapValue(value !== 0 && normalized === 0 ? value : normalized);
+  };
+  const widestYTick = Math.max(...yTickValues.map((value) => yTickLabel(value).length), 1) * GLYPH_PX.body;
+  const plotLeft = Math.max(70, Y_TITLE_X + 13 + 8 + widestYTick + 8);
+  const plotRight = width - (colorBar ? 90 : MARGIN.right);
+  const detectedLeft = absent.length > 0 ? plotLeft + ABSENT_BAND + ABSENT_GAP : plotLeft;
+  const shapSpan = yMax - yMin || 1;
+  const toY = (shap) => plotBottom - (shap - yMin) / shapSpan * (plotBottom - plotTop);
+  const yTicks = yTickValues.map((value) => ({ value, y: toY(value), label: yTickLabel(value) }));
+  const [lowValue, highValue] = logDomain(detected);
+  const useLog = xScale === "log" && lowValue > 0;
+  const scaleOf = (v) => useLog ? Math.log10(v) : v;
+  const lowScaled = scaleOf(lowValue);
+  const highScaled = scaleOf(highValue);
+  const scaledSpan = highScaled - lowScaled || 1;
+  const toX = (v) => detectedLeft + (scaleOf(v) - lowScaled) / scaledSpan * (plotRight - detectedLeft);
+  let colorFeatureIndex = null;
+  let colorNote = "";
+  let byOutput = false;
+  if (colorFeature === "auto") {
+    const best = strongestInteraction(featureIndex, parsed.values, parsed.data);
+    if (best && best.score >= colorFeatureMinScore) {
+      colorFeatureIndex = best.index;
+      colorNote = words.interactionScore(best.score);
+    } else {
+      colorNote = words.weakInteraction;
+    }
+  } else if (colorFeature === "output") {
+    byOutput = true;
+  } else if (typeof colorFeature === "number" && colorFeature !== featureIndex) {
+    colorFeatureIndex = colorFeature;
+  }
+  const outputs = parsed.values.map(
+    (row, i) => parsed.baseValues[i] + row.reduce((sum, value) => sum + value, 0)
+  );
+  let colorLow = 0;
+  let colorHigh = 1;
+  const clipTo = (column) => {
+    const sorted = [...column].sort((a, b) => a - b);
+    const at = (q) => sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))];
+    colorLow = at(0.05);
+    colorHigh = at(0.95);
+    if (colorLow === colorHigh) {
+      colorLow = sorted[0];
+      colorHigh = sorted[sorted.length - 1];
+    }
+  };
+  if (colorFeatureIndex !== null) {
+    clipTo(parsed.data.map((row) => row[colorFeatureIndex]));
+  } else if (byOutput) {
+    clipTo(outputs);
+  }
+  const colorOf = (sampleIndex) => {
+    if (colorFeatureIndex === null && !byOutput) return UNCOLOURED;
+    const value = byOutput ? outputs[sampleIndex] : parsed.data[sampleIndex][colorFeatureIndex];
+    const t = colorHigh === colorLow ? 0.5 : (value - colorLow) / (colorHigh - colorLow);
+    return sampleColormap(colormap, t);
+  };
+  const colorFeatureLabel = colorFeatureIndex === null ? null : formatFeatureLabel(parsed.featureNames[colorFeatureIndex]);
+  const scaleSubject = colorFeatureLabel ? `${colorFeatureLabel} \xB7 ${words.featureValue}${colorNote ? ` (${colorNote})` : ""}` : words.modelOutput;
+  const scaleParts = colorFeatureLabel ? colorScaleTitleParts(words.colorScale(scaleSubject), colorFeatureLabel) : void 0;
+  const colorBarGeometry = colorFeatureIndex === null && !byOutput || !colorBar ? null : colorBarLayout({
+    colormap,
+    tickLabels: byOutput ? [formatLevel(colorLow), formatLevel(colorHigh)] : [words.featureValueLow, words.featureValueHigh],
+    label: words.colorScale(scaleSubject),
+    ...scaleParts ? { labelParts: scaleParts } : {},
+    labelPad: 0
+  }, { x: plotRight + 18, y1: plotTop, y2: plotBottom });
+  const absentCenter = plotLeft + ABSENT_BAND / 2;
+  const absentPoints = absent.map((p, i) => ({
+    // Spread the band's points so identical SHAP values do not stack invisibly.
+    cx: absentCenter + (i % 5 - 2) * (DOT_RADIUS + 1),
+    cy: toY(p.shap),
+    color: colorOf(p.sampleIndex),
+    sampleIndex: p.sampleIndex
+  }));
+  const detectedPoints = detected.map((p) => ({
+    cx: toX(p.value),
+    cy: toY(p.shap),
+    color: colorOf(p.sampleIndex),
+    sampleIndex: p.sampleIndex
+  }));
+  const trendPoints = trend ? binnedMedianTrend(detected) : [];
+  const trendPath = trendPoints.length >= 2 ? trendPoints.map((p, i) => `${i === 0 ? "M" : "L"}${toX(p.value)},${toY(p.shap)}`).join(" ") : null;
+  const absentMeanY = absent.length > 0 ? toY(absent.reduce((sum, p) => sum + p.shap, 0) / absent.length) : null;
+  const { ticks, step } = niceTicks(
+    lowScaled,
+    highScaled,
+    tickSpace(plotRight - detectedLeft, TICK_LABEL_PT6)
+  );
+  const xTicks = ticks.map((t) => ({
+    x: detectedLeft + (t - lowScaled) / scaledSpan * (plotRight - detectedLeft),
+    label: useLog ? formatLevel(10 ** t) : tickLabel(t, step)
+  }));
+  return {
+    absentPoints,
+    detectedPoints,
+    absentLabelLines: absent.length > 0 ? wrapToWidth(words.absentWithCount(absent.length), ABSENT_BAND + ABSENT_GAP - 4) : [],
+    absentMeanY,
+    zeroRuleY: toY(0),
+    trendPath,
+    colorFeatureIndex,
+    colorFeatureLabel,
+    colorNote,
+    colorBar: colorBarGeometry,
+    xTicks,
+    yTicks,
+    plotLeft,
+    plotRight,
+    plotTop,
+    plotBottom,
+    xTitle: {
+      unit: words.featureValue,
+      text: formatFeatureLabel(parsed.featureNames[featureIndex]),
+      x: (plotLeft + plotRight) / 2,
+      y: plotBottom + AXIS_TITLE_DY
+    },
+    yTitle: words.shapValue,
+    yTitleX: Y_TITLE_X
+  };
+}
+
+// src/core/pca.ts
+var DEFAULT_ITERATIONS = 200;
+var EPSILON = 1e-12;
+function centerColumns(values) {
+  var _a, _b;
+  const rows = values.length;
+  const cols = (_b = (_a = values[0]) == null ? void 0 : _a.length) != null ? _b : 0;
+  const means = new Array(cols).fill(0);
+  for (const row of values) for (let j = 0; j < cols; j++) means[j] += row[j];
+  for (let j = 0; j < cols; j++) means[j] /= rows;
+  return values.map((row) => row.map((v, j) => v - means[j]));
+}
+function leadingComponent(m, iterations) {
+  var _a, _b;
+  const cols = (_b = (_a = m[0]) == null ? void 0 : _a.length) != null ? _b : 0;
+  let v = Array.from({ length: cols }, (_, j) => 1 / (j + 1));
+  normalise(v);
+  for (let step = 0; step < iterations; step++) {
+    const w = m.map((row) => {
+      let sum = 0;
+      for (let j = 0; j < cols; j++) sum += row[j] * v[j];
+      return sum;
+    });
+    const next = new Array(cols).fill(0);
+    m.forEach((row, i) => {
+      const weight = w[i];
+      for (let j = 0; j < cols; j++) next[j] += row[j] * weight;
+    });
+    if (!normalise(next)) return new Array(cols).fill(0);
+    v = next;
+  }
+  return v;
+}
+function normalise(v) {
+  let norm = 0;
+  for (const x of v) norm += x * x;
+  norm = Math.sqrt(norm);
+  if (!(norm > EPSILON)) return false;
+  for (let j = 0; j < v.length; j++) v[j] /= norm;
+  return true;
+}
+function fixSign(component) {
+  let peak = 0;
+  for (const x of component) if (Math.abs(x) > Math.abs(peak)) peak = x;
+  if (peak < 0) for (let j = 0; j < component.length; j++) component[j] = -component[j];
+}
+function project(m, component) {
+  return m.map((row) => {
+    let sum = 0;
+    for (let j = 0; j < row.length; j++) sum += row[j] * component[j];
+    return sum;
+  });
+}
+function shapPca(values, iterations = DEFAULT_ITERATIONS) {
+  if (values.length === 0) return { coords: [], varianceRatios: [0, 0] };
+  const centered = centerColumns(values);
+  let total = 0;
+  for (const row of centered) for (const v of row) total += v * v;
+  const first = leadingComponent(centered, iterations);
+  fixSign(first);
+  const xs = project(centered, first);
+  const residual = centered.map(
+    (row, i) => row.map((v, j) => v - xs[i] * first[j])
+  );
+  const second = leadingComponent(residual, iterations);
+  fixSign(second);
+  const ys = project(residual, second);
+  const energy = (projected) => projected.reduce((sum, v) => sum + v * v, 0);
+  const ratio = (projected) => total > EPSILON ? energy(projected) / total : 0;
+  return {
+    coords: xs.map((x, i) => [x, ys[i]]),
+    varianceRatios: [ratio(xs), ratio(ys)]
+  };
+}
+
+// src/core/embeddingLayout.ts
+var MARGIN2 = { left: 64, right: 24, top: 20, bottom: 52 };
+var COLOR_BAR_MARGIN = 96;
+var MEANING_MIN_R = 0.7;
+function embeddingLayout(input) {
+  var _a;
+  const { parsed, width, height, colorBy, coords, colormap = "red_blue", colorBar = true } = input;
+  const words = (_a = input.labels) != null ? _a : resolveLabels();
+  if (coords && coords.length !== parsed.nSamples) {
+    throw new RangeError(
+      `coords must hold one position per Sample: expected ${parsed.nSamples}, received ${coords.length}`
+    );
+  }
+  const projection = coords ? null : shapPca(parsed.values);
+  const positions = coords != null ? coords : projection.coords;
+  const plotLeft = MARGIN2.left;
+  const showColorBar = colorBar && colorBy !== "none";
+  const plotRight = width - (showColorBar ? COLOR_BAR_MARGIN : MARGIN2.right);
+  const plotTop = MARGIN2.top;
+  const plotBottom = height - MARGIN2.bottom;
+  const axisRange = (axis) => {
+    const all = positions.map((p) => p[axis]);
+    const low = Math.min(...all);
+    const high = Math.max(...all);
+    return low === high ? [low - 1, high + 1] : [low, high];
+  };
+  const [xLow, xHigh] = axisRange(0);
+  const [yLow, yHigh] = axisRange(1);
+  const toX = (v) => plotLeft + (v - xLow) / (xHigh - xLow) * (plotRight - plotLeft);
+  const toY = (v) => plotBottom - (v - yLow) / (yHigh - yLow) * (plotBottom - plotTop);
+  const colourValues = colorBy === "none" ? null : parsed.values.map(
+    (row) => colorBy === "sum" ? row.reduce((sum, v) => sum + v, 0) : row[colorBy]
+  );
+  const colourLow = colourValues ? Math.min(...colourValues) : 0;
+  const colourHigh = colourValues ? Math.max(...colourValues) : 1;
+  const points = positions.map((position, i) => ({
+    cx: toX(position[0]),
+    cy: toY(position[1]),
+    coordinates: position,
+    sampleIndex: i,
+    color: colourValues ? sampleColormap(
+      colormap,
+      colourHigh === colourLow ? 0.5 : (colourValues[i] - colourLow) / (colourHigh - colourLow)
+    ) : UNCOLOURED
+  }));
+  const title = (index) => projection ? words.principalComponent(index, projection.varianceRatios[index - 1]) : words.suppliedComponent(index);
+  const colouredTaxon = typeof colorBy === "number" ? formatFeatureLabel(parsed.featureNames[colorBy]) : null;
+  const colourLabel = colorBy === "sum" ? words.sampleTotal : colouredTaxon ? `${colouredTaxon} \xB7 ${words.shapValue}` : "";
+  const colourParts = colouredTaxon ? colorScaleTitleParts(words.colorScale(colourLabel), colouredTaxon) : void 0;
+  const inside = (value, low, high) => value > low && value < high;
+  const totals = parsed.values.map((row) => row.reduce((sum, value) => sum + value, 0));
+  const meaningOf = (axis) => {
+    const r = pearson(positions.map((position) => position[axis]), totals);
+    return Math.abs(r) >= MEANING_MIN_R ? words.componentTracksTotal(r) : null;
+  };
+  return {
+    points,
+    xMeaning: meaningOf(0),
+    yMeaning: meaningOf(1),
+    zeroX: inside(0, xLow, xHigh) ? toX(0) : null,
+    zeroY: inside(0, yLow, yHigh) ? toY(0) : null,
+    xTitle: title(1),
+    yTitle: title(2),
+    plotLeft,
+    plotRight,
+    plotTop,
+    plotBottom,
+    colorBar: showColorBar && colourValues ? colorBarLayout(
+      {
+        colormap,
+        // The actual range, not "Low" and "High": these are signed
+        // SHAP values and their sign is the thing worth reading.
+        tickLabels: [formatShapValue(colourLow), formatShapValue(colourHigh)],
+        label: words.colorScale(colourLabel),
+        ...colourParts ? { labelParts: colourParts } : {},
+        labelPad: 0
+      },
+      { x: plotRight + 18, y1: plotTop, y2: plotBottom }
+    ) : null
+  };
+}
+
+// src/core/decisionLayout.ts
+var AXIS_HEIGHT5 = 52;
+var MARGIN3 = { left: 220, right: 40, top: 16 };
+var X_MARGIN3 = 0.02;
+var MAX_OPACITY = 0.9;
+var MIN_OPACITY = 0.08;
+var OPACITY_FLOOR_AT = 400;
+function decisionLayout(input) {
+  var _a;
+  const { parsed, width, rowHeight, maxDisplay, colormap = "red_blue" } = input;
+  const indices = (_a = input.sampleIndices) != null ? _a : parsed.values.map((_, i) => i);
+  const descending = orderFeatures(globalImportance(parsed));
+  const shown = descending.slice(0, Math.min(maxDisplay, descending.length));
+  const hidden = descending.slice(shown.length);
+  const bottomUp = [...shown].reverse();
+  const paths = indices.map((sampleIndex) => {
+    const row = parsed.values[sampleIndex];
+    const hiddenSum = hidden.reduce((sum, j) => sum + row[j], 0);
+    const values = [parsed.baseValues[sampleIndex] + hiddenSum];
+    for (const j of bottomUp) values.push(values[values.length - 1] + row[j]);
+    return { sampleIndex, values };
+  });
+  const base = indices.length === 0 ? 0 : indices.reduce((sum, sampleIndex) => sum + parsed.baseValues[sampleIndex], 0) / indices.length;
+  let reach = 0;
+  for (const path of paths) {
+    for (const value of path.values) reach = Math.max(reach, Math.abs(value - base));
+  }
+  reach = reach || 1;
+  const pad = reach * 2 * X_MARGIN3;
+  const xDomain = [base - reach - pad, base + reach + pad];
+  const plotLeft = MARGIN3.left;
+  const plotRight = width - MARGIN3.right;
+  const plotTop = MARGIN3.top;
+  const plotBottom = plotTop + bottomUp.length * rowHeight;
+  const toX = (v) => plotLeft + (v - xDomain[0]) / (xDomain[1] - xDomain[0]) * (plotRight - plotLeft);
+  const toY = (step) => plotBottom - step * rowHeight;
+  const pathOpacity = MIN_OPACITY + (MAX_OPACITY - MIN_OPACITY) * Math.max(0, 1 - Math.max(0, indices.length - 1) / OPACITY_FLOOR_AT);
+  return {
+    rowLabels: bottomUp.map((j) => parsed.featureNames[j]),
+    rowY: bottomUp.map((_, i) => plotBottom - i * rowHeight - rowHeight / 2),
+    paths: paths.map(({ sampleIndex, values }) => {
+      const end = values[values.length - 1];
+      const t = (end - xDomain[0]) / (xDomain[1] - xDomain[0]);
+      return {
+        sampleIndex,
+        values,
+        points: values.map((value, step) => ({ x: toX(value), y: toY(step) })),
+        color: sampleColormap(colormap, t)
+      };
+    }),
+    pathOpacity,
+    xDomain,
+    baseValue: base,
+    baseValueX: toX(base),
+    plotLeft,
+    plotRight,
+    plotTop,
+    plotBottom,
+    height: plotBottom + AXIS_HEIGHT5
+  };
+}
+
+// src/core/forceLayout.ts
+var MIN_LABEL_SHARE = 0.05;
+var MARGIN4 = { left: 16, right: 16 };
+function forceLayout(input) {
+  var _a;
+  const { parsed, sampleIndex, width, height, maxDisplay, faithfulOtherRow = false } = input;
+  const words = (_a = input.labels) != null ? _a : resolveLabels();
+  const row = parsed.values[sampleIndex];
+  const baseValue = parsed.baseValues[sampleIndex];
+  const modelOutput = row.reduce((sum, v) => sum + v, 0) + baseValue;
+  const magnitudes = row.map((v) => Math.abs(v));
+  const order = magnitudes.map((value, index) => ({ value, index })).sort((a, b) => b.value - a.value || a.index - b.index).map((entry) => entry.index);
+  const display = collapseToDisplay(
+    parsed.featureNames,
+    row,
+    order,
+    maxDisplay,
+    faithfulOtherRow,
+    words
+  );
+  const totalEffect = display.rows.reduce((sum, r) => sum + Math.abs(r.value), 0) || 1;
+  const usable = Math.max(0, width - MARGIN4.left - MARGIN4.right);
+  const scale = usable / totalEffect;
+  const positives = display.rows.filter((r) => r.value > 0).sort((a, b) => b.value - a.value);
+  const negatives = display.rows.filter((r) => r.value <= 0).sort((a, b) => a.value - b.value);
+  const positiveTotal = positives.reduce((sum, r) => sum + Math.abs(r.value), 0);
+  const meetingX = MARGIN4.left + positiveTotal * scale;
+  const barHeight = Math.max(12, height - 48);
+  const barY = 24;
+  const segments = [];
+  let cursor = meetingX;
+  for (const r of positives) {
+    const segmentWidth = Math.abs(r.value) * scale;
+    cursor -= segmentWidth;
+    segments.push({
+      label: r.label,
+      featureIndex: r.featureIndex,
+      isOtherRow: r.isOtherRow,
+      value: r.value,
+      x: cursor,
+      width: segmentWidth,
+      color: POSITIVE_COLOR,
+      labelled: Math.abs(r.value) / totalEffect >= MIN_LABEL_SHARE
+    });
+  }
+  cursor = meetingX;
+  for (const r of negatives) {
+    const segmentWidth = Math.abs(r.value) * scale;
+    segments.push({
+      label: r.label,
+      featureIndex: r.featureIndex,
+      isOtherRow: r.isOtherRow,
+      value: r.value,
+      x: cursor,
+      width: segmentWidth,
+      color: NEGATIVE_COLOR,
+      labelled: Math.abs(r.value) / totalEffect >= MIN_LABEL_SHARE
+    });
+    cursor += segmentWidth;
+  }
+  const outputSpan = modelOutput - baseValue;
+  return {
+    segments,
+    baseValue,
+    modelOutput,
+    meetingX,
+    baseValueX: meetingX - outputSpan * scale,
+    barY,
+    barHeight
+  };
+}
+
+// src/core/tableRows.ts
+var taxon = (name) => ({ text: formatFeatureLabel(name), italic: true });
+function scatterTableRows(parsed, featureIndex, split, words) {
+  const featureName = taxon(parsed.featureNames[featureIndex]);
+  const rows = [...split.absent, ...split.detected].sort((a, b) => a.sampleIndex - b.sampleIndex).map((point) => [
+    sampleDisplayName(parsed, point.sampleIndex, words),
+    point.value > 0 ? formatLevel(point.value) : words.absent,
+    formatShapValue(point.shap)
+  ]);
+  return {
+    caption: words.tableCaption,
+    columns: ["Sample", featureName, words.shapValue],
+    rows
+  };
+}
+function embeddingTableRows(layout, parsed, words) {
+  return {
+    caption: words.tableCaption,
+    columns: ["Sample", layout.xTitle, layout.yTitle],
+    rows: layout.points.map((point) => [
+      sampleDisplayName(parsed, point.sampleIndex, words),
+      formatLevel(point.coordinates[0]),
+      formatLevel(point.coordinates[1])
+    ])
+  };
+}
+function decisionTableRows(layout, parsed, words) {
+  return {
+    caption: words.tableCaption,
+    columns: ["Sample", words.baseValue, ...layout.rowLabels.map(taxon)],
+    rows: layout.paths.map((path) => [
+      sampleDisplayName(parsed, path.sampleIndex, words),
+      ...path.values.map((value) => formatLevel(value))
+    ])
+  };
+}
+function forceTableRows(layout, words) {
+  return {
+    caption: words.tableCaption,
+    columns: ["Feature", words.shapValue],
+    rows: layout.segments.map((segment) => [
+      // The Other features row is a count, not a taxon, so it stays upright.
+      segment.isOtherRow ? segment.label : taxon(segment.label),
+      formatShapValue(segment.value)
+    ])
+  };
+}
+
+// src/core/dendrogram.ts
+function dendrogramCoords(leafPositions, linkage) {
+  if (linkage.length === 0) return [];
+  const leafCount = leafPositions.length;
+  const out = [];
+  const walk = (node) => {
+    if (node < leafCount) return [leafPositions[node], 0];
+    const row = linkage[node - leafCount];
+    const [leftX, leftY] = walk(row[0]);
+    const [rightX, rightY] = walk(row[1]);
+    const height = row[2];
+    out.push({
+      xs: [leftX, leftX, rightX, rightX],
+      ys: [leftY, height, height, rightY]
+    });
+    return [(leftX + rightX) / 2, height];
+  };
+  walk(leafCount + linkage.length - 1);
+  return out;
+}
+
 export {
   UnsupportedContractVersionError,
   InvalidExplanationError,
@@ -1750,18 +2637,27 @@ export {
   groupExplanationByGenus,
   sortDisplayRows,
   parseExplanation,
+  sampleDisplayName,
   globalImportance,
   orderFeatures,
+  formatFixed,
   formatShapValue,
   formatLevel,
   formatFeatureLabel,
   shapLabels,
   resolveLabels,
   collapseToDisplay,
+  correlationDistances,
+  averageLinkage,
+  copheneticDistances,
+  leafOrder,
+  relaxSortOrder,
   TICK_LENGTH,
   TICK_LABEL_DY,
   POSITIVE_COLOR,
   NEGATIVE_COLOR,
+  CLUSTERING_POOL,
+  clusteredOrder,
   barLayout,
   WATERFALL_HEAD_LENGTH_PX,
   WATERFALL_TICK_LABEL_DY,
@@ -1769,16 +2665,42 @@ export {
   waterfallRows,
   waterfallLayout,
   sampleColormap,
+  UNCOLOURED,
   colorBarExtent,
   fitColorBar,
   colorBarLayout,
   scalarFormatterLabels,
+  colorScaleTitleParts,
+  GLYPH_PX,
   placeTooltip,
+  runsToText,
+  namedValue,
+  TOOLTIP_LINE_HEIGHT,
   BEESWARM_MISSING_COLOR,
   BEESWARM_ROW_HEIGHT,
   beeswarmRows,
   beeswarmLayout,
   heatmapRows,
-  heatmapLayout
+  heatmapLayout,
+  interactionWindowSize,
+  interactionScores,
+  strongestInteraction,
+  scatterPoints,
+  logDomain,
+  binnedMedianTrend,
+  ABSENT_BAND,
+  DOT_RADIUS,
+  scatterTooltipLines,
+  wrapToWidth,
+  scatterGeometry,
+  shapPca,
+  embeddingLayout,
+  decisionLayout,
+  forceLayout,
+  scatterTableRows,
+  embeddingTableRows,
+  decisionTableRows,
+  forceTableRows,
+  dendrogramCoords
 };
-//# sourceMappingURL=chunk-UVIVTJK3.js.map
+//# sourceMappingURL=chunk-JQBQSWIU.js.map