@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/engineering/ThermalProfileChart.js

@@ -0,0 +1,255 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+import { curveMonotoneX, group, interpolateNumber, mean, scaleLinear } from "d3";
+// src/charts/engineering/ThermalProfileChart.ts
+var ThermalRender = /* @__PURE__ */ function(ThermalRender) {
+	ThermalRender["Probes"] = "probes";
+	ThermalRender["Envelope"] = "envelope";
+	ThermalRender["ProbesEnvelope"] = "probes-envelope";
+	return ThermalRender;
+}({});
+var PROFILE = [
+	[0, 25],
+	[90, 150],
+	[180, 190],
+	[235, 246],
+	[255, 246],
+	[305, 120],
+	[345, 60]
+];
+function sampleReflow(seed) {
+	const trims = SampleData.categories(seed, 4, 1).map((row) => (+row.value - 60) / 40);
+	const curve = (moment) => {
+		const t = Math.max(0, Math.min(PROFILE[PROFILE.length - 1][0], moment));
+		const i = Math.max(1, PROFILE.findIndex((p) => p[0] >= t));
+		const [t0, v0] = PROFILE[i - 1], [t1, v1] = PROFILE[i];
+		return interpolateNumber(v0, v1)((t - t0) / (t1 - t0));
+	};
+	return trims.flatMap((trim, p) => {
+		let value = 25;
+		return Array.from({ length: 88 }, (_, i) => {
+			const time = i * 4;
+			value += (curve(time + 6 * trim) * (1 + trim * .018) - value) * .45;
+			return {
+				probe: `TC${p + 1}`,
+				time,
+				temperature: +value.toFixed(1)
+			};
+		});
+	});
+}
+/** Verify a soldering or heat-treat profile against its limits, across every thermocouple. */
+var ThermalProfileChart = class extends EngineeringChart {
+	static meta = {
+		id: "thermal-profile-chart",
+		name: "Thermal profile",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Tracks temperature over time through process zones, with liquidus, peak and ramp-rate limits.",
+		tags: [
+			"reflow",
+			"soldering",
+			"oven",
+			"heat treatment",
+			"thermocouple"
+		],
+		sample: sampleReflow,
+		variants: {
+			render: [
+				"probes",
+				"envelope",
+				"probes-envelope"
+			],
+			zones: [true, false],
+			liquidus: [true, false],
+			rate: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			time: "time",
+			temperature: "temperature",
+			probe: "probe",
+			render: "probes",
+			zones: true,
+			liquidus: true,
+			rate: true,
+			liquidusTemperature: 217,
+			soakTemperature: 150,
+			rateLimit: 3
+		};
+	}
+	slices() {
+		const { time, temperature } = this.options;
+		return [...group(this.rows, (row) => this.num(row, time))].filter(([moment]) => Number.isFinite(moment)).map(([moment, rows]) => {
+			const values = rows.map((row) => this.num(row, temperature)).filter(Number.isFinite);
+			return {
+				time: moment,
+				low: Math.min(...values),
+				high: Math.max(...values),
+				mean: mean(values) ?? NaN
+			};
+		}).filter((slice) => Number.isFinite(slice.mean)).sort((a, b) => a.time - b.time);
+	}
+	draw(ctx) {
+		const { time, temperature, probe, render, zones, liquidus, rate, liquidusTemperature, soakTemperature, rateLimit, xLabel, yLabel } = this.options;
+		const { width, height } = ctx.plot;
+		const slices = this.slices();
+		const panel = rate ? Math.min(60, height * .3) : 0;
+		const gap = rate ? 8 : 0;
+		const main = height - panel - gap;
+		const x = scaleLinear(this.span(slices.map((s) => s.time)), [0, width]);
+		const y = scaleLinear(this.span([...slices.flatMap((s) => [s.low, s.high]), ...liquidus ? [liquidusTemperature] : []], { pad: .06 }), [main, 0]).nice();
+		const seconds = xLabel ?? "Time (s)";
+		const top = ctx.nest("translate(0,0)", "profile");
+		this.frame(top, {
+			x,
+			y,
+			hideX: rate,
+			xTitle: seconds,
+			yTitle: yLabel ?? "Temperature (°C)"
+		});
+		const peak = slices.reduce((best, s) => !best || s.mean > best.mean ? s : best, null);
+		if (zones && peak) {
+			const rising = slices.filter((s) => s.time <= peak.time);
+			const soak = rising.find((s) => s.mean >= soakTemperature)?.time ?? peak.time;
+			const melt = rising.find((s) => s.mean >= liquidusTemperature)?.time ?? peak.time;
+			const freeze = slices.find((s) => s.time > peak.time && s.mean < liquidusTemperature)?.time ?? x.domain()[1];
+			const stops = [
+				x.domain()[0],
+				soak,
+				melt,
+				freeze,
+				x.domain()[1]
+			];
+			const names = [
+				"Preheat",
+				"Soak",
+				"Reflow",
+				"Cooling"
+			];
+			this.shapes(top, "zones", names.map((name, i) => ({
+				key: name,
+				fill: ctx.theme.grid,
+				opacity: i % 2 ? .55 : 0,
+				d: `M${x(stops[i])},0H${x(stops[i + 1])}V${main}H${x(stops[i])}Z`
+			})));
+			this.annotate(top, "zone-notes", names.map((name, i) => ({
+				key: name,
+				text: name,
+				x: (x(stops[i]) + x(stops[i + 1])) / 2,
+				y: main - 5,
+				anchor: "middle",
+				tone: "muted",
+				size: 10
+			})).filter((_, i) => x(stops[i + 1]) - x(stops[i]) > 42), {
+				width,
+				height: main
+			});
+		}
+		if (render !== "probes" && slices.length) {
+			const rim = [...slices.map((s) => [x(s.time), y(s.high)]), ...[...slices].reverse().map((s) => [x(s.time), y(s.low)])];
+			this.shapes(top, "spread", [{
+				key: "spread",
+				fill: ctx.theme.inkMuted,
+				opacity: .28,
+				d: `M${rim.join("L")}Z`
+			}]);
+		}
+		if (render !== "envelope") this.traces(top, "probes", this.series(probe).map(([name, rows]) => ({
+			key: name,
+			color: ctx.palette.color(name),
+			width: render === "probes-envelope" ? 1.5 : 2,
+			curve: curveMonotoneX,
+			points: rows.map((row) => [this.num(row, time), this.num(row, temperature)]).filter((p) => p.every(Number.isFinite)).sort((a, b) => a[0] - b[0]).map((p) => [x(p[0]), y(p[1])])
+		})));
+		else this.traces(top, "mean", [{
+			key: "mean",
+			color: ctx.palette.color("Mean"),
+			curve: curveMonotoneX,
+			points: slices.map((s) => [x(s.time), y(s.mean)])
+		}]);
+		this.probes(top, "probe-points", slices, (s) => [x(s.time), y(s.mean)], (s) => ({
+			title: `${s.time} s`,
+			rows: [
+				["Mean", `${s.mean.toFixed(1)} °C`],
+				["Lowest", `${s.low.toFixed(1)} °C`],
+				["Highest", `${s.high.toFixed(1)} °C`]
+			]
+		}));
+		if (liquidus) {
+			this.traces(top, "liquidus", [{
+				key: "l",
+				color: ctx.theme.critical,
+				width: 1.5,
+				dash: "6 4",
+				points: [[0, y(liquidusTemperature)], [width, y(liquidusTemperature)]]
+			}]);
+			const above = slices.filter((s) => s.mean >= liquidusTemperature);
+			const dwell = above.length ? above[above.length - 1].time - above[0].time : 0;
+			this.annotate(top, "liquidus-note", [{
+				key: "l",
+				text: `Liquidus ${liquidusTemperature} °C`,
+				x: 4,
+				y: y(liquidusTemperature) - 5,
+				tone: "muted",
+				size: 10
+			}], {
+				width,
+				height: main
+			});
+			if (peak) {
+				this.dots(top, "peak", [peak], (s) => [x(s.time), y(s.mean)], () => ctx.theme.ink, (s) => ({
+					title: "Peak",
+					rows: [["Temperature", `${s.mean.toFixed(1)} °C`], ["Time above liquidus", `${dwell} s`]]
+				}), 4);
+				this.annotate(top, "peak-note", [{
+					key: "p",
+					text: `${peak.mean.toFixed(0)} °C, ${dwell} s above`,
+					x: x(peak.time) + 8,
+					y: y(peak.mean) - 2,
+					tone: "ink",
+					size: 10
+				}], {
+					width,
+					height: main
+				});
+			}
+		}
+		if (rate) {
+			const lower = ctx.nest(`translate(0,${main + gap})`, "ramp");
+			const slopes = slices.slice(1).map((s, i) => [s.time, (s.mean - slices[i].mean) / (s.time - slices[i].time || 1)]);
+			const reach = Math.max(rateLimit * 1.25, ...slopes.map((p) => Math.abs(p[1])));
+			const r = scaleLinear([-reach, reach], [panel, 0]);
+			this.frame(lower, {
+				x,
+				y: r,
+				xTitle: seconds,
+				yTitle: "°C/s",
+				yValues: [
+					-rateLimit,
+					0,
+					rateLimit
+				]
+			});
+			this.guides(lower, "rate-limits", [1, -1].map((sign) => ({
+				key: `l${sign}`,
+				dash: "3 3",
+				points: [[0, r(sign * rateLimit)], [width, r(sign * rateLimit)]]
+			})));
+			this.traces(lower, "ramp-curve", [{
+				key: "r",
+				color: ctx.theme.inkSecondary,
+				width: 1.5,
+				points: slopes.map((p) => [x(p[0]), r(p[1])])
+			}]);
+			this.probes(lower, "ramp-probes", slopes, (p) => [x(p[0]), r(p[1])], (p) => ({
+				title: `${p[0]} s`,
+				rows: [["Ramp", `${p[1].toFixed(2)} °C/s`]]
+			}));
+		}
+	}
+};
+export { ThermalProfileChart, ThermalRender };

package/dist/charts/engineering/TransferFunction.js

@@ -0,0 +1,96 @@
+import { SampleData } from "../../data/SampleData.js";
+import { ComplexMath } from "./ComplexMath.js";
+// src/charts/engineering/TransferFunction.ts
+var unit = (row) => (+row.size - 3) / 30;
+/**
+* A linear system in pole-zero-gain form, `H(s) = k * prod(s - z) / prod(s - p)`. Feeds the
+* frequency-response and s-plane charts: `new BodePlot({ data: system.response(band) })`.
+*/
+var TransferFunction = class TransferFunction {
+	zeros;
+	poles;
+	gain;
+	constructor(zeros, poles, gain = 1) {
+		this.zeros = zeros;
+		this.poles = poles;
+		this.gain = gain;
+	}
+	/** `count` points spaced evenly on a log axis. */
+	static logspace(from, to, count) {
+		return Array.from({ length: count }, (_, i) => from * (to / from) ** (i / (count - 1)));
+	}
+	/** Two stable third-order loops derived from sample points, with low-frequency gain above 0 dB. */
+	static demoLoops(seed, count = 2) {
+		const rows = SampleData.points(seed, count * 4, count);
+		return Array.from({ length: count }, (_, g) => {
+			const [a, b, c, d] = rows.filter((_, i) => i % count === g).map(unit);
+			const corners = [
+				.4 + .5 * a,
+				1.6 + 2 * b,
+				6 + 8 * c
+			];
+			const dc = 3 + 3 * d;
+			return new TransferFunction([], corners.map((corner) => [-corner, 0]), dc * corners[0] * corners[1] * corners[2]);
+		});
+	}
+	/** Rows of a sample loop family, ready for Bode, Nyquist and Nichols charts. */
+	static demoResponse(seed) {
+		const band = TransferFunction.logspace(.02, 200, 240);
+		return TransferFunction.demoLoops(seed).flatMap((loop, i) => loop.response(band, i ? "Compensated" : "Plant"));
+	}
+	/** A loop with an integrator, a resonant pair and a zero, as pole-zero rows. */
+	static demoPoles(seed) {
+		const [a, b, c, d] = SampleData.points(seed, 4, 1).map(unit);
+		const pair = [-1 - a, 1.2 + 2 * b];
+		return [...[
+			[0, 0],
+			pair,
+			[pair[0], -pair[1]],
+			[-6 - 2 * c, 0]
+		].map(([real, imaginary]) => ({
+			real,
+			imaginary,
+			kind: "pole",
+			system: "Plant"
+		})), {
+			real: -3 - d,
+			imaginary: 0,
+			kind: "zero",
+			system: "Plant"
+		}];
+	}
+	at(s) {
+		const over = this.zeros.reduce((value, zero) => ComplexMath.mul(value, ComplexMath.sub(s, zero)), [this.gain, 0]);
+		return this.poles.reduce((value, pole) => ComplexMath.div(value, ComplexMath.sub(s, pole)), over);
+	}
+	/** `{ system, frequency, magnitude, phase }` rows: rad/s, dB and unwrapped degrees. */
+	response(frequencies, system = "System") {
+		let last = 0;
+		return frequencies.map((frequency, i) => {
+			const value = this.at([0, frequency]);
+			let phase = ComplexMath.arg(value) * 180 / Math.PI;
+			if (i) phase += 360 * Math.round((last - phase) / 360);
+			last = phase;
+			return {
+				system,
+				frequency,
+				magnitude: 20 * Math.log10(ComplexMath.abs(value)),
+				phase
+			};
+		});
+	}
+	/** Closed-loop poles of `1 + k * H(s)` at each gain: `result[gain][branch]`. */
+	locus(gains) {
+		const denominator = ComplexMath.expand(this.poles);
+		const numerator = ComplexMath.expand(this.zeros);
+		const shift = denominator.length - numerator.length;
+		if (shift < 1) return [];
+		let roots = this.poles.map((pole) => [pole[0] + 1e-6, pole[1] + 1e-6]);
+		return gains.map((gain) => {
+			const coefficients = denominator.map((c, i) => i < shift ? c : ComplexMath.add(c, ComplexMath.mul(numerator[i - shift], [gain * this.gain, 0])));
+			roots = ComplexMath.roots(coefficients, roots);
+			return roots;
+		});
+	}
+};
+export { TransferFunction };

package/dist/charts/engineering/TransferSurface3D.js

@@ -0,0 +1,208 @@
+import { Chart3D } from "../../core/Chart3D.js";
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { ComplexMath } from "./ComplexMath.js";
+import { TransferFunction } from "./TransferFunction.js";
+import { scaleLinear } from "d3";
+import { BufferGeometry, CatmullRomCurve3, Color, DoubleSide, Float32BufferAttribute, Group, InstancedMesh, LineBasicMaterial, LineSegments, Mesh, MeshStandardMaterial, Object3D, PlaneGeometry, SphereGeometry, TubeGeometry, Vector3 } from "three";
+// src/charts/engineering/TransferSurface3D.ts
+var TransferSurfaceStyle = /* @__PURE__ */ function(TransferSurfaceStyle) {
+	TransferSurfaceStyle["Solid"] = "solid";
+	TransferSurfaceStyle["Wireframe"] = "wireframe";
+	TransferSurfaceStyle["Contours"] = "contours";
+	return TransferSurfaceStyle;
+}({});
+var N = 72;
+var FLOOR = -.7;
+var levels = [
+	.15,
+	.3,
+	.45,
+	.6,
+	.75,
+	.9
+];
+/** See why a system rings: the gain landscape over the s-plane, with poles as peaks and zeros as pits. */
+var TransferSurface3D = class extends Chart3D {
+	static meta = {
+		id: "transfer-surface-3d",
+		name: "Transfer function surface",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Lifts the gain of a transfer function over the s-plane so poles rise as peaks and zeros sink as pits.",
+		tags: [
+			"s-plane",
+			"laplace",
+			"control",
+			"frequency response",
+			"poles"
+		],
+		sample: (seed) => TransferFunction.demoPoles(seed).filter((row) => +row.real !== 0),
+		variants: {
+			style: [
+				"solid",
+				"wireframe",
+				"contours"
+			],
+			heightScale: [ScaleKind.Log, ScaleKind.Linear],
+			slice: [true, false],
+			floor: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			real: "real",
+			imaginary: "imaginary",
+			kind: "kind",
+			style: "solid",
+			heightScale: ScaleKind.Log,
+			slice: true,
+			floor: true
+		};
+	}
+	build(ctx) {
+		const { real, imaginary, kind, style, heightScale, slice, floor } = this.options;
+		const roots = (Array.isArray(this.options.data) ? this.options.data : []).map((row) => ({
+			at: [+row[real], +row[imaginary] || 0],
+			zero: String(row[kind]).toLowerCase().startsWith("z")
+		})).filter((root) => Number.isFinite(root.at[0]));
+		const poles = roots.filter((root) => !root.zero).map((root) => root.at), zeros = roots.filter((root) => root.zero).map((root) => root.at);
+		const system = new TransferFunction(zeros, poles);
+		const reach = Math.max(1, ...roots.map((root) => Math.hypot(...root.at))) * 1.25;
+		const sx = scaleLinear([-reach, reach * .4], [-1, 1]), sz = scaleLinear([-reach * .7, reach * .7], [1, -1]);
+		const gain = (s) => {
+			const size = ComplexMath.abs(system.at(s));
+			return heightScale === ScaleKind.Log ? 20 * Math.log10(size || 1e-9) : size;
+		};
+		const grid = Array.from({ length: N }, (_, j) => Array.from({ length: N }, (_, i) => gain([sx.invert(-1 + 2 * i / 71), sz.invert(-1 + 2 * j / 71)])));
+		const ordered = grid.flat().filter(Number.isFinite).sort((a, b) => a - b);
+		const [low, high] = [ordered[Math.floor(ordered.length * .02)] ?? 0, ordered[Math.floor(ordered.length * .97)] ?? 1];
+		const lift = scaleLinear([low, Math.max(low + 1e-9, high)], [0, 1.3]).clamp(true);
+		const positions = [], colors = [], indices = [];
+		grid.forEach((line, j) => line.forEach((value, i) => {
+			const u = lift(value);
+			positions.push(-1 + 2 * i / 71, FLOOR + u, -1 + 2 * j / 71);
+			colors.push(...new Color(ctx.palette.sequential(.1 + .9 * u / 1.3)).toArray());
+		}));
+		for (let j = 0; j < 71; j++) for (let i = 0; i < 71; i++) {
+			const a = j * N + i, b = a + 1, c = a + N, d = c + 1;
+			indices.push(a, c, b, b, c, d);
+		}
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		const body = new Group();
+		ctx.root.add(body);
+		if (style === "solid") {
+			geometry.setIndex(indices);
+			geometry.computeVertexNormals();
+			const surface = new Mesh(geometry, new MeshStandardMaterial({
+				vertexColors: true,
+				roughness: .55,
+				side: DoubleSide
+			}));
+			surface.castShadow = surface.receiveShadow = true;
+			body.add(surface);
+		} else {
+			const lines = [], tones = [];
+			const push = (a, b) => {
+				lines.push(positions[a * 3], positions[a * 3 + 1], positions[a * 3 + 2], positions[b * 3], positions[b * 3 + 1], positions[b * 3 + 2]);
+				tones.push(colors[a * 3], colors[a * 3 + 1], colors[a * 3 + 2], colors[b * 3], colors[b * 3 + 1], colors[b * 3 + 2]);
+			};
+			if (style === "wireframe") {
+				for (let j = 0; j < N; j += 2) for (let i = 0; i < 71; i++) push(j * N + i, j * N + i + 1);
+				for (let i = 0; i < N; i += 2) for (let j = 0; j < 71; j++) push(j * N + i, (j + 1) * N + i);
+			} else {
+				const mix = (a, b, t) => [
+					0,
+					1,
+					2
+				].map((axis) => positions[a * 3 + axis] + (positions[b * 3 + axis] - positions[a * 3 + axis]) * t);
+				for (const level of levels) {
+					const tone = new Color(ctx.palette.sequential(.1 + .9 * level)).toArray();
+					const height = FLOOR + level * 1.3;
+					for (let j = 0; j < 71; j++) for (let i = 0; i < 71; i++) {
+						const a = j * N + i, b = a + 1, c = a + N, d = c + 1;
+						const hits = [
+							[a, b],
+							[b, d],
+							[d, c],
+							[c, a]
+						].flatMap(([from, to]) => {
+							const u = positions[from * 3 + 1] - height, v = positions[to * 3 + 1] - height;
+							return u * v < 0 ? [mix(from, to, u / (u - v))] : [];
+						});
+						if (hits.length >= 2) {
+							lines.push(...hits[0], ...hits[1]);
+							tones.push(...tone, ...tone);
+						}
+					}
+				}
+			}
+			const wire = new BufferGeometry();
+			wire.setAttribute("position", new Float32BufferAttribute(lines, 3));
+			wire.setAttribute("color", new Float32BufferAttribute(tones, 3));
+			body.add(new LineSegments(wire, new LineBasicMaterial({ vertexColors: true })));
+		}
+		ctx.reveal((progress) => {
+			body.scale.y = Math.max(.001, progress);
+			body.position.y = FLOOR * (1 - Math.max(.001, progress));
+		});
+		ctx.pick(body, () => ({
+			title: "Gain surface",
+			rows: [["Poles", poles.length], ["Zeros", zeros.length]]
+		}));
+		const base = new Mesh(new PlaneGeometry(2.1, 2.1), new MeshStandardMaterial({ color: ctx.theme.grid }));
+		base.rotation.x = -Math.PI / 2;
+		base.position.y = -.71;
+		base.receiveShadow = true;
+		ctx.root.add(base);
+		if (slice) {
+			const curve = new CatmullRomCurve3(Array.from({ length: N }, (_, j) => {
+				const z = -1 + 2 * j / 71;
+				return new Vector3(sx(0), FLOOR + lift(gain([0, sz.invert(z)])) + .015, z);
+			}));
+			const tube = new Mesh(new TubeGeometry(curve, 160, .016, 8), new MeshStandardMaterial({ color: ctx.theme.ink }));
+			ctx.root.add(tube);
+			ctx.pick(tube, () => ({
+				title: "Frequency response",
+				rows: [["Where", "Imaginary axis"]]
+			}));
+			ctx.label("jω", [
+				sx(0),
+				FLOOR,
+				1.12
+			], "secondary");
+		}
+		if (floor) {
+			const dots = new InstancedMesh(new SphereGeometry(.035, 16, 12), new MeshStandardMaterial({ color: ctx.theme.ink }), roots.length);
+			const dummy = new Object3D();
+			roots.forEach((root, i) => {
+				dummy.position.set(sx(root.at[0]), -.6599999999999999, sz(root.at[1]));
+				dummy.updateMatrix();
+				dots.setMatrixAt(i, dummy.matrix);
+			});
+			ctx.root.add(dots);
+			ctx.pick(dots, (i) => ({
+				title: roots[i].zero ? "Zero" : "Pole",
+				rows: [["Real", roots[i].at[0].toFixed(2)], ["Imaginary", roots[i].at[1].toFixed(2)]]
+			}));
+		}
+		ctx.label("Re(s)", [
+			0,
+			FLOOR,
+			1.2
+		], "secondary");
+		ctx.label("Im(s)", [
+			1.2,
+			FLOOR,
+			0
+		], "secondary");
+		ctx.label(heightScale === ScaleKind.Log ? "Gain (dB)" : "Gain", [
+			-1.05,
+			.7,
+			-1.05
+		], "secondary");
+	}
+};
+export { TransferSurface3D, TransferSurfaceStyle };

package/dist/charts/engineering/index.js

@@ -0,0 +1,53 @@
+import { TransferFunction } from "./TransferFunction.js";
+import { BodeMagnitudeUnit, BodePhaseRange, BodePlot, BodeView } from "./BodePlot.js";
+import { ConstellationDiagram, ConstellationEncoding, ConstellationModulation, ConstellationReference, ConstellationRender, ConstellationView } from "./ConstellationDiagram.js";
+import { EyeDiagram, EyeRender } from "./EyeDiagram.js";
+import { FatigueFit, FatigueSNCurve } from "./FatigueSNCurve.js";
+import { GoodmanCriterion, GoodmanDiagram, GoodmanLayout } from "./GoodmanDiagram.js";
+import { HysteresisLoopChart } from "./HysteresisLoopChart.js";
+import { IVCurveChart, IVQuadrant } from "./IVCurveChart.js";
+import { LoadLineChart, LoadLineSet } from "./LoadLineChart.js";
+import { MohrCircle, MohrFailure, MohrShearAxis, MohrState } from "./MohrCircle.js";
+import { MollierChart, MollierIsolines, MollierPlane } from "./MollierChart.js";
+import { MoodyCoefficient, MoodyCorrelation, MoodyDensity, MoodyDiagram } from "./MoodyDiagram.js";
+import { NicholsChart, NicholsGrid, NicholsWindow } from "./NicholsChart.js";
+import { NyquistHelix3D } from "./NyquistHelix3D.js";
+import { NyquistContour, NyquistGuide, NyquistPlot, NyquistRadius } from "./NyquistPlot.js";
+import { PoleZeroPlane, PoleZeroPlot } from "./PoleZeroPlot.js";
+import { PsychrometricChart, PsychrometricOrientation, PsychrometricOverlay } from "./PsychrometricChart.js";
+import { PumpArrangement, PumpCurveChart, PumpPanels } from "./PumpCurveChart.js";
+import { RootLocusGain, RootLocusMarks, RootLocusPlot } from "./RootLocusPlot.js";
+import { SParameterChart, SParameterLayout, SParameterView } from "./SParameterChart.js";
+import { SmithChart, SmithDensity, SmithGrid, SmithMarks } from "./SmithChart.js";
+import { StepHold, StepResponseChart } from "./StepResponseChart.js";
+import { StressEnergy, StressMeasure, StressRange, StressStrainChart } from "./StressStrainChart.js";
+import { ThermalProfileChart, ThermalRender } from "./ThermalProfileChart.js";
+import { TransferSurface3D, TransferSurfaceStyle } from "./TransferSurface3D.js";
+// src/charts/engineering/index.ts
+var engineeringCatalog = [
+	BodePlot,
+	NyquistPlot,
+	NicholsChart,
+	SmithChart,
+	PoleZeroPlot,
+	RootLocusPlot,
+	EyeDiagram,
+	ConstellationDiagram,
+	SParameterChart,
+	LoadLineChart,
+	IVCurveChart,
+	PsychrometricChart,
+	MollierChart,
+	MohrCircle,
+	FatigueSNCurve,
+	StressStrainChart,
+	ThermalProfileChart,
+	PumpCurveChart,
+	StepResponseChart,
+	MoodyDiagram,
+	GoodmanDiagram,
+	HysteresisLoopChart,
+	TransferSurface3D,
+	NyquistHelix3D
+];
+export { BodeMagnitudeUnit, BodePhaseRange, BodePlot, BodeView, ConstellationDiagram, ConstellationEncoding, ConstellationModulation, ConstellationReference, ConstellationRender, ConstellationView, EyeDiagram, EyeRender, FatigueFit, FatigueSNCurve, GoodmanCriterion, GoodmanDiagram, GoodmanLayout, HysteresisLoopChart, IVCurveChart, IVQuadrant, LoadLineChart, LoadLineSet, MohrCircle, MohrFailure, MohrShearAxis, MohrState, MollierChart, MollierIsolines, MollierPlane, MoodyCoefficient, MoodyCorrelation, MoodyDensity, MoodyDiagram, NicholsChart, NicholsGrid, NicholsWindow, NyquistContour, NyquistGuide, NyquistHelix3D, NyquistPlot, NyquistRadius, PoleZeroPlane, PoleZeroPlot, PsychrometricChart, PsychrometricOrientation, PsychrometricOverlay, PumpArrangement, PumpCurveChart, PumpPanels, RootLocusGain, RootLocusMarks, RootLocusPlot, SParameterChart, SParameterLayout, SParameterView, SmithChart, SmithDensity, SmithGrid, SmithMarks, StepHold, StepResponseChart, StressEnergy, StressMeasure, StressRange, StressStrainChart, ThermalProfileChart, ThermalRender, TransferFunction, TransferSurface3D, TransferSurfaceStyle, engineeringCatalog };