@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/signals/PhaseSpaceChart.js

@@ -0,0 +1,148 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { max, scaleLinear } from "d3";
+import { hexbin } from "d3-hexbin";
+// src/charts/signals/PhaseSpaceChart.ts
+var PhaseCoordinates = /* @__PURE__ */ function(PhaseCoordinates) {
+	PhaseCoordinates["Delay"] = "delay";
+	PhaseCoordinates["Derivative"] = "derivative";
+	PhaseCoordinates["Channels"] = "channels";
+	return PhaseCoordinates;
+}({});
+var PhaseMark = /* @__PURE__ */ function(PhaseMark) {
+	PhaseMark["Trajectory"] = "trajectory";
+	PhaseMark["Points"] = "points";
+	PhaseMark["Density"] = "density";
+	return PhaseMark;
+}({});
+var SEGMENTS = 24;
+var POINTS = 180;
+/** Reconstructs a dynamical system's state space from a signal, showing limit cycles and strange attractors. */
+var PhaseSpaceChart = class extends SignalChart {
+	static meta = {
+		id: "signal-phase-space",
+		name: "Phase space plot",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots a signal against its delayed self, its slope or another channel to reveal cycles and attractors.",
+		tags: [
+			"attractor",
+			"delay embedding",
+			"poincare section",
+			"lissajous",
+			"dynamics"
+		],
+		sample: (seed) => SignalSamples.attractor(seed),
+		variants: {
+			coordinates: Object.values(PhaseCoordinates),
+			mark: Object.values(PhaseMark),
+			delay: [36, 12],
+			section: [false, true]
+		},
+		valid: (values) => values.coordinates === "delay" || values.delay === 36
+	};
+	constructor(options) {
+		const kind = options.coordinates ?? "delay";
+		super({
+			xLabel: kind === "channels" ? "Channel 1" : "x(t)",
+			yLabel: kind === "derivative" ? "dx/dt" : kind === "channels" ? "Channel 2" : "x(t + τ)",
+			...options
+		});
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			coordinates: "delay",
+			mark: "trajectory",
+			delay: 36,
+			section: false
+		};
+	}
+	get legended() {
+		return false;
+	}
+	get points() {
+		const { coordinates, delay } = this.options, { v, rate } = this.first, b = this.channels[1]?.v;
+		if (coordinates === "channels" && b) return v.slice(0, b.length).map((value, i) => [value, b[i]]);
+		if (coordinates === "derivative") return v.slice(1, -1).map((value, i) => [value, (v[i + 2] - v[i]) * rate / 2]);
+		return v.slice(0, Math.max(0, v.length - delay)).map((value, i) => [value, v[i + delay]]);
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, points = this.points;
+		const fit = (axis, range) => {
+			const values = points.map((point) => point[axis]), low = Math.min(...values), high = Math.max(...values), pad = (high - low) * .06 || 1;
+			return scaleLinear([low - pad, high + pad], range);
+		};
+		return {
+			x: fit(0, [0, width]),
+			y: fit(1, [height, 0])
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { mark, section } = this.options, points = this.points;
+		if (!points.length) return;
+		if (mark === "trajectory") {
+			const size = Math.ceil(points.length / SEGMENTS);
+			const parts = Array.from({ length: SEGMENTS }, (_, i) => ({
+				i,
+				list: points.slice(i * size, (i + 1) * size + 1)
+			})).filter((part) => part.list.length > 1);
+			const paths = this.stroke(ctx, "path", parts, (part) => part.i, (part) => this.path(part.list, x, y), (part) => ctx.palette.sequential(.25 + .75 * part.i / SEGMENTS), 1.5);
+			ctx.hover(paths, (part) => ({
+				title: "Trajectory",
+				rows: [["Progress", `${Math.round(part.i / SEGMENTS * 100)}%`]]
+			}));
+		}
+		if (mark === "points") {
+			const stride = Math.max(1, Math.floor(points.length / POINTS)), kept = points.filter((_, i) => i % stride === 0);
+			const dots = ctx.marks("dots", "circle", kept, (_, i) => i).attr("fill", (_, i) => ctx.palette.sequential(.25 + .75 * i / kept.length)).attr("stroke", ctx.theme.surface).attr("stroke-width", 1);
+			ctx.set(dots, {
+				cx: (point) => x(point[0]),
+				cy: (point) => y(point[1]),
+				r: 4
+			}, { r: 0 }, 2);
+			ctx.hover(dots, (point, i) => ({
+				title: `Sample ${i * stride}`,
+				rows: [["x", SignalScales.number(point[0])], ["y", SignalScales.number(point[1])]]
+			}));
+		}
+		if (mark === "density") {
+			const { width, height } = ctx.plot, radius = Math.max(5, Math.min(width, height) / 22);
+			const bins = hexbin().x((point) => x(point[0])).y((point) => y(point[1])).radius(radius).extent([[0, 0], [width, height]])(points);
+			const top = max(bins, (bin) => bin.length) ?? 1, shape = hexbin().radius(radius - 1).hexagon();
+			const cells = ctx.marks("hex", "path", bins, (bin) => `${bin.x},${bin.y}`).attr("d", shape).attr("fill", (bin) => ctx.palette.sequential(.15 + .85 * Math.sqrt(bin.length / top)));
+			ctx.set(cells, {
+				transform: (bin) => `translate(${bin.x},${bin.y})`,
+				opacity: 1
+			}, { opacity: 0 }, 2);
+			ctx.hover(cells, (bin) => ({
+				title: "Density",
+				rows: [["Samples", bin.length]]
+			}));
+		}
+		if (section) this.section(ctx, points, x, y);
+	}
+	/** Poincaré section: upward crossings of the mid-line of x. */
+	section(ctx, points, x, y) {
+		const [lo, hi] = x.domain(), at = (lo + hi) / 2;
+		ctx.marks("section-line", "line", [0]).attr("x1", x(at)).attr("x2", x(at)).attr("y1", 0).attr("y2", ctx.plot.height).attr("stroke", ctx.theme.axis).attr("stroke-dasharray", "4 3");
+		const hits = points.flatMap((point, i) => i && points[i - 1][0] < at && point[0] >= at ? [{
+			i,
+			y: point[1]
+		}] : []);
+		const dots = ctx.marks("section", "circle", hits, (hit) => hit.i).attr("fill", ctx.theme.ink).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: x(at),
+			cy: (hit) => y(hit.y),
+			r: 4
+		}, { r: 0 }, 8);
+		ctx.hover(dots, (hit) => ({
+			title: "Section crossing",
+			rows: [["y", SignalScales.number(hit.y)]]
+		}));
+	}
+};
+export { PhaseCoordinates, PhaseMark, PhaseSpaceChart };

package/dist/charts/signals/SeismogramChart.js

@@ -0,0 +1,237 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalDsp } from "./SignalDsp.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { area, scaleBand, scaleLinear } from "d3";
+// src/charts/signals/SeismogramChart.ts
+var SeismogramLayout = /* @__PURE__ */ function(SeismogramLayout) {
+	SeismogramLayout["Section"] = "record-section";
+	SeismogramLayout["Lanes"] = "lanes";
+	SeismogramLayout["Helicorder"] = "helicorder";
+	return SeismogramLayout;
+}({});
+var SeismogramFill = /* @__PURE__ */ function(SeismogramFill) {
+	SeismogramFill["Wiggle"] = "wiggle";
+	SeismogramFill["VariableArea"] = "variable-area";
+	return SeismogramFill;
+}({});
+var SeismogramGain = /* @__PURE__ */ function(SeismogramGain) {
+	SeismogramGain["Trace"] = "trace-normalised";
+	SeismogramGain["True"] = "true-amplitude";
+	return SeismogramGain;
+}({});
+var STATIONS = [
+	["ANMO", 90],
+	["COLA", 165],
+	["HRV", 240],
+	["KIP", 330],
+	["PFO", 430]
+];
+var P = 7.6;
+var S = 4.3;
+var RATE = 20;
+/** Ground motion against time, as an event record section, stacked stations or a drum recorder. */
+var SeismogramChart = class extends SignalChart {
+	static meta = {
+		id: "signal-seismogram",
+		name: "Seismogram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows ground motion across stations or hours, with wiggle or variable-area traces and picked wave arrivals.",
+		tags: [
+			"earthquake",
+			"record section",
+			"helicorder",
+			"wiggle",
+			"sta/lta"
+		],
+		sample: (seed) => SignalSamples.noise(seed, 2e3, STATIONS.length).flatMap(({ noise }, s) => {
+			const [series, distance] = STATIONS[s], fade = 90 / distance;
+			let smooth = 0;
+			return noise.map((step, i) => {
+				const t = i / RATE, p = t - distance / P, w = t - distance / S;
+				smooth = smooth * .55 + step * .45;
+				const body = p > 0 ? .3 * Math.exp(-p / 7) * smooth * 3 : 0, shear = w > 0 ? Math.exp(-w / 11) * (smooth * 1.6 + 1.2 * Math.sin(2 * Math.PI * .7 * w)) : 0;
+				return {
+					t,
+					series,
+					distance,
+					value: +((body + shear) * fade + smooth * .012).toFixed(4)
+				};
+			});
+		}),
+		variants: {
+			layout: Object.values(SeismogramLayout),
+			fill: Object.values(SeismogramFill),
+			gain: Object.values(SeismogramGain),
+			picks: [true, false],
+			moveout: [false, true]
+		},
+		valid: (values) => {
+			if (values.moveout === true && values.layout !== "record-section") return false;
+			return values.layout !== "helicorder" || values.gain === "trace-normalised";
+		}
+	};
+	constructor(options) {
+		const section = (options.layout ?? "record-section") === "record-section";
+		super({
+			yLabel: section ? "Distance (km)" : void 0,
+			xLabel: options.moveout ? `Reduced time (s)` : "Time (s)",
+			...options
+		});
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			distance: "distance",
+			layout: "record-section",
+			fill: "variable-area",
+			gain: "trace-normalised",
+			picks: true,
+			moveout: false,
+			velocity: P,
+			lines: 7,
+			grid: false
+		};
+	}
+	get legended() {
+		return false;
+	}
+	distanceOf(channel, index) {
+		const row = (this.options.data ?? []).find((item) => String(item[this.options.series] ?? "Signal") === channel.name);
+		const value = row ? +row[this.options.distance] : NaN;
+		return Number.isFinite(value) ? value : index;
+	}
+	get stations() {
+		return this.channels.map((channel, i) => ({
+			channel,
+			distance: this.distanceOf(channel, i)
+		})).sort((a, b) => a.distance - b.distance);
+	}
+	/** Arrivals: the first pick, then the next rise once the first has had time to pass. */
+	pick(channel) {
+		const rate = channel.rate, values = channel.v, short = Math.max(2, Math.round(rate)), long = Math.max(8, Math.round(rate * 10));
+		const first = SignalDsp.staLta(values, short, long, 8);
+		if (first < 0) return [];
+		return [first, SignalDsp.staLta(values, short, long, 3.5, first + Math.round(rate * 5))].filter((index) => index >= 0).map((index) => channel.t[index]);
+	}
+	get window() {
+		const [lo, hi] = this.span, stations = this.stations;
+		if (!this.options.moveout || !stations.length) return [lo, hi];
+		return [lo, hi - stations[stations.length - 1].distance / this.options.velocity];
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, { layout, lines } = this.options, stations = this.stations;
+		if (layout === "helicorder") {
+			const [lo, hi] = this.span, each = (hi - lo) / lines;
+			const y = scaleBand(Array.from({ length: lines }, (_, i) => `+${SignalScales.number(i * each)}`), [0, height]).paddingInner(0);
+			return {
+				x: scaleLinear([0, each], [0, width]),
+				y
+			};
+		}
+		const x = scaleLinear(this.window, [0, width]);
+		if (layout === "lanes") return {
+			x,
+			y: scaleBand(stations.map((station) => station.channel.name), [0, height]).paddingInner(.1)
+		};
+		const reach = stations.length ? [stations[0].distance, stations[stations.length - 1].distance] : [0, 1], pad = (reach[1] - reach[0] || 1) * .14;
+		return {
+			x,
+			y: scaleLinear([reach[0] - pad, reach[1] + pad], [height, 0])
+		};
+	}
+	traces({ x, y }, height) {
+		const { layout, gain, moveout, velocity, lines, picks } = this.options, width = x.range()[1];
+		const peak = this.peak;
+		const build = (key, label, middle, size, channel, from, to, shift, top) => {
+			const kept = [], time = [];
+			channel.t.forEach((t, i) => {
+				if (t >= from && t < to) {
+					kept.push(channel.v[i]);
+					time.push(t - shift);
+				}
+			});
+			const near = kept.reduce((most, value) => Math.max(most, Math.abs(value)), 1e-9), scale = size / 2 / (top || near);
+			return {
+				key,
+				label,
+				middle,
+				height: size,
+				points: this.thin({
+					...channel,
+					t: time
+				}, kept, width).map(([t, value]) => [t, Math.max(-size * .95, Math.min(size * .95, value * scale))]),
+				picks: picks ? this.pick(channel).filter((t) => t >= from && t < to).map((t) => t - shift) : [],
+				shift,
+				channel
+			};
+		};
+		if (layout === "helicorder") {
+			const channel = this.first, [lo, hi] = this.span, each = (hi - lo) / lines, band = y, near = channel.v.reduce((most, value) => Math.max(most, Math.abs(value)), 1e-9);
+			return band.domain().map((name, i) => build(name, name, (band(name) ?? 0) + band.bandwidth() / 2, band.bandwidth() * 1.1, channel, lo + i * each, lo + (i + 1) * each, lo + i * each, near * .3));
+		}
+		const stations = this.stations;
+		if (layout === "lanes") {
+			const band = y;
+			return stations.map(({ channel }) => build(channel.name, channel.name, (band(channel.name) ?? 0) + band.bandwidth() / 2, band.bandwidth(), channel, -Infinity, Infinity, 0, gain === "true-amplitude" ? peak : 0));
+		}
+		const scale = y, gap = stations.length > 1 ? Math.min(...stations.slice(1).map((station, i) => Math.abs(scale(station.distance) - scale(stations[i].distance)))) : height / 2;
+		return stations.map(({ channel, distance }) => {
+			const shift = moveout ? distance / velocity : 0;
+			const [from, to] = this.window;
+			return build(channel.name, channel.name, scale(distance), gap * 1.5, channel, from + shift, to + shift, shift, gain === "true-amplitude" ? peak : 0);
+		});
+	}
+	plotMarks(ctx, axes) {
+		const { x } = axes, { fill, layout } = this.options, { height, width } = ctx.plot, traces = this.traces(axes, height);
+		const color = (trace) => ctx.palette.color(layout === "helicorder" ? this.first.name : trace.channel.name);
+		if (fill === "variable-area") {
+			const shape = (trace) => area().x((point) => x(point[0])).y0(trace.middle).y1((point) => trace.middle - Math.max(0, point[1]))(trace.points) ?? "";
+			this.fill(ctx, "lobes", traces, (trace) => trace.key, shape, color, .7);
+		}
+		this.stroke(ctx, "trace", traces, (trace) => trace.key, (trace) => this.path(trace.points, x, (value) => trace.middle - value), color, 1);
+		const labels = traces.filter(() => layout === "record-section");
+		this.halo(ctx, ctx.text(ctx.marks("names", "text", labels, (trace) => trace.key).attr("x", width - 2).attr("y", (trace) => trace.middle - 3).attr("text-anchor", "end").text((trace) => trace.label), 10, "secondary"));
+		const arrivals = traces.flatMap((trace) => trace.picks.map((t, i) => ({
+			key: `${trace.key}${i}`,
+			trace,
+			t,
+			i
+		})));
+		const ticks = ctx.marks("picks", "line", arrivals, (pick) => pick.key).attr("stroke", ctx.theme.ink).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		ctx.set(ticks, {
+			x1: (pick) => x(pick.t),
+			x2: (pick) => x(pick.t),
+			y1: (pick) => pick.trace.middle - 9,
+			y2: (pick) => pick.trace.middle + 9
+		}, {}, 20);
+		ctx.hover(ticks, (pick) => ({
+			title: `${pick.trace.label} ${pick.i ? "S" : "P"} arrival`,
+			rows: [["Time", `${SignalScales.number(pick.t + pick.trace.shift)} s`]]
+		}));
+		if (arrivals.length) {
+			const top = arrivals.filter((pick) => pick.trace === arrivals[0].trace && x(pick.t) > 8);
+			ctx.text(ctx.marks("pick-names", "text", top, (pick) => pick.key).attr("x", (pick) => x(pick.t)).attr("y", (pick) => Math.max(10, pick.trace.middle - 12)).attr("text-anchor", "middle").text((pick) => pick.i ? "S" : "P"), 11, "ink");
+		}
+		this.probe(ctx, (px, py) => {
+			const trace = traces.reduce((best, item) => !best || Math.abs(item.middle - py) < Math.abs(best.middle - py) ? item : best, null);
+			if (!trace) return null;
+			const time = x.invert(px) + trace.shift;
+			return {
+				x: px,
+				tip: {
+					title: trace.label,
+					rows: [["Time", `${SignalScales.number(time)} s`], ["Amplitude", SignalScales.number(SignalDsp.interpolate(trace.channel.t, trace.channel.v, time))]]
+				},
+				datum: {
+					station: trace.label,
+					t: time
+				}
+			};
+		});
+	}
+};
+export { SeismogramChart, SeismogramFill, SeismogramGain, SeismogramLayout };

package/dist/charts/signals/SignalChart.js

@@ -0,0 +1,164 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { LegendPosition } from "../../core/enums.js";
+import { SignalDsp } from "./SignalDsp.js";
+import { SignalScales } from "./SignalScales.js";
+import { axisLeft, line, pointer, scaleBand } from "d3";
+// src/charts/signals/SignalChart.ts
+var numeric = (cell) => cell instanceof Date ? +cell / 1e3 : cell === null || cell === void 0 || cell === "" ? NaN : +cell;
+/** Turns long-form rows into clean channels: sorted, de-duplicated, free of nulls. */
+var SignalParser = class {
+	static channels(data, x, y, series, sampleRate) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const [index, row] of (data ?? []).entries()) {
+			const time = numeric(row[x]), value = numeric(row[y]);
+			if (!Number.isFinite(value)) continue;
+			const name = String(row[series] ?? "Signal");
+			if (!groups.has(name)) groups.set(name, []);
+			groups.get(name).push([Number.isFinite(time) ? time : index, value]);
+		}
+		return [...groups].map(([name, points]) => {
+			points.sort((a, b) => a[0] - b[0]);
+			const unique = points.filter((point, i) => i === 0 || point[0] !== points[i - 1][0]);
+			const t = unique.map((point) => point[0]), gaps = t.slice(1).map((time, i) => time - t[i]).sort((a, b) => a - b);
+			const step = gaps[gaps.length >> 1] || 1;
+			return {
+				name,
+				t,
+				v: unique.map((point) => point[1]),
+				rate: sampleRate ?? 1 / step
+			};
+		});
+	}
+};
+/** Base for sampled signals: parses channels and provides lanes, trace drawing and a nearest-sample probe. */
+var SignalChart = class extends CartesianChart {
+	parsed;
+	defaults() {
+		return {
+			x: "t",
+			y: "value",
+			series: "series",
+			xLabel: "Time (s)",
+			yLabel: "Amplitude"
+		};
+	}
+	get channels() {
+		const { data, x, y, series, sampleRate } = this.options;
+		const key = `${x}|${y}|${series}|${sampleRate}`;
+		if (this.parsed?.data !== data || this.parsed.key !== key) this.parsed = {
+			data,
+			key,
+			list: SignalParser.channels(data, x, y, series, sampleRate)
+		};
+		return this.parsed.list;
+	}
+	get first() {
+		return this.channels[0] ?? {
+			name: "Signal",
+			t: [],
+			v: [],
+			rate: 1
+		};
+	}
+	/** Longest time span across channels. */
+	get span() {
+		const list = this.channels.filter((channel) => channel.t.length);
+		if (!list.length) return [0, 1];
+		const lo = Math.min(...list.map((channel) => channel.t[0])), hi = Math.max(...list.map((channel) => channel.t[channel.t.length - 1]));
+		return hi > lo ? [lo, hi] : [lo, lo + 1];
+	}
+	/** Largest absolute amplitude across channels, never zero. */
+	get peak() {
+		return Math.max(1e-9, ...this.channels.map((channel) => channel.v.reduce((most, value) => Math.max(most, Math.abs(value)), 0)));
+	}
+	/** A legend only earns its row when several channels share the plot. */
+	get legended() {
+		return this.channels.length > 1;
+	}
+	get legendPosition() {
+		return this.legended ? super.legendPosition : LegendPosition.None;
+	}
+	tickFormat(scale) {
+		const label = scale.label;
+		if (label) return (value) => label(+value);
+		return typeof scale.domain()[0] === "number" ? (value) => SignalScales.number(+value) : null;
+	}
+	lanes(height, names = this.channels.map((channel) => channel.name)) {
+		return scaleBand(names, [0, height]).paddingInner(.14);
+	}
+	/** Pairs of min and max per pixel column, which keeps every peak of a long trace. */
+	thin(channel, values, width) {
+		if (values.length <= width / 1.5) return values.map((value, i) => [channel.t[i], value]);
+		return SignalDsp.buckets(channel.t, values, width / 2).flatMap((bucket) => bucket.rising ? [[bucket.t, bucket.min], [bucket.t, bucket.max]] : [[bucket.t, bucket.max], [bucket.t, bucket.min]]);
+	}
+	path(points, x, y) {
+		return line().x((point) => x(point[0])).y((point) => y(point[1]))(points) ?? "";
+	}
+	/** Stroked line marks that draw on from their start. */
+	stroke(ctx, name, data, key, d, color, width = 2) {
+		const paths = ctx.marks(name, "path", data, key).attr("fill", "none").attr("stroke", color).attr("stroke-width", width).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("d", d);
+		ctx.drawOn(paths);
+		return paths;
+	}
+	/** Filled path marks that fade in. */
+	fill(ctx, name, data, key, d, color, opacity = 1) {
+		const paths = ctx.marks(name, "path", data, key).attr("fill", color).attr("stroke", "none");
+		return ctx.set(paths, {
+			d,
+			opacity
+		}, { opacity: 0 });
+	}
+	/** Text with a surface-coloured halo, for labels that may sit on a trace. */
+	halo(ctx, selection) {
+		return selection.attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke");
+	}
+	/** Horizontal rule across the plot. */
+	rule(ctx, name, values, y, dashed = false) {
+		ctx.marks(name, "line", values, (_, i) => i).attr("x1", 0).attr("x2", ctx.plot.width).attr("y1", y).attr("y2", y).attr("stroke", ctx.theme.axis).attr("stroke-width", 1).attr("stroke-dasharray", dashed ? "4 3" : null);
+	}
+	/** Left axis for a second panel stacked in the same plot. */
+	panelAxis(ctx, name, scale, ticks = 3) {
+		const formatter = (value) => (scale.label ?? SignalScales.number)(+value);
+		const axis = ctx.group(name).call(axisLeft(scale).ticks(ticks).tickSize(0).tickFormat(formatter));
+		axis.select(".domain").attr("stroke", "none");
+		axis.selectAll("text").attr("fill", ctx.theme.inkSecondary).attr("font-size", 11).attr("font-family", ctx.theme.fontFamily);
+	}
+	/** Transparent layer that reports whatever `at` finds under the pointer, with a vertical hairline. */
+	probe(ctx, at) {
+		const { width, height } = ctx.plot;
+		const hair = ctx.marks("probe-hair", "line", [0]).attr("y1", 0).attr("y2", height).attr("stroke", ctx.theme.inkMuted).attr("stroke-width", 1).attr("opacity", 0);
+		const zone = ctx.marks("probe-zone", "rect", [0]).attr("width", width).attr("height", height).attr("fill", "transparent").style("cursor", "crosshair");
+		const hit = (event) => {
+			const [x, y] = pointer(event, zone.node());
+			return at(x, y);
+		};
+		zone.on("pointermove", (event) => {
+			const found = hit(event);
+			if (!found) return;
+			hair.attr("x1", found.x).attr("x2", found.x).attr("opacity", 1);
+			this.tip(event, found.tip);
+		}).on("pointerleave", () => {
+			hair.attr("opacity", 0);
+			this.untip();
+		}).on("click", (event) => {
+			const found = hit(event);
+			if (found) this.options.onSelect?.(found.datum);
+		});
+	}
+	/** Probe that reads every channel at the time under the pointer. */
+	timeProbe(ctx, x) {
+		this.probe(ctx, (px) => {
+			const time = x.invert(px);
+			const rows = this.channels.map((channel) => [channel.name, SignalScales.number(SignalDsp.interpolate(channel.t, channel.v, time))]);
+			return {
+				x: px,
+				tip: {
+					title: `${SignalScales.number(time)} s`,
+					rows
+				},
+				datum: { t: time }
+			};
+		});
+	}
+};
+export { SignalChart, SignalParser };