@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/statistics/VolcanoPlot.js

@@ -0,0 +1,196 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { StatMath } from "./StatMath.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+// src/charts/statistics/VolcanoPlot.ts
+/** Multiple-testing correction applied to p-values. */
+var PValueAdjustment = /* @__PURE__ */ function(PValueAdjustment) {
+	PValueAdjustment["None"] = "raw-p";
+	PValueAdjustment["BenjaminiHochberg"] = "fdr";
+	PValueAdjustment["Bonferroni"] = "bonferroni";
+	return PValueAdjustment;
+}({});
+/** Shape of the significance boundary. */
+var VolcanoCutoff = /* @__PURE__ */ function(VolcanoCutoff) {
+	VolcanoCutoff["Rectangular"] = "rectangular";
+	VolcanoCutoff["Hyperbolic"] = "hyperbolic";
+	VolcanoCutoff["None"] = "no-cutoff";
+	return VolcanoCutoff;
+}({});
+/** Differential results at a glance: effect size against significance, with the interesting hits in the upper corners. */
+var VolcanoPlot = class extends StatisticalChart {
+	static meta = {
+		id: "volcano-plot",
+		name: "Volcano plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots effect size against significance so strong, reliable changes stand out among thousands of tests.",
+		tags: [
+			"genomics",
+			"differential expression",
+			"multiple testing",
+			"p-value"
+		],
+		sample: (seed) => SampleData.points(seed, 360, 3).map((row, i) => {
+			const effect = (+row.y - +row.x * .8 - 10) / 9 * .9;
+			return {
+				gene: `G${String(i + 1).padStart(3, "0")}`,
+				log2fc: +effect.toFixed(3),
+				pvalue: StatMath.twoSided(effect * (+row.size / 7)),
+				mean: row.size
+			};
+		}),
+		variants: {
+			adjustment: Object.values(PValueAdjustment),
+			cutoff: Object.values(VolcanoCutoff),
+			scale: [ScaleKind.Linear, ScaleKind.Sqrt],
+			sized: [false, true],
+			labels: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			effect: "log2fc",
+			pvalue: "pvalue",
+			label: "gene",
+			size: "mean",
+			adjustment: "fdr",
+			cutoff: "rectangular",
+			scale: ScaleKind.Linear,
+			sized: false,
+			labels: true,
+			alpha: .05,
+			threshold: 1
+		};
+	}
+	yTicks() {
+		return this.options.scale === ScaleKind.Sqrt ? 4 : super.yTicks();
+	}
+	axisTitles() {
+		return {
+			x: "Effect (log2 fold change)",
+			y: `-log10 ${{
+				["raw-p"]: "p",
+				["fdr"]: "FDR",
+				["bonferroni"]: "adj. p"
+			}[this.options.adjustment]}`
+		};
+	}
+	points() {
+		const { data, effect, pvalue, label, size, adjustment, cutoff, alpha, threshold } = this.options;
+		const rows = this.complete(data, effect, pvalue).filter((row) => +row[pvalue] >= 0);
+		const raw = rows.map((row) => +row[pvalue]);
+		const adjusted = adjustment === "fdr" ? StatMath.benjaminiHochberg(raw) : adjustment === "bonferroni" ? raw.map((p) => Math.min(1, p * raw.length)) : raw;
+		const floor = -Math.log10(alpha);
+		return rows.map((row, index) => {
+			const value = +row[effect], height = -Math.log10(Math.max(1e-300, adjusted[index]));
+			const inside = cutoff === "hyperbolic" ? Math.abs(value) > threshold / 2 && height > floor + .9 / (Math.abs(value) - threshold / 2) : height > floor && Math.abs(value) > threshold;
+			return {
+				index,
+				name: String(row[label] ?? index + 1),
+				effect: value,
+				p: adjusted[index],
+				height,
+				size: this.number(row[size]) ?? 0,
+				hit: inside ? value > 0 ? 1 : -1 : 0
+			};
+		});
+	}
+	scales(ctx) {
+		const { scale, threshold, alpha } = this.options;
+		const points = this.points();
+		const reach = Math.max(threshold * 1.4, ...points.map((d) => Math.abs(d.effect))) * 1.06;
+		const top = Math.max(-Math.log10(alpha) * 1.5, ...points.map((d) => d.height)) * 1.06;
+		const y = Scales.continuous(scale).domain([0, top]).range([ctx.plot.height, 0]);
+		return {
+			x: this.linear([-reach, reach], [0, ctx.plot.width]),
+			y
+		};
+	}
+	legendItems() {
+		if (!this.options.data?.length) return [];
+		return [
+			{
+				key: "Down",
+				color: this.palette.diverging(-1)
+			},
+			{
+				key: "Up",
+				color: this.palette.diverging(1)
+			},
+			{
+				key: "Not significant",
+				color: this.theme.inkMuted
+			}
+		];
+	}
+	plotMarks(ctx, axes) {
+		const { cutoff, sized, labels, alpha, threshold } = this.options;
+		const points = this.points().sort((a, b) => Math.abs(a.hit) - Math.abs(b.hit));
+		const [left, right] = axes.x.domain(), top = axes.y.domain()[1];
+		const floor = -Math.log10(alpha);
+		const dash = "5 4";
+		this.rules(ctx, "cutoffs", cutoff === "rectangular" ? [
+			{
+				key: "p",
+				from: [left, floor],
+				to: [right, floor],
+				dash
+			},
+			{
+				key: "low",
+				from: [-threshold, 0],
+				to: [-threshold, top],
+				dash
+			},
+			{
+				key: "high",
+				from: [threshold, 0],
+				to: [threshold, top],
+				dash
+			}
+		] : [], axes);
+		const branch = (sign) => Array.from({ length: 30 }, (_, i) => {
+			const x = threshold / 2 + .9 / (top - floor) + i / 29 * (right - threshold / 2 - .9 / (top - floor));
+			return [sign * x, Math.min(top, floor + .9 / (x - threshold / 2))];
+		});
+		this.traces(ctx, "hyperbola", cutoff === "hyperbolic" ? [{
+			key: "Lower cutoff",
+			color: ctx.theme.inkMuted,
+			dash,
+			width: 1.5,
+			points: branch(-1)
+		}, {
+			key: "Upper cutoff",
+			color: ctx.theme.inkMuted,
+			dash,
+			width: 1.5,
+			points: branch(1)
+		}] : [], axes);
+		const color = (d) => d.hit ? ctx.palette.diverging(d.hit) : ctx.theme.inkMuted;
+		const largest = Math.max(1e-9, ...points.map((d) => d.size));
+		const radius = (d) => sized ? Math.max(1.5, 6.5 * Math.sqrt(Math.max(0, d.size) / largest)) : d.hit ? 4 : 2.5;
+		this.dots(ctx, "points", points, (d) => [axes.x(d.effect), axes.y(d.height)], color, (d) => ({
+			title: d.name,
+			color: color(d),
+			rows: [["Effect", +d.effect.toFixed(3)], ["Adjusted p", +d.p.toPrecision(3)]]
+		}), {
+			r: radius,
+			key: (d) => d.index,
+			ring: false,
+			opacity: .8
+		});
+		const best = labels ? points.filter((d) => d.hit).sort((a, b) => b.height - a.height).slice(0, 6) : [];
+		this.notes(ctx, "labels", best.map((d) => ({
+			key: `${d.index}`,
+			text: d.name,
+			x: axes.x(d.effect) + (d.hit > 0 ? -6 : 6),
+			y: axes.y(d.height) + 4,
+			anchor: d.hit > 0 ? "end" : "start",
+			tone: "ink"
+		})));
+	}
+};
+export { PValueAdjustment, VolcanoCutoff, VolcanoPlot };

package/dist/charts/statistics/index.js

@@ -0,0 +1,69 @@
+import { ProcessRules, ProcessRuleset } from "./ProcessRules.js";
+import { StatMath } from "./StatMath.js";
+import { StatisticalChart, textWidth } from "./StatisticalChart.js";
+import { ProcessChartBase } from "./ProcessChartBase.js";
+import { AttributeControlChart, AttributeLimits, AttributeStatistic } from "./AttributeControlChart.js";
+import { CorrelogramBase, CorrelogramMarks } from "./CorrelogramBase.js";
+import { AutocorrelationBand, AutocorrelationPlot } from "./AutocorrelationPlot.js";
+import { RegressionFit } from "./RegressionFit.js";
+import { AgreementDifference, AgreementLimits, AgreementReference, BlandAltmanPlot } from "./BlandAltmanPlot.js";
+import { ClassifierCurveBase } from "./ClassifierCurveBase.js";
+import { CalibrationBinning, CalibrationPlot, CalibrationUncertainty, PredictionDistribution } from "./CalibrationPlot.js";
+import { ControlChart, ControlStatistic } from "./ControlChart.js";
+import { CooksDistancePlot, InfluenceMarks, InfluenceMeasure, InfluenceOrder } from "./CooksDistancePlot.js";
+import { CrossCorrelationPlot } from "./CrossCorrelationPlot.js";
+import { CusumChart, CusumForm } from "./CusumChart.js";
+import { DetectionErrorCurve, ErrorAxisScale, ErrorCurveFit } from "./DetectionErrorCurve.js";
+import { EwmaChart, EwmaLimits } from "./EwmaChart.js";
+import { ForestOrder, ForestPlot } from "./ForestPlot.js";
+import { MetaAnalysis, PoolingModel } from "./MetaAnalysis.js";
+import { FunnelContours, FunnelPlot, FunnelPrecision } from "./FunnelPlot.js";
+import { InteractionEffect, InteractionError, InteractionPlot } from "./InteractionPlot.js";
+import { KaplanMeierCurve, SurvivalEstimator, SurvivalScale } from "./KaplanMeierCurve.js";
+import { LagPlot } from "./LagPlot.js";
+import { LiftChart, LiftMarks, LiftMetric } from "./LiftChart.js";
+import { LorenzCurve, LorenzForm, LorenzResolution } from "./LorenzCurve.js";
+import { ManhattanMarks, ManhattanPlot, ManhattanSpacing } from "./ManhattanPlot.js";
+import { PacfMethod, PartialAutocorrelation } from "./PartialAutocorrelation.js";
+import { PPMarks, PPPlot, PlottingPosition } from "./PPPlot.js";
+import { ReferenceDistribution, ReferenceLaw } from "./ReferenceLaw.js";
+import { PrecisionInterpolation, PrecisionRecallCurve } from "./PrecisionRecallCurve.js";
+import { QQEnvelope, QQPlot, QQReferenceLine } from "./QQPlot.js";
+import { InfluenceEncoding, RegressionInfluencePlot } from "./RegressionInfluencePlot.js";
+import { RegressionForm, ResidualHorizontal, ResidualPlot, ResidualScale } from "./ResidualPlot.js";
+import { ROCCurve, RocFill, RocOperatingPoint, RocSmoothing } from "./ROCCurve.js";
+import { ScreeMarks, ScreeMetric, ScreePlot, ScreeReference } from "./ScreePlot.js";
+import { SilhouetteDistance, SilhouetteMarks, SilhouetteOrder, SilhouettePlot } from "./SilhouettePlot.js";
+import { PValueAdjustment, VolcanoCutoff, VolcanoPlot } from "./VolcanoPlot.js";
+// src/charts/statistics/index.ts
+var statisticsCatalog = [
+	QQPlot,
+	PPPlot,
+	ROCCurve,
+	PrecisionRecallCurve,
+	DetectionErrorCurve,
+	LiftChart,
+	CalibrationPlot,
+	ResidualPlot,
+	RegressionInfluencePlot,
+	CooksDistancePlot,
+	BlandAltmanPlot,
+	FunnelPlot,
+	ForestPlot,
+	ControlChart,
+	AttributeControlChart,
+	CusumChart,
+	EwmaChart,
+	KaplanMeierCurve,
+	AutocorrelationPlot,
+	PartialAutocorrelation,
+	CrossCorrelationPlot,
+	LagPlot,
+	LorenzCurve,
+	VolcanoPlot,
+	ManhattanPlot,
+	InteractionPlot,
+	ScreePlot,
+	SilhouettePlot
+];
+export { AgreementDifference, AgreementLimits, AgreementReference, AttributeControlChart, AttributeLimits, AttributeStatistic, AutocorrelationBand, AutocorrelationPlot, BlandAltmanPlot, CalibrationBinning, CalibrationPlot, CalibrationUncertainty, ClassifierCurveBase, ControlChart, ControlStatistic, CooksDistancePlot, CorrelogramBase, CorrelogramMarks, CrossCorrelationPlot, CusumChart, CusumForm, DetectionErrorCurve, ErrorAxisScale, ErrorCurveFit, EwmaChart, EwmaLimits, ForestOrder, ForestPlot, FunnelContours, FunnelPlot, FunnelPrecision, InfluenceEncoding, InfluenceMarks, InfluenceMeasure, InfluenceOrder, InteractionEffect, InteractionError, InteractionPlot, KaplanMeierCurve, LagPlot, LiftChart, LiftMarks, LiftMetric, LorenzCurve, LorenzForm, LorenzResolution, ManhattanMarks, ManhattanPlot, ManhattanSpacing, MetaAnalysis, PPMarks, PPPlot, PValueAdjustment, PacfMethod, PartialAutocorrelation, PlottingPosition, PoolingModel, PrecisionInterpolation, PrecisionRecallCurve, PredictionDistribution, ProcessChartBase, ProcessRules, ProcessRuleset, QQEnvelope, QQPlot, QQReferenceLine, ROCCurve, ReferenceDistribution, ReferenceLaw, RegressionFit, RegressionForm, RegressionInfluencePlot, ResidualHorizontal, ResidualPlot, ResidualScale, RocFill, RocOperatingPoint, RocSmoothing, ScreeMarks, ScreeMetric, ScreePlot, ScreeReference, SilhouetteDistance, SilhouetteMarks, SilhouetteOrder, SilhouettePlot, StatMath, StatisticalChart, SurvivalEstimator, SurvivalScale, VolcanoCutoff, VolcanoPlot, statisticsCatalog, textWidth };

package/dist/charts/structure/DependencyMatrix.js

@@ -0,0 +1,302 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { DependencyOrdering } from "./DependencyOrdering.js";
+import { StructureText } from "./StructureText.js";
+import { DsmColumnLabel, DsmConvention, DsmMark, DsmOrder } from "./structureEnums.js";
+import { symbol, symbolCross } from "d3";
+// src/charts/structure/DependencyMatrix.ts
+var SYSTEMS = {
+	Alpha: ["Powertrain", [
+		"Battery",
+		"Inverter",
+		"Motor",
+		"Gearbox",
+		"Cooling"
+	]],
+	Bravo: ["Chassis", [
+		"Frame",
+		"Suspension",
+		"Steering",
+		"Brakes",
+		"Wheels"
+	]],
+	Charlie: ["Body", [
+		"Shell",
+		"Doors",
+		"Glazing",
+		"Seats",
+		"HVAC"
+	]],
+	Delta: ["Electronics", [
+		"ECU",
+		"Harness",
+		"Sensors",
+		"Display",
+		"Telematics"
+	]]
+};
+/** Design structure matrix: every element against every other, reordered so modules or coupled sets sit on the diagonal. */
+var DependencyMatrix = class DependencyMatrix extends Chart2D {
+	static meta = {
+		id: "dependency-structure-matrix",
+		name: "Dependency structure matrix",
+		family: ChartFamily.Matrix,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Square element-by-element matrix reordered to expose clusters on the diagonal and feedback across it.",
+		tags: [
+			"dsm",
+			"n-squared",
+			"modularity",
+			"partitioning"
+		],
+		sample: (seed) => DependencyMatrix.vehicle(seed),
+		variants: {
+			order: [
+				DsmOrder.Cluster,
+				DsmOrder.Partition,
+				DsmOrder.Given
+			],
+			convention: [DsmConvention.RowInputs, DsmConvention.ColumnInputs],
+			mark: [
+				DsmMark.Cell,
+				DsmMark.Dot,
+				DsmMark.Cross
+			],
+			blocks: [true, false],
+			columnLabel: [DsmColumnLabel.Index, DsmColumnLabel.Name]
+		},
+		valid: (values) => values.order !== DsmOrder.Given || values.blocks === true
+	};
+	/** A vehicle's subsystems: the sample graph's clusters become systems, and stronger links inside a system run both ways. */
+	static vehicle(seed) {
+		const first = SampleData.graph(seed, 20, 4), second = SampleData.graph(seed + 1, 20, 4);
+		const count = {};
+		const names = new Map(first.nodes.map((node) => {
+			const taken = count[node.group] = (count[node.group] ?? -1) + 1;
+			return [node.id, {
+				id: SYSTEMS[node.group][1][taken],
+				group: SYSTEMS[node.group][0]
+			}];
+		}));
+		const seen = /* @__PURE__ */ new Set();
+		const links = [...first.links, ...second.links].flatMap((link) => {
+			const forward = {
+				source: names.get(link.source).id,
+				target: names.get(link.target).id,
+				value: link.value
+			};
+			return link.value >= 6 && names.get(link.source).group === names.get(link.target).group ? [forward, {
+				source: forward.target,
+				target: forward.source,
+				value: Math.max(1, link.value - 4)
+			}] : [forward];
+		}).filter((link) => {
+			const key = `${link.source}>${link.target}`;
+			return !seen.has(key) && seen.add(key);
+		});
+		return {
+			nodes: first.nodes.map((node) => names.get(node.id)),
+			links
+		};
+	}
+	defaults() {
+		return {
+			order: DsmOrder.Cluster,
+			convention: DsmConvention.RowInputs,
+			mark: DsmMark.Cell,
+			blocks: true,
+			columnLabel: DsmColumnLabel.Index
+		};
+	}
+	plotMargin() {
+		return {
+			top: 6,
+			right: 12,
+			bottom: 8,
+			left: 12
+		};
+	}
+	legendItems() {
+		return [];
+	}
+	/** Elements in display order, with blocks from the chosen ordering. Unknown link ends join the matrix. */
+	arrange() {
+		const data = this.options.data ?? {
+			nodes: [],
+			links: []
+		};
+		const known = /* @__PURE__ */ new Map();
+		for (const node of data.nodes ?? []) if (node?.id !== null && node?.id !== void 0 && !known.has(String(node.id))) known.set(String(node.id), node);
+		for (const link of data.links ?? []) for (const end of [link.source, link.target]) if (end !== null && end !== void 0 && !known.has(String(end))) known.set(String(end), { id: String(end) });
+		const ids = [...known.keys()], at = new Map(ids.map((id, i) => [id, i]));
+		const weights = ids.map(() => new Array(ids.length).fill(0));
+		for (const link of data.links ?? []) {
+			const a = at.get(String(link.source)), b = at.get(String(link.target));
+			if (a === void 0 || b === void 0 || a === b) continue;
+			const value = Math.abs(+(link.value ?? 1));
+			weights[a][b] += Number.isFinite(value) && value > 0 ? value : 1;
+		}
+		const groups = this.options.order === DsmOrder.Given ? ids.map((_, i) => [i]) : this.options.order === DsmOrder.Partition ? DependencyOrdering.partition(weights) : DependencyOrdering.cluster(weights);
+		const elements = [];
+		const blocks = [];
+		groups.forEach((group) => {
+			const block = group.length > 1 ? blocks.length : null;
+			if (block !== null) blocks.push({
+				key: group.map((i) => ids[i]).join("|"),
+				start: elements.length,
+				size: group.length,
+				name: this.blockName(group.map((i) => known.get(ids[i])), block)
+			});
+			for (const i of group) elements.push({
+				id: ids[i],
+				group: known.get(ids[i]).group,
+				position: i,
+				block
+			});
+		});
+		const uses = /* @__PURE__ */ new Map();
+		for (const block of blocks) uses.set(block.name, (uses.get(block.name) ?? 0) + 1);
+		const issued = /* @__PURE__ */ new Map();
+		for (const block of blocks) {
+			if (uses.get(block.name) < 2) continue;
+			const turn = (issued.get(block.name) ?? 0) + 1;
+			issued.set(block.name, turn);
+			block.name = `${block.name} ${turn}`;
+		}
+		return {
+			elements,
+			weights,
+			blocks
+		};
+	}
+	blockName(members, block) {
+		const tally = /* @__PURE__ */ new Map();
+		for (const { group } of members) if (group) tally.set(group, (tally.get(group) ?? 0) + 1);
+		const [name, count] = [...tally].sort((a, b) => b[1] - a[1])[0] ?? ["", 0];
+		if (count * 2 > members.length) return name;
+		return `${this.options.order === DsmOrder.Partition ? "Coupled set" : "Cluster"} ${block + 1}`;
+	}
+	draw(ctx) {
+		const { convention, mark, columnLabel, blocks: boxed } = this.options;
+		const { elements, weights, blocks } = this.arrange();
+		const n = elements.length;
+		const longest = Math.max(0, ...elements.map((element) => element.id.length));
+		const named = columnLabel === DsmColumnLabel.Name;
+		const head = named ? Math.min(ctx.plot.height * .3, longest * 5.6 + 6) : 16;
+		const rowRoom = Math.min(ctx.plot.width * .3, longest * 6 + 28);
+		const noteRoom = boxed && blocks.length && ctx.plot.width > 300 ? Math.min(96, ctx.plot.width * .25) : 0;
+		const side = n ? Math.max(0, Math.min(ctx.plot.height - head, ctx.plot.width - rowRoom - noteRoom)) : 0;
+		const cell = n ? side / n : 0;
+		const inset = Math.min(1, cell * .1);
+		const font = Math.min(11, Math.max(7, cell * .8));
+		const stride = Math.max(1, Math.ceil(9 / Math.max(cell, .01)));
+		const spare = Math.max(0, (ctx.plot.width - rowRoom - noteRoom - side) / 2);
+		const grid = ctx.nest(`translate(${rowRoom + spare},${head})`, "dsm");
+		const rows = convention === DsmConvention.RowInputs;
+		const views = [];
+		let top = 0;
+		elements.forEach((a, i) => elements.forEach((b, j) => {
+			const weight = weights[a.position][b.position];
+			if (!weight) return;
+			top = Math.max(top, weight);
+			views.push({
+				key: `${a.id}>${b.id}`,
+				row: rows ? j : i,
+				column: rows ? i : j,
+				weight,
+				source: a.id,
+				target: b.id,
+				within: a.block !== null && a.block === b.block
+			});
+		}));
+		const shade = (d) => ctx.palette.sequential(.35 + .65 * d.weight / (top || 1));
+		const lattice = n ? Array.from({ length: n + 1 }, (_, i) => `M0,${i * cell}H${side}M${i * cell},0V${side}`).join("") : "";
+		const lines = grid.marks("lattice", "path", n ? [lattice] : [], () => "lattice").attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
+		ctx.set(lines, { d: (d) => d });
+		const diagonal = grid.marks("diagonal", "rect", elements, (d) => d.id).attr("fill", ctx.theme.axis);
+		ctx.set(diagonal, {
+			x: (_, i) => i * cell,
+			y: (_, i) => i * cell,
+			width: cell,
+			height: cell
+		});
+		const cells = grid.marks("cells", "rect", mark === DsmMark.Cell ? views : [], (d) => d.key).attr("fill", shade).attr("rx", Math.min(2, cell / 6));
+		ctx.set(cells, {
+			x: (d) => d.column * cell + inset,
+			y: (d) => d.row * cell + inset,
+			width: cell - inset * 2,
+			height: cell - inset * 2
+		}, { width: 0 });
+		const dots = grid.marks("dots", "circle", mark === DsmMark.Dot ? views : [], (d) => d.key).attr("fill", shade);
+		ctx.set(dots, {
+			cx: (d) => (d.column + .5) * cell,
+			cy: (d) => (d.row + .5) * cell,
+			r: (d) => Math.max(1.5, cell * .46 * Math.sqrt(d.weight / (top || 1)))
+		}, { r: 0 });
+		const glyph = symbol(symbolCross, Math.max(6, (cell * .8) ** 2) * .32)();
+		const crosses = grid.marks("crosses", "path", mark === DsmMark.Cross ? views : [], (d) => d.key).attr("fill", shade);
+		ctx.set(crosses, {
+			d: glyph,
+			transform: (d) => `translate(${(d.column + .5) * cell},${(d.row + .5) * cell}) rotate(45)`
+		});
+		const shown = mark === DsmMark.Cell ? cells : mark === DsmMark.Dot ? dots : crosses;
+		ctx.hover(shown, (d) => ({
+			title: `${d.source} → ${d.target}`,
+			rows: [
+				["Strength", d.weight],
+				["Reading", d.column < d.row === rows ? "Feedforward" : "Feedback"],
+				["Scope", d.within ? "Within block" : "Across blocks"]
+			]
+		}));
+		const outlines = grid.marks("blocks", "rect", boxed ? blocks : [], (d) => d.key).attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", 2).attr("rx", 2).attr("pointer-events", "none");
+		ctx.set(outlines, {
+			x: (d) => d.start * cell + 1,
+			y: (d) => d.start * cell + 1,
+			width: (d) => Math.max(0, d.size * cell - 2),
+			height: (d) => Math.max(0, d.size * cell - 2)
+		});
+		const rowLabels = elements.flatMap((element, i) => i % stride ? [] : [{
+			key: element.id,
+			text: `${StructureText.fit(element.id, rowRoom - 26, font)}  ${i + 1}`,
+			at: i
+		}]);
+		const rowText = ctx.text(grid.marks("row-labels", "text", rowLabels, (d) => d.key), font).attr("text-anchor", "end").text((d) => d.text);
+		ctx.set(rowText, {
+			x: -5,
+			y: (d) => (d.at + .5) * cell + font * .35
+		});
+		const columnLabels = elements.flatMap((element, i) => i % stride ? [] : [{
+			key: element.id,
+			text: named ? StructureText.fit(element.id, head - 6, font) : String(i + 1),
+			at: i
+		}]);
+		const columnText = ctx.text(grid.marks("column-labels", "text", columnLabels, (d) => d.key), font).attr("text-anchor", named ? "start" : "middle").text((d) => d.text);
+		ctx.set(columnText, {
+			x: 0,
+			y: 0,
+			transform: (d) => named ? `translate(${(d.at + .5) * cell + font * .35},-5) rotate(-90)` : `translate(${(d.at + .5) * cell},-5)`
+		});
+		const notes = ctx.text(grid.marks("block-notes", "text", noteRoom ? blocks.filter((block) => block.size * cell >= 12) : [], (d) => d.key), 10.5).text((d) => StructureText.fit(d.name, noteRoom - 10, 10.5));
+		ctx.set(notes, {
+			x: side + 8,
+			y: (d) => (d.start + d.size / 2) * cell + 4
+		});
+	}
+	table() {
+		return {
+			columns: [
+				"source",
+				"target",
+				"value"
+			],
+			rows: (this.options.data?.links ?? []).map((link) => [
+				link.source,
+				link.target,
+				link.value
+			])
+		};
+	}
+};
+export { DependencyMatrix };

package/dist/charts/structure/DependencyOrdering.js

@@ -0,0 +1,76 @@
+import { range, sum } from "d3";
+// src/charts/structure/DependencyOrdering.ts
+/** Orderings for a design structure matrix. `weights[a][b]` is what element `a` passes to `b`. */
+var DependencyOrdering = class DependencyOrdering {
+	/** Net producers come first, so more marks land on the feedforward side of the diagonal. */
+	static #flow(weights, members) {
+		return (i) => sum(members, (j) => weights[i][j] - weights[j][i]);
+	}
+	/** Groups elements by greedy modularity on the undirected interaction strength. */
+	static cluster(weights) {
+		const n = weights.length;
+		const total = sum(weights, (row) => sum(row)) || 1;
+		const shared = range(n).map((a) => range(n).map((b) => a === b ? 0 : (weights[a][b] + weights[b][a]) / (2 * total)));
+		const reach = shared.map((row) => sum(row));
+		const groups = range(n).map((i) => [i]);
+		for (;;) {
+			let bestA = -1, bestB = -1, best = 1e-9;
+			for (let a = 0; a < n; a++) {
+				if (!groups[a]) continue;
+				for (let b = a + 1; b < n; b++) {
+					if (!groups[b]) continue;
+					const gain = 2 * (shared[a][b] - reach[a] * reach[b]);
+					if (gain > best) {
+						best = gain;
+						bestA = a;
+						bestB = b;
+					}
+				}
+			}
+			if (bestA < 0) break;
+			groups[bestA].push(...groups[bestB]);
+			groups[bestB] = null;
+			reach[bestA] += reach[bestB];
+			for (let k = 0; k < n; k++) {
+				if (k === bestA || !groups[k]) continue;
+				shared[bestA][k] += shared[bestB][k];
+				shared[k][bestA] = shared[bestA][k];
+			}
+		}
+		const everyone = range(n);
+		const flow = DependencyOrdering.#flow(weights, everyone);
+		const score = (members) => sum(members, flow) / members.length;
+		return groups.filter((group) => group !== null).map((group) => [...group].sort((a, b) => DependencyOrdering.#flow(weights, group)(b) - DependencyOrdering.#flow(weights, group)(a) || a - b)).sort((a, b) => score(b) - score(a) || a[0] - b[0]);
+	}
+	/** Steward's partitioning: strongly connected sets in dependency order, leaving feedback only inside coupled blocks. */
+	static partition(weights) {
+		const n = weights.length;
+		const index = new Array(n).fill(-1), low = new Array(n).fill(0), onStack = new Array(n).fill(false);
+		const stack = [], found = [];
+		let counter = 0;
+		const connect = (v) => {
+			index[v] = low[v] = counter++;
+			stack.push(v);
+			onStack[v] = true;
+			for (let w = 0; w < n; w++) {
+				if (w === v || !weights[v][w]) continue;
+				if (index[w] < 0) {
+					connect(w);
+					low[v] = Math.min(low[v], low[w]);
+				} else if (onStack[w]) low[v] = Math.min(low[v], index[w]);
+			}
+			if (low[v] !== index[v]) return;
+			const members = [];
+			for (;;) {
+				const w = stack.pop();
+				onStack[w] = false;
+				members.push(w);
+				if (w === v) break;
+			}
+			found.push(members);
+		};
+		for (let v = 0; v < n; v++) if (index[v] < 0) connect(v);
+		return found.reverse().map((group) => [...group].sort((a, b) => DependencyOrdering.#flow(weights, group)(b) - DependencyOrdering.#flow(weights, group)(a) || a - b));
+	}
+};
+export { DependencyOrdering };