@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/engineering/MollierChart.js

@@ -0,0 +1,235 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart, engineeringTick } from "./EngineeringChart.js";
+import { SteamModel } from "./SteamModel.js";
+// src/charts/engineering/MollierChart.ts
+var MollierPlane = /* @__PURE__ */ function(MollierPlane) {
+	MollierPlane["EnthalpyEntropy"] = "h-s";
+	MollierPlane["TemperatureEntropy"] = "t-s";
+	MollierPlane["PressureEnthalpy"] = "p-h";
+	return MollierPlane;
+}({});
+var MollierIsolines = /* @__PURE__ */ function(MollierIsolines) {
+	MollierIsolines["None"] = "dome-only";
+	MollierIsolines["Isobars"] = "isobars";
+	MollierIsolines["Quality"] = "quality";
+	MollierIsolines["Full"] = "full-grid";
+	return MollierIsolines;
+}({});
+var ISOBARS = [
+	.1,
+	1,
+	10,
+	50,
+	100,
+	200
+];
+var ISOTHERMS = [
+	200,
+	300,
+	400,
+	500,
+	600
+];
+var QUALITIES = [
+	.2,
+	.4,
+	.6,
+	.8
+];
+var DOME = Array.from({ length: 40 }, (_, i) => 10 + i * 364.14 / 39);
+function sampleRankine(seed) {
+	const [a, b] = SampleData.points(seed, 2, 1).map((row) => (+row.size - 3) / 30);
+	const boiler = 80 + 40 * a, top = 500 + 60 * b;
+	const cold = SteamModel.saturationTemperature(.1), hot = SteamModel.saturationTemperature(boiler);
+	const liquid = SteamModel.wet(cold, 0), inlet = SteamModel.superheated(boiler, top);
+	const quality = (inlet.entropy * 1.04 - liquid.entropy) / (SteamModel.wet(cold, 1).entropy - liquid.entropy);
+	return [
+		["1", liquid],
+		["2", {
+			...liquid,
+			enthalpy: liquid.enthalpy + 12,
+			pressure: boiler,
+			temperature: cold + 1
+		}],
+		["3", SteamModel.wet(hot, 0)],
+		["4", SteamModel.wet(hot, 1)],
+		["5", inlet],
+		["6", SteamModel.wet(cold, Math.min(.98, quality))],
+		["1", liquid]
+	].map(([label, state]) => ({
+		label,
+		cycle: "Rankine cycle",
+		...state
+	}));
+}
+/** Size a steam cycle on the enthalpy-entropy, temperature-entropy or pressure-enthalpy plane. */
+var MollierChart = class extends EngineeringChart {
+	static meta = {
+		id: "mollier-chart",
+		name: "Mollier chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots thermodynamic cycle states over the steam dome and isolines on h-s, T-s or p-h axes.",
+		tags: [
+			"steam",
+			"thermodynamics",
+			"rankine",
+			"enthalpy",
+			"entropy",
+			"turbine",
+			"p-h diagram",
+			"t-s diagram"
+		],
+		sample: sampleRankine,
+		variants: {
+			plane: Object.values(MollierPlane),
+			isolines: [
+				"full-grid",
+				"isobars",
+				"quality",
+				"dome-only"
+			],
+			dome: [true, false],
+			connected: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			entropy: "entropy",
+			enthalpy: "enthalpy",
+			temperature: "temperature",
+			pressure: "pressure",
+			cycle: "cycle",
+			label: "label",
+			plane: "h-s",
+			isolines: "full-grid",
+			dome: true,
+			connected: true
+		};
+	}
+	draw(ctx) {
+		const { entropy, enthalpy, temperature, pressure, cycle, label, plane, isolines, dome, connected, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const states = this.rows.map((row) => ({
+			entropy: this.num(row, entropy),
+			enthalpy: this.num(row, enthalpy),
+			temperature: this.num(row, temperature),
+			pressure: this.num(row, pressure),
+			cycle: String(row[cycle] ?? "Cycle"),
+			label: String(row[label] ?? "")
+		}));
+		const pick = plane === "t-s" ? (s) => [s.entropy, s.temperature] : plane === "p-h" ? (s) => [s.enthalpy, s.pressure] : (s) => [s.entropy, s.enthalpy];
+		const usable = states.filter((s) => pick(s).every(Number.isFinite) && (plane !== "p-h" || s.pressure > 0));
+		const log = plane === "p-h";
+		const left = DOME.map((t) => SteamModel.wet(t, 0)), right = DOME.map((t) => SteamModel.wet(t, 1)).reverse();
+		const cage = [
+			...left,
+			...right,
+			SteamModel.superheated(.05, 620),
+			SteamModel.superheated(240, 620)
+		];
+		const x = Scales.continuous(ScaleKind.Linear).domain(this.span([...cage, ...usable].map((s) => pick(s)[0]))).range([0, width]);
+		const y = Scales.continuous(log ? ScaleKind.Log : ScaleKind.Linear).domain(this.span([...cage, ...usable].map((s) => pick(s)[1]), { log })).range([height, 0]);
+		const titles = {
+			["h-s"]: ["Entropy (kJ/kg·K)", "Enthalpy (kJ/kg)"],
+			["t-s"]: ["Entropy (kJ/kg·K)", "Temperature (°C)"],
+			["p-h"]: ["Enthalpy (kJ/kg)", "Pressure (bar)"]
+		};
+		this.frame(ctx, {
+			x,
+			y,
+			xTitle: xLabel ?? titles[plane][0],
+			yTitle: yLabel ?? titles[plane][1]
+		});
+		const at = (s) => {
+			const [a, b] = pick(s);
+			return [x(a), y(b)];
+		};
+		const inside = (list) => this.within(list.map(at), width, height);
+		if (dome) this.shapes(ctx, "dome-fill", [{
+			key: "dome",
+			fill: ctx.palette.sequential(.2),
+			opacity: .35,
+			d: `M${[...left, ...right].map(at).join("L")}Z`
+		}]);
+		let isobarNotes = [];
+		if (isolines === "isobars" || isolines === "full-grid") {
+			const lines = ISOBARS.map((p) => {
+				const tsat = Math.min(SteamModel.saturationTemperature(p), 374);
+				const wet = [
+					SteamModel.wet(tsat, 0),
+					SteamModel.wet(tsat, .5),
+					SteamModel.wet(tsat, 1)
+				];
+				const dry = Array.from({ length: 24 }, (_, i) => SteamModel.superheated(p, tsat + (620 - tsat) * (i + 1) / 24));
+				return {
+					key: `p${p}`,
+					p,
+					points: inside([...wet, ...dry])
+				};
+			});
+			this.guides(ctx, "isobars", lines);
+			isobarNotes = lines.flatMap((line) => {
+				const seat = line.points.filter((p) => Number.isFinite(p[0])).at(-1);
+				return seat ? [{
+					key: line.key,
+					text: `${engineeringTick(line.p)} bar`,
+					x: seat[0] - 3,
+					y: seat[1] + 11,
+					anchor: "end",
+					tone: "muted",
+					size: 9
+				}] : [];
+			});
+		}
+		if (isolines === "full-grid") this.guides(ctx, "isotherms", ISOTHERMS.map((t) => ({
+			key: `t${t}`,
+			dash: "4 3",
+			points: inside(SteamModelSweep.filter((p) => SteamModel.saturationTemperature(p) < t).map((p) => SteamModel.superheated(p, t)))
+		})));
+		if (isolines === "quality" || isolines === "full-grid") this.guides(ctx, "quality", QUALITIES.map((q) => ({
+			key: `x${q}`,
+			dash: "1 3",
+			points: inside(DOME.map((t) => SteamModel.wet(t, q)))
+		})));
+		this.traces(ctx, "dome", [{
+			key: "dome",
+			color: ctx.theme.inkSecondary,
+			points: inside([...left, ...right])
+		}]);
+		const tip = (s) => ({
+			title: s.label ? `State ${s.label}` : s.cycle,
+			color: ctx.palette.color(s.cycle),
+			rows: [
+				["Enthalpy", `${s.enthalpy.toFixed(0)} kJ/kg`],
+				["Entropy", `${s.entropy.toFixed(2)} kJ/kg·K`],
+				["Temperature", `${s.temperature.toFixed(0)} °C`],
+				["Pressure", `${s.pressure.toPrecision(3)} bar`]
+			]
+		});
+		const cycles = this.series(cycle).map(([name]) => ({
+			name,
+			states: usable.filter((s) => s.cycle === name)
+		}));
+		if (connected) this.traces(ctx, "cycles", cycles.map((c) => ({
+			key: c.name,
+			color: ctx.palette.color(c.name),
+			points: c.states.map(at)
+		})));
+		const unique = usable.filter((s, i) => usable.findIndex((o) => o.cycle === s.cycle && o.label === s.label && s.label !== "") === i);
+		this.dots(ctx, "states", unique, at, (s) => ctx.palette.color(s.cycle), tip, 5);
+		this.annotate(ctx, "state-notes", [...unique.filter((s) => s.label).map((s, i) => ({
+			key: `${s.label}${i}`,
+			text: s.label,
+			x: at(s)[0] + 7,
+			y: at(s)[1] - 6,
+			tone: "ink",
+			size: 11
+		})), ...isobarNotes]);
+	}
+};
+var SteamModelSweep = Array.from({ length: 30 }, (_, i) => .05 * 1.33 ** i);
+export { MollierChart, MollierIsolines, MollierPlane };

package/dist/charts/engineering/MoodyDiagram.js

@@ -0,0 +1,238 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+import { max, min } from "d3";
+// src/charts/engineering/MoodyDiagram.ts
+var MoodyCorrelation = /* @__PURE__ */ function(MoodyCorrelation) {
+	MoodyCorrelation["Colebrook"] = "colebrook";
+	MoodyCorrelation["Haaland"] = "haaland";
+	MoodyCorrelation["SwameeJain"] = "swamee-jain";
+	return MoodyCorrelation;
+}({});
+var MoodyCoefficient = /* @__PURE__ */ function(MoodyCoefficient) {
+	MoodyCoefficient["Darcy"] = "darcy";
+	MoodyCoefficient["Fanning"] = "fanning";
+	return MoodyCoefficient;
+}({});
+var MoodyDensity = /* @__PURE__ */ function(MoodyDensity) {
+	MoodyDensity["Standard"] = "standard";
+	MoodyDensity["Fine"] = "fine";
+	return MoodyDensity;
+}({});
+var COARSE = [
+	0,
+	1e-4,
+	.001,
+	.005,
+	.02,
+	.05
+];
+var FINE = [
+	0,
+	1e-5,
+	5e-5,
+	2e-4,
+	5e-4,
+	.001,
+	.002,
+	.005,
+	.01,
+	.02,
+	.03,
+	.05
+];
+var haaland = (re, rough) => (-1.8 * Math.log10((rough / 3.7) ** 1.11 + 6.9 / re)) ** -2;
+var swamee = (re, rough) => .25 / Math.log10(rough / 3.7 + 5.74 / re ** .9) ** 2;
+function colebrook(re, rough) {
+	let inverse = 1 / Math.sqrt(haaland(re, rough));
+	for (let i = 0; i < 8; i++) inverse = -2 * Math.log10(rough / 3.7 + 2.51 * inverse / re);
+	return 1 / (inverse * inverse);
+}
+var LAWS = {
+	["colebrook"]: colebrook,
+	["haaland"]: haaland,
+	["swamee-jain"]: swamee
+};
+function samplePipes(seed) {
+	const pipes = [
+		["Drawn copper", 1e-4],
+		["Commercial steel", .001],
+		["Cast iron", .01]
+	];
+	return SampleData.points(seed, 30, 3).map((row, i) => {
+		const [pipe, rough] = pipes[i % 3], reynolds = 10 ** (4.2 + (+row.size - 3) / 30 * 3);
+		return {
+			pipe,
+			reynolds: Math.round(reynolds),
+			friction: +(colebrook(reynolds, rough) * (1 + (+row.y - +row.x * .8 - 10) / 9 * .03)).toFixed(5)
+		};
+	});
+}
+/** Find pipe friction losses: friction factor against Reynolds number over relative-roughness curves. */
+var MoodyDiagram = class extends EngineeringChart {
+	static meta = {
+		id: "moody-diagram",
+		name: "Moody diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots pipe friction factor against Reynolds number across laminar, transitional and rough flow.",
+		tags: [
+			"fluid mechanics",
+			"pipe flow",
+			"colebrook",
+			"darcy",
+			"reynolds number",
+			"pressure drop"
+		],
+		sample: samplePipes,
+		variants: {
+			correlation: [
+				"colebrook",
+				"haaland",
+				"swamee-jain"
+			],
+			coefficient: ["darcy", "fanning"],
+			density: ["standard", "fine"],
+			regimes: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			reynolds: "reynolds",
+			friction: "friction",
+			pipe: "pipe",
+			correlation: "colebrook",
+			coefficient: "darcy",
+			density: "standard",
+			regimes: true
+		};
+	}
+	plotMargin() {
+		return {
+			...super.plotMargin(),
+			right: 46
+		};
+	}
+	draw(ctx) {
+		const { reynolds, friction, pipe, correlation, coefficient, density, regimes, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const fanning = coefficient === "fanning";
+		const factor = (darcy) => fanning ? darcy / 4 : darcy;
+		const law = LAWS[correlation];
+		const measures = this.rows.map((row) => ({
+			pipe: String(row[pipe] ?? "Pipe"),
+			reynolds: this.num(row, reynolds),
+			friction: this.num(row, friction)
+		})).filter((m) => m.reynolds > 0 && m.friction > 0);
+		const x = Scales.continuous(ScaleKind.Log).domain([min([600, ...measures.map((m) => m.reynolds)]), max([1e8, ...measures.map((m) => m.reynolds)])]).range([0, width]);
+		const y = Scales.continuous(ScaleKind.Log).domain([factor(.0055), factor(max([.1, ...measures.map((m) => m.friction * 1.1)]))]).range([height, 0]);
+		const yValues = fanning ? [
+			.0015,
+			.002,
+			.003,
+			.004,
+			.005,
+			.007,
+			.01,
+			.02
+		] : [
+			.006,
+			.008,
+			.01,
+			.015,
+			.02,
+			.03,
+			.05,
+			.08
+		];
+		this.frame(ctx, {
+			x,
+			y,
+			yValues,
+			xTitle: xLabel ?? "Reynolds number",
+			yTitle: yLabel ?? `${fanning ? "Fanning" : "Darcy"} friction factor`
+		});
+		const at = (re, f) => [x(re), y(factor(f))];
+		if (regimes) {
+			this.shapes(ctx, "regimes", [{
+				key: "laminar",
+				fill: ctx.theme.grid,
+				opacity: .5,
+				d: `M0,0H${x(2300)}V${height}H0Z`
+			}, {
+				key: "transition",
+				fill: ctx.theme.grid,
+				d: `M${x(2300)},0H${x(4e3)}V${height}H${x(2300)}Z`
+			}]);
+			this.annotate(ctx, "regime-notes", [{
+				key: "l",
+				text: "Laminar",
+				x: x(2300) - 4,
+				y: height - 6,
+				anchor: "end",
+				tone: "muted",
+				size: 10
+			}, {
+				key: "t",
+				text: "Turbulent",
+				x: x(4e3) + 6,
+				y: height - 6,
+				tone: "muted",
+				size: 10
+			}]);
+		}
+		const roughness = density === "fine" ? FINE : COARSE;
+		const sweep = Array.from({ length: 80 }, (_, i) => 4e3 * (x.domain()[1] / 4e3) ** (i / 79));
+		const lines = roughness.map((rough) => ({
+			rough,
+			points: this.within(sweep.map((re) => at(re, law(re, rough))), width, height)
+		}));
+		this.traces(ctx, "roughness", lines.map((line) => ({
+			key: `r${line.rough}`,
+			color: ctx.theme.inkMuted,
+			width: 1.25,
+			points: line.points
+		})));
+		const labelled = this.within(lines.map((line) => line.points.filter((p) => Number.isFinite(p[0])).at(-1) ?? [NaN, NaN]), width, height);
+		const room = {
+			width: width + 44,
+			height
+		};
+		this.annotate(ctx, "roughness-notes", lines.map((line, i) => ({
+			key: `n${i}`,
+			text: line.rough ? `${line.rough}` : "Smooth",
+			x: width + 4,
+			y: (labelled[i]?.[1] ?? NaN) + 3,
+			tone: "muted",
+			size: 9
+		})), room);
+		this.traces(ctx, "laminar", [{
+			key: "l",
+			color: ctx.theme.inkSecondary,
+			points: this.within(Array.from({ length: 30 }, (_, i) => {
+				const re = x.domain()[0] * (2300 / x.domain()[0]) ** (i / 29);
+				return at(re, 64 / re);
+			}), width, height)
+		}]);
+		this.guides(ctx, "rough-limit", [{
+			key: "b",
+			dash: "5 4",
+			points: this.within(roughness.filter(Boolean).concat(1e-5, .05).sort((a, b) => a - b).map((rough) => {
+				const f = law(0xe8d4a51000, rough);
+				return at(200 / (rough * Math.sqrt(f)), f);
+			}), width, height)
+		}]);
+		this.dots(ctx, "measures", measures, (m) => at(m.reynolds, m.friction), (m) => ctx.palette.color(m.pipe), (m) => ({
+			title: m.pipe,
+			color: ctx.palette.color(m.pipe),
+			rows: [
+				["Reynolds", m.reynolds.toLocaleString("en")],
+				["Friction factor", factor(m.friction).toFixed(4)],
+				["Smooth pipe", factor(law(m.reynolds, 0)).toFixed(4)]
+			]
+		}), 3.5);
+	}
+};
+export { MoodyCoefficient, MoodyCorrelation, MoodyDensity, MoodyDiagram };

package/dist/charts/engineering/NicholsChart.js

@@ -0,0 +1,190 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ComplexMath } from "./ComplexMath.js";
+import { FrequencyResponseChart } from "./FrequencyResponseChart.js";
+import { TransferFunction } from "./TransferFunction.js";
+import { scaleLinear } from "d3";
+// src/charts/engineering/NicholsChart.ts
+var NicholsGrid = /* @__PURE__ */ function(NicholsGrid) {
+	NicholsGrid["None"] = "open";
+	NicholsGrid["Magnitude"] = "magnitude-contours";
+	NicholsGrid["Full"] = "magnitude-phase-contours";
+	return NicholsGrid;
+}({});
+var NicholsWindow = /* @__PURE__ */ function(NicholsWindow) {
+	NicholsWindow["Fit"] = "fit";
+	NicholsWindow["FullTurn"] = "full-turn";
+	return NicholsWindow;
+}({});
+var M_DB = [
+	12,
+	6,
+	3,
+	1,
+	0,
+	-1,
+	-3,
+	-6,
+	-12,
+	-20
+];
+var N_DEG = [
+	-5,
+	-20,
+	-60,
+	-90,
+	-120,
+	-150,
+	-175
+];
+var toDb = (value) => 20 * Math.log10(value);
+var openLoop = (closed) => {
+	const open = ComplexMath.div(closed, ComplexMath.sub([1, 0], closed));
+	const phase = ComplexMath.arg(open) * 180 / Math.PI;
+	return [phase > 0 ? phase - 360 : phase, toDb(ComplexMath.abs(open))];
+};
+/** Shape a loop by reading closed-loop gain straight off its open-loop gain-phase curve. */
+var NicholsChart = class extends FrequencyResponseChart {
+	static meta = {
+		id: "nichols-chart",
+		name: "Nichols chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots open-loop gain against phase over closed-loop contours for loop shaping.",
+		tags: [
+			"control",
+			"loop shaping",
+			"gain phase"
+		],
+		sample: (seed) => TransferFunction.demoResponse(seed),
+		variants: {
+			gridLines: [
+				"magnitude-phase-contours",
+				"magnitude-contours",
+				"open"
+			],
+			window: ["fit", "full-turn"],
+			margins: [true, false],
+			decades: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			gridLines: "magnitude-phase-contours",
+			window: "fit",
+			floor: -60,
+			margins: true,
+			decades: true
+		};
+	}
+	contour(points, at, width, height) {
+		return points.flatMap((p, i) => {
+			const last = points[i - 1];
+			return last && Math.abs(p[0] - last[0]) > 180 ? [[NaN, NaN], at(p)] : [at(p)];
+		}).map((p) => Number.isFinite(p[0]) ? this.within([p], width, height)[0] : p);
+	}
+	draw(ctx) {
+		const { gridLines, window, floor, margins, decades, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const loops = this.responses();
+		const points = loops.flatMap((loop) => loop.points);
+		const fit = this.span(points.map((p) => p.phase));
+		const step = 45;
+		const left = window === "full-turn" ? -360 : Math.floor(Math.min(fit[0], -180) / step) * step;
+		const right = window === "full-turn" ? 0 : Math.ceil(fit[1] / step) * step;
+		const x = scaleLinear([left, right === left ? left + step : right], [0, width]);
+		const y = scaleLinear([floor, Math.max(12, this.span(points.map((p) => p.magnitude))[1] + 3)], [height, 0]).nice();
+		const xValues = Array.from({ length: Math.round((x.domain()[1] - left) / step) + 1 }, (_, i) => left + i * step);
+		this.frame(ctx, {
+			x,
+			y,
+			xValues: width < 340 ? xValues.filter((_, i) => i % 2 === 0) : xValues,
+			xFormat: (v) => `${v}°`,
+			xTitle: xLabel ?? "Open-loop phase",
+			yTitle: yLabel ?? "Open-loop gain (dB)"
+		});
+		const at = (p) => [x(p[0]), y(p[1])];
+		if (gridLines !== "open") {
+			const sweep = Array.from({ length: 359 }, (_, i) => (i + .5) * Math.PI / 179.5);
+			const magnitude = M_DB.map((db) => ({
+				key: `m${db}`,
+				db,
+				points: this.contour(sweep.map((angle) => openLoop(ComplexMath.polar(10 ** (db / 20), -angle))), at, width, height)
+			}));
+			this.guides(ctx, "magnitude-contours", magnitude.map((m) => ({
+				...m,
+				dash: m.db === 0 ? void 0 : "3 3"
+			})));
+			this.annotate(ctx, "magnitude-notes", magnitude.flatMap((m) => {
+				const seat = m.points.find((p) => Number.isFinite(p[0]) && p[0] > width * .62) ?? m.points.find((p) => Number.isFinite(p[0]));
+				return seat && m.db >= -6 ? [{
+					key: m.key,
+					text: `${m.db}`,
+					x: seat[0],
+					y: seat[1] - 2,
+					tone: "muted",
+					size: 9
+				}] : [];
+			}));
+			if (gridLines === "magnitude-phase-contours") {
+				const reach = Array.from({ length: 160 }, (_, i) => 10 ** (-2 + i / 40));
+				this.guides(ctx, "phase-contours", N_DEG.map((deg) => ({
+					key: `n${deg}`,
+					dash: "1 3",
+					points: this.contour(reach.map((m) => openLoop(ComplexMath.polar(m, deg * Math.PI / 180))), at, width, height)
+				})));
+			}
+		}
+		const inside = (p) => this.within([p], width, height)[0];
+		const seat = (p) => inside(at([p.phase, p.magnitude]));
+		this.traces(ctx, "curves", loops.map((loop) => ({
+			key: loop.system,
+			color: ctx.palette.color(loop.system),
+			points: loop.points.map(seat)
+		})));
+		const tip = (p) => ({
+			title: p.system,
+			color: ctx.palette.color(p.system),
+			rows: [
+				["Frequency", p.frequency.toPrecision(3)],
+				["Gain", `${p.magnitude.toFixed(1)} dB`],
+				["Phase", `${p.phase.toFixed(1)}°`]
+			]
+		});
+		if (decades) {
+			const ticks = loops.flatMap((loop) => [
+				-2,
+				-1,
+				0,
+				1,
+				2
+			].flatMap((power) => {
+				const hit = loop.points.find((p) => p.frequency >= 10 ** power);
+				return hit && hit.frequency < 10 ** (power + .05) ? [hit] : [];
+			}));
+			this.dots(ctx, "decade-dots", ticks, seat, (p) => ctx.palette.color(p.system), tip, 3.5);
+		}
+		if (margins) {
+			const cross = loops.flatMap((loop) => {
+				const m = this.margins(loop);
+				return [m.gainCross, m.phaseCross].filter((p) => p !== void 0);
+			});
+			this.dots(ctx, "crossover-dots", cross, seat, () => ctx.theme.ink, tip, 4.5);
+		}
+		const target = at([-180, 0]);
+		this.traces(ctx, "critical", [{
+			key: "x",
+			color: ctx.theme.critical,
+			points: [
+				[target[0] - 5, target[1] - 5],
+				[target[0] + 5, target[1] + 5],
+				[NaN, 0],
+				[target[0] - 5, target[1] + 5],
+				[target[0] + 5, target[1] - 5]
+			]
+		}]);
+		loops.forEach((loop, i) => this.probes(ctx, `probe-${i}`, loop.points, seat, tip));
+	}
+};
+export { NicholsChart, NicholsGrid, NicholsWindow };