@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/earthscience/HovmollerSample.js

@@ -0,0 +1,40 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/earthscience/HovmollerSample.ts
+var DAYS = 61;
+var STEP = 2;
+var DAY = 864e5;
+var START = Date.UTC(2026, 0, 1);
+/** Near 5 m/s at the equator, the textbook Madden-Julian speed. */
+var EASTWARD = 3.9;
+/** Near −5 m/s, a textbook equatorial Rossby speed. */
+var WESTWARD = -3.9;
+/** Near 1.3 m/s, a textbook poleward speed for boreal-summer intraseasonal bands. */
+var NORTHWARD = 1.2;
+var gauss = (distance, width) => Math.exp(-((distance / width) ** 2));
+var radians = (degrees) => degrees * Math.PI / 180;
+var arc = (a, b) => Math.abs((a - b + 540) % 360 - 180);
+/** Synthetic tropical data for Hovmöller diagrams. It is a sum of invented waves, not a measurement of any kind. */
+var HovmollerSample = class {
+	/**
+	* Long-form rows `{ time, longitude, latitude, value }`, shaped like outgoing longwave radiation in W/m²:
+	* a warm-pool minimum, then an eastward packet, westward waves and a northward band.
+	*/
+	static tropics(seed) {
+		const [one, two, three] = SampleData.points(seed, 3, 1).map((row) => radians(+row.y * 7));
+		const rows = [];
+		for (let day = 0; day < DAYS; day += STEP) for (let longitude = 0; longitude < 360; longitude += 10) for (let latitude = -30; latitude <= 30; latitude += 5) {
+			const mean = 248 - 34 * gauss(arc(longitude, 130), 60) * gauss(latitude, 18);
+			const packet = -24 * gauss(latitude, 14) * gauss(arc(longitude - EASTWARD * day, 40), 110) * Math.cos(radians(2 * (longitude - EASTWARD * day)) + one);
+			const rossby = 10 * gauss(Math.abs(latitude) - 10, 9) * Math.cos(radians(6 * (longitude - WESTWARD * day)) + two);
+			const band = 11 * Math.cos(radians(6 * (latitude - NORTHWARD * day)) + three);
+			rows.push({
+				time: new Date(START + day * DAY),
+				longitude,
+				latitude,
+				value: +(mean + packet + rossby + band).toFixed(1)
+			});
+		}
+		return rows;
+	}
+};
+export { HovmollerSample };

package/dist/charts/earthscience/HovmollerSpeed.js

@@ -0,0 +1,71 @@
+import { HovmollerReference } from "./HovmollerEnums.js";
+// src/charts/earthscience/HovmollerSpeed.ts
+var SECONDS = 86400;
+/** Metres in one degree of a great circle on a sphere of radius 6371 km. */
+var METRES = 2 * Math.PI * 6371e3 / 360;
+var SEARCH = Array.from({ length: 59 }, (_, i) => 1 + i * .5);
+var MEANINGFUL = .05;
+/** Converts wave speeds to slopes, and estimates speeds from a section. */
+var HovmollerSpeed = class HovmollerSpeed {
+	/** Degrees per day at `speed` m/s along a line of latitude. Pass 0 for motion along a meridian. */
+	static degreesPerDay(speed, latitude = 0) {
+		return speed * SECONDS / (METRES * Math.cos(Math.min(85, Math.abs(latitude)) * Math.PI / 180));
+	}
+	/**
+	* Radon-style speed estimate, as used on altimeter and SST sections by Hill et al. (2000) and Cipollini et al. (2001).
+	* Rows are sheared by each trial speed and collapsed along the shear: the speed whose projection keeps the
+	* most variance wins. Variance is reported as adjusted R² of a one-way layout, so shears that happen to make
+	* more bins earn no credit. Stationary signal is removed first, and a best speed at the edge of the search is no peak, so it returns null.
+	*/
+	static fit(field, direction, latitude = 0) {
+		if (field.columns < 4 || field.rows < 4) return null;
+		const flat = field.anomaly(HovmollerReference.TimeMean).anomaly(HovmollerReference.SpaceMean);
+		const scores = SEARCH.map((speed) => HovmollerSpeed.score(flat, direction * this.degreesPerDay(speed, latitude)));
+		const best = scores.reduce((top, score, i) => score.share > scores[top].share ? i : top, 0);
+		if (best === 0 || best === SEARCH.length - 1 || scores[best].share < MEANINGFUL) return null;
+		return {
+			speed: direction * SEARCH[best],
+			rate: direction * this.degreesPerDay(SEARCH[best], latitude),
+			...scores[best]
+		};
+	}
+	static score(field, rate) {
+		const { columns, rows, positions, values, cyclic, spacing } = field;
+		const days = field.days, first = positions[0], turn = 360;
+		const shifts = days.map((day) => rate * day);
+		const lowest = first - Math.max(0, ...shifts);
+		const span = positions.at(-1) - first + Math.max(0, ...shifts) - Math.min(0, ...shifts);
+		const bins = Math.ceil((cyclic ? turn : span) / spacing) + 1;
+		const sum = new Float64Array(bins), count = new Float64Array(bins);
+		const place = (sheared) => cyclic ? ((sheared - first) % turn + turn) % turn : sheared - lowest;
+		let total = 0, square = 0, seen = 0;
+		for (let j = 0; j < rows; j++) for (let i = 0; i < columns; i++) {
+			const value = values[i + j * columns];
+			if (Number.isNaN(value)) continue;
+			const bin = Math.floor(place(positions[i] - shifts[j]) / spacing);
+			sum[bin] += value;
+			count[bin]++;
+			total += value;
+			square += value * value;
+			seen++;
+		}
+		const grand = total * total / (seen || 1), whole = square - grand;
+		let between = -grand, used = 0, peak = 0, origin = first;
+		sum.forEach((part, bin) => {
+			if (!count[bin]) return;
+			between += part * part / count[bin];
+			used++;
+			const mean = Math.abs(part / count[bin]);
+			if (count[bin] >= rows / 2 && mean > peak) {
+				peak = mean;
+				origin = (cyclic ? first : lowest) + (bin + .5) * spacing;
+			}
+		});
+		const free = seen - used;
+		return {
+			share: whole > 0 && free > 0 ? Math.max(0, 1 - (whole - between) / free / (whole / (seen - 1))) : 0,
+			origin
+		};
+	}
+};
+export { HovmollerSpeed };

package/dist/charts/earthscience/Hydrograph.js

@@ -0,0 +1,442 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Draft } from "../scientific/Draft.js";
+import { BaseflowMethod, BaseflowSeparation } from "./BaseflowSeparation.js";
+import { EarthSample } from "./EarthSample.js";
+import { area, axisRight, line, max, median, min, scaleLinear, scaleLog, scaleTime, sum, timeFormat } from "d3";
+// src/charts/earthscience/Hydrograph.ts
+/** Share of the plot height the hyetograph may reach down into. */
+var RAIN_BAND = .3;
+/** Highest share of the discharge axis the peak may reach, which keeps it clear of the rain. */
+var HEADROOM = .64;
+var stamp = timeFormat("%b %-d, %H:%M");
+var clock = timeFormat("%H:%M");
+var day = timeFormat("%b %-d");
+var fixed = (value) => value.toLocaleString("en", { maximumFractionDigits: value < 10 ? 2 : 1 });
+/** Storm hydrograph: discharge against time under a hanging hyetograph, with baseflow separated from direct runoff. */
+var Hydrograph = class extends CartesianChart {
+	static meta = {
+		id: "hydrograph",
+		name: "Storm hydrograph",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots river discharge over time beneath rainfall bars hanging from the top, separating baseflow from direct runoff.",
+		tags: [
+			"hydrology",
+			"hyetograph",
+			"baseflow",
+			"discharge",
+			"rainfall-runoff",
+			"phi index"
+		],
+		sample: (seed) => EarthSample.hydrograph(seed),
+		variants: {
+			baseflow: Object.values(BaseflowMethod),
+			scale: [ScaleKind.Linear, ScaleKind.Log],
+			rainStep: [
+				1,
+				3,
+				6
+			],
+			losses: [false, true],
+			annotate: [false, true]
+		},
+		valid: (values) => !(values.losses && values.baseflow === BaseflowMethod.None)
+	};
+	#rainLegend = [];
+	defaults() {
+		return {
+			time: "time",
+			flow: "flow",
+			rain: "rain",
+			baseflow: BaseflowMethod.None,
+			scale: ScaleKind.Linear,
+			rainStep: 1,
+			losses: false,
+			annotate: false,
+			area: EarthSample.area,
+			bfiMax: .8,
+			yLabel: "Discharge (m³/s)"
+		};
+	}
+	plotMargin() {
+		return {
+			...super.plotMargin(),
+			right: 54
+		};
+	}
+	legendItems() {
+		return [...this.palette.items(), ...this.#rainLegend];
+	}
+	/** Midnights name the day and other ticks the hour. Log paper keeps its minor grid, but only 1, 2 and 5 carry a label. */
+	tickFormat(scale) {
+		const format = super.tickFormat(scale);
+		if (scale.domain?.()[0] instanceof Date) return (value) => {
+			const date = value;
+			return date.getHours() || date.getMinutes() ? clock(date) : day(date);
+		};
+		if (!format || this.options.scale !== ScaleKind.Log) return format;
+		return (value) => /^[125]e/.test((+value).toExponential()) ? format(value) : "";
+	}
+	read() {
+		const { data, time, flow, rain, baseflow, area: basin, recession, bfiMax } = this.options;
+		let dated = false;
+		const seen = /* @__PURE__ */ new Map();
+		for (const row of data ?? []) {
+			const raw = row[time];
+			if (raw instanceof Date || typeof raw === "string") dated = true;
+			const t = raw instanceof Date ? raw.getTime() : typeof raw === "string" ? Date.parse(raw) : Draft.number(raw);
+			if (t === null || !Number.isFinite(t) || seen.has(t)) continue;
+			seen.set(t, {
+				t,
+				q: Draft.number(row[flow]),
+				rain: Math.max(0, Draft.number(row[rain]) ?? 0)
+			});
+		}
+		const unit = dated ? 36e5 : 1;
+		let held = null;
+		const records = [...seen.values()].sort((a, b) => a.t - b.t).flatMap((record) => {
+			held = record.q ?? held;
+			return held === null ? [] : [{
+				...record,
+				q: Math.max(0, held)
+			}];
+		});
+		const hours = records.map((record) => (record.t - records[0].t) / unit);
+		const q = records.map((record) => record.q);
+		const step = median(hours.slice(1).map((hour, i) => hour - hours[i])) ?? 1;
+		const events = BaseflowSeparation.events(q, hours, basin);
+		const base = BaseflowSeparation.separate(baseflow, q, hours, basin, {
+			recession,
+			bfiMax
+		});
+		const steps = records.map((record, i) => ({
+			t: record.t,
+			hours: hours[i],
+			q: record.q,
+			rain: record.rain,
+			base: base[i]
+		}));
+		const total = sum(q);
+		return {
+			steps,
+			dated,
+			step,
+			unit,
+			events,
+			runoff: sum(steps, (d) => d.q - d.base) * step * 3.6 / basin,
+			bfi: total ? sum(base) / total : 0
+		};
+	}
+	bins({ steps, step, unit }) {
+		const size = Math.max(1, Math.round(this.options.rainStep));
+		return Array.from({ length: Math.ceil(steps.length / size) }, (_, k) => {
+			const slice = steps.slice(k * size, (k + 1) * size);
+			return {
+				key: k,
+				start: slice[0].t,
+				stop: steps[(k + 1) * size]?.t ?? slice.at(-1).t + step * unit,
+				depth: sum(slice, (d) => d.rain)
+			};
+		});
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot;
+		const reading = this.read();
+		const { steps, step, unit, dated, runoff } = reading;
+		const start = steps[0]?.t ?? 0, stop = (steps.at(-1)?.t ?? 0) + step * unit;
+		const x = dated ? scaleTime([new Date(start), new Date(stop)], [0, width]) : scaleLinear([start, stop], [0, width]);
+		const place = (t) => dated ? x(new Date(t)) : x(t);
+		const peak = max(steps, (d) => d.q) || 1;
+		const log = this.options.scale === ScaleKind.Log;
+		const decade = 10 ** Math.floor(Math.log10(min(steps, (d) => d.q > 0 ? d.q : void 0) ?? peak));
+		const y = log ? scaleLog([decade, decade * (peak / decade) ** (1 / HEADROOM)], [height, 0]) : scaleLinear([0, peak / HEADROOM], [height, 0]).nice();
+		const floor = y.domain()[0];
+		const bins = this.bins(reading);
+		return {
+			x,
+			y,
+			place,
+			level: (q) => y(Math.max(q, floor)),
+			depth: scaleLinear([0, max(bins, (bin) => bin.depth) || 1], [0, height * RAIN_BAND]).nice(3),
+			reading,
+			bins,
+			phi: this.options.losses && this.options.baseflow !== BaseflowMethod.None ? BaseflowSeparation.phiIndex(bins.map((bin) => bin.depth), runoff) : 0
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { baseflow, annotate } = this.options;
+		const separated = baseflow !== BaseflowMethod.None && axes.reading.steps.length > 0;
+		const hasRain = axes.bins.some((bin) => bin.depth > 0);
+		const stream = ctx.palette.color("Streamflow");
+		this.drawVolumes(ctx, axes, separated);
+		this.drawRainAxis(ctx, axes, hasRain);
+		this.drawHits(ctx, axes, separated);
+		this.drawRain(ctx, axes);
+		const flow = line().x((d) => axes.place(d.t)).y((d) => axes.level(d.q));
+		const under = line().x((d) => axes.place(d.t)).y((d) => axes.level(d.base));
+		const parts = axes.reading.steps.length > 1 ? [{
+			key: "base",
+			d: separated ? under(axes.reading.steps) : null
+		}, {
+			key: "flow",
+			d: flow(axes.reading.steps)
+		}].filter((part) => part.d) : [];
+		const lines = ctx.marks("hydro-lines", "path", parts, (part) => part.key).attr("fill", "none").attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke", (part) => part.key === "flow" ? stream : ctx.palette.color("Baseflow")).style("pointer-events", "none");
+		ctx.set(lines, { d: (part) => part.d }, { d: (part) => part.d });
+		ctx.drawOn(lines);
+		this.drawAnnotations(ctx, axes, annotate ? this.main(axes.reading) : null);
+		this.#rainLegend = !hasRain ? [] : axes.phi ? [{
+			key: "excess",
+			label: "Excess rainfall",
+			color: ctx.palette.sequential(.75)
+		}, {
+			key: "losses",
+			label: "Losses",
+			color: ctx.theme.inkMuted
+		}] : [{
+			key: "rain",
+			label: "Rainfall",
+			color: ctx.palette.sequential(.75)
+		}];
+	}
+	drawVolumes(ctx, { place, level, reading }, separated) {
+		const { height } = ctx.plot;
+		const shapes = separated && reading.steps.length > 1 ? [{
+			key: "Direct runoff",
+			low: (d) => level(d.base),
+			high: (d) => level(d.q),
+			rest: (d) => level(d.base)
+		}, {
+			key: "Baseflow",
+			low: () => height,
+			high: (d) => level(d.base),
+			rest: () => height
+		}] : [];
+		const outline = (shape, top) => area().x((d) => place(d.t)).y0(shape.low).y1(top)(reading.steps) ?? "";
+		const fills = ctx.marks("hydro-volumes", "path", shapes, (shape) => shape.key).attr("fill", (shape) => ctx.palette.color(shape.key)).attr("fill-opacity", .2).style("pointer-events", "none");
+		ctx.set(fills, { d: (shape) => outline(shape, shape.high) }, { d: (shape) => outline(shape, shape.rest) });
+	}
+	/** Hours one hyetograph bar spans, which is the time base of its depth and of phi. */
+	barHours({ step }) {
+		return +(step * Math.max(1, Math.round(this.options.rainStep))).toFixed(2);
+	}
+	drawRainAxis(ctx, { depth, reading }, shown) {
+		const { width } = ctx.plot;
+		const axis = axisRight(depth).tickValues(shown ? depth.ticks(2) : []).tickSize(0).tickFormat((value) => fixed(+value));
+		Draft.axis(ctx, "axis-rain", axis, `translate(${width},0)`, false);
+		Draft.rules(ctx, "rain-datum", shown ? [{
+			x1: 0,
+			y1: 0,
+			x2: width,
+			y2: 0
+		}] : [], { stroke: ctx.theme.axis });
+		const title = {
+			text: `Rainfall (mm/${this.barHours(reading)} h)`,
+			x: width + 42,
+			y: 0,
+			anchor: "start",
+			rotate: 90
+		};
+		Draft.captions(ctx, "rain-title", shown ? [title] : []);
+	}
+	drawHits(ctx, { place, reading }, separated) {
+		const { width, height } = ctx.plot;
+		const { steps, dated } = reading;
+		const edge = (i) => i < 0 ? 0 : i >= steps.length - 1 ? width : (place(steps[i].t) + place(steps[i + 1].t)) / 2;
+		const cells = ctx.marks("hydro-hits", "rect", steps, (d) => d.t).attr("fill", "transparent").attr("x", (_, i) => edge(i - 1)).attr("y", 0).attr("width", (_, i) => Math.max(0, edge(i) - edge(i - 1))).attr("height", height);
+		ctx.hover(cells, (d) => ({
+			title: dated ? stamp(new Date(d.t)) : `Hour ${fixed(d.hours)}`,
+			color: ctx.palette.color("Streamflow"),
+			rows: [
+				["Discharge", `${fixed(d.q)} m³/s`],
+				...separated ? [["Baseflow", `${fixed(d.base)} m³/s`]] : [],
+				["Rainfall", `${fixed(d.rain)} mm`]
+			]
+		}));
+	}
+	drawRain(ctx, { place, depth, bins, phi, reading }) {
+		const peak = depth.domain()[1];
+		const parts = bins.filter((bin) => bin.depth > 0).flatMap((bin) => {
+			if (!phi) return [{
+				key: `${bin.key}`,
+				bin,
+				from: 0,
+				to: bin.depth,
+				loss: false,
+				end: true
+			}];
+			const held = Math.min(phi, bin.depth);
+			return [{
+				key: `${bin.key}/loss`,
+				bin,
+				from: 0,
+				to: held,
+				loss: true,
+				end: bin.depth <= phi
+			}, ...bin.depth > phi ? [{
+				key: `${bin.key}/excess`,
+				bin,
+				from: phi,
+				to: bin.depth,
+				loss: false,
+				end: true
+			}] : []];
+		});
+		const box = (part) => {
+			const left = place(part.bin.start), span = place(part.bin.stop) - left;
+			const gap = span >= 4 ? 2 : span >= 2.5 ? 1 : 0;
+			return {
+				x: left + gap / 2,
+				w: Math.max(1, span - gap)
+			};
+		};
+		const shape = (part, to) => {
+			const { x, w } = box(part);
+			const top = depth(part.from) + (part.from ? Math.min(2, depth(to) - depth(part.from)) : 0), bottom = depth(to);
+			const r = part.end ? Math.min(4, w / 2, bottom - top) : 0;
+			return `M${x},${top}H${x + w}V${bottom - r}Q${x + w},${bottom} ${x + w - r},${bottom}H${x + r}Q${x},${bottom} ${x},${bottom - r}Z`;
+		};
+		const bars = ctx.marks("hydro-rain", "path", parts, (part) => part.key).attr("fill", (part) => part.loss ? ctx.theme.inkMuted : ctx.palette.sequential(.4 + .6 * part.bin.depth / peak)).attr("fill-opacity", (part) => part.loss ? .55 : 1);
+		ctx.set(bars, { d: (part) => shape(part, part.to) }, { d: (part) => shape(part, part.from) }, 3);
+		ctx.hover(bars, (part) => ({
+			title: part.loss ? "Losses" : phi ? "Excess rainfall" : "Rainfall",
+			rows: [["Depth", `${fixed(part.to - part.from)} mm`], ["Bar total", `${fixed(part.bin.depth)} mm`]]
+		}));
+		const y = depth(phi);
+		Draft.rules(ctx, "hydro-phi", phi ? [{
+			x1: 0,
+			y1: y,
+			x2: ctx.plot.width,
+			y2: y
+		}] : [], {
+			stroke: ctx.theme.inkSecondary,
+			dash: "4 3"
+		});
+		Draft.captions(ctx, "hydro-phi-label", phi ? [{
+			text: `φ ${fixed(phi)} mm/${this.barHours(reading)} h`,
+			x: ctx.plot.width - 4,
+			y: y + 13,
+			anchor: "end",
+			tone: "ink"
+		}] : []).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+	}
+	/** The largest storm, with the centroid of the rain burst that fed its peak. */
+	main({ steps, step, events }) {
+		if (!events.length) return null;
+		const event = events.reduce((best, next) => steps[next.peak].q > steps[best.peak].q ? next : best);
+		let wettest = event.peak;
+		while (wettest >= 0 && !steps[wettest].rain) wettest--;
+		if (wettest < 0) return {
+			event,
+			centroid: null
+		};
+		let first = wettest;
+		for (let i = wettest - 1, dry = 0; i >= 0 && dry * step <= 6; i--) if (steps[i].rain > 0) {
+			first = i;
+			dry = 0;
+		} else dry++;
+		const burst = steps.slice(first, wettest + 1);
+		return {
+			event,
+			centroid: sum(burst, (d) => d.rain * (d.hours + step / 2)) / sum(burst, (d) => d.rain)
+		};
+	}
+	drawAnnotations(ctx, { place, level, reading, depth, bins }, main) {
+		const { steps, unit, events, runoff, bfi } = reading;
+		const graphical = [
+			BaseflowMethod.ConstantDischarge,
+			BaseflowMethod.ConstantSlope,
+			BaseflowMethod.Concave
+		].includes(this.options.baseflow);
+		const tops = main ? [main.event.peak] : [];
+		const crest = main ? steps[main.event.peak] : null;
+		const px = crest ? place(crest.t) : 0, py = crest ? level(crest.q) : 0;
+		const lag = crest && main?.centroid != null ? crest.hours - main.centroid : null;
+		const from = lag !== null ? place(crest.t - lag * unit) : px;
+		const shown = lag !== null && lag > 0 ? lag : null;
+		const fed = crest ? crest.t - (lag ?? 0) * unit : 0;
+		const hung = bins.find((bin) => fed >= bin.start && fed < bin.stop)?.depth ?? 0;
+		const span = shown === null ? [] : [{
+			x1: from,
+			y1: py,
+			x2: px,
+			y2: py
+		}, {
+			x1: from,
+			y1: Math.min(depth(hung) + 3, py),
+			x2: from,
+			y2: py
+		}];
+		Draft.rules(ctx, "hydro-lag", span, {
+			stroke: ctx.theme.inkSecondary,
+			dash: "3 3"
+		});
+		const dots = ctx.marks("hydro-peak", "circle", tops, (i) => i).attr("fill", ctx.palette.color("Streamflow")).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: px,
+			cy: py,
+			r: 5
+		}, {
+			cx: px,
+			cy: py,
+			r: 0
+		});
+		ctx.hover(dots, () => ({
+			title: "Peak of the storm",
+			color: ctx.palette.color("Streamflow"),
+			rows: [
+				["Discharge", `${fixed(crest.q)} m³/s`],
+				...shown === null ? [] : [["Lag", `${fixed(shown)} h`]],
+				...this.options.baseflow === BaseflowMethod.None ? [] : [["Direct runoff", `${fixed(runoff)} mm`], ["Baseflow index", fixed(bfi)]]
+			]
+		}));
+		const stops = main && graphical ? events.flatMap((event) => [event.rise, event.end]) : [];
+		const pins = ctx.marks("hydro-stops", "circle", stops, (_, i) => i).attr("fill", ctx.theme.surface).attr("stroke", ctx.palette.color("Streamflow")).attr("stroke-width", 2);
+		ctx.set(pins, {
+			cx: (i) => place(steps[i].t),
+			cy: (i) => level(steps[i].q),
+			r: 4
+		});
+		ctx.hover(pins, (i) => ({
+			title: events.some((event) => event.rise === i) ? "Rise of direct runoff" : "End of direct runoff",
+			rows: [["Discharge", `${fixed(steps[i].q)} m³/s`]]
+		}));
+		const peakText = crest ? `Peak ${fixed(crest.q)} m³/s${shown === null ? "" : `, lag ${fixed(shown)} h`}` : "";
+		const fitsRight = px + 12 + peakText.length * 6.2 <= ctx.plot.width;
+		const notes = !crest ? [] : [fitsRight ? {
+			text: peakText,
+			x: px + 10,
+			y: py + 4,
+			anchor: "start",
+			tone: "ink"
+		} : {
+			text: peakText,
+			x: px - 10,
+			y: py + 4,
+			anchor: "end",
+			tone: "ink"
+		}];
+		Draft.captions(ctx, "hydro-notes", Draft.declutter(notes, ctx.plot.width, ctx.plot.height)).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+	}
+	table() {
+		const { steps, dated } = this.read();
+		const separated = this.options.baseflow !== BaseflowMethod.None;
+		return {
+			columns: [
+				"time",
+				"flow",
+				"rain",
+				...separated ? ["baseflow"] : []
+			],
+			rows: steps.map((d) => [
+				dated ? new Date(d.t) : d.t,
+				d.q,
+				d.rain,
+				...separated ? [d.base] : []
+			])
+		};
+	}
+};
+export { Hydrograph };

package/dist/charts/earthscience/SimplexContours.js

@@ -0,0 +1,94 @@
+// src/charts/earthscience/SimplexContours.ts
+var DIVISIONS = 40;
+/**
+* Marching triangles on a subdivided simplex. Working on triangles rather than a pixel grid
+* means bands end exactly on the frame, with no staircase along the sloping sides.
+*/
+var SimplexContours = class {
+	#points = [];
+	#values = [];
+	#triangles = [];
+	lowest;
+	highest;
+	constructor(simplex, surface, n = DIVISIONS) {
+		const index = [];
+		for (let i = 0; i <= n; i++) {
+			index[i] = [];
+			for (let j = 0; j <= n - i; j++) {
+				const a = i / n, b = j / n, c = (n - i - j) / n;
+				index[i][j] = this.#points.length;
+				this.#points.push(simplex.at(a, b, c));
+				this.#values.push(surface(a, b, c));
+			}
+		}
+		for (let i = 0; i < n; i++) for (let j = 0; j < n - i; j++) {
+			this.#triangles.push([
+				index[i][j],
+				index[i + 1][j],
+				index[i][j + 1]
+			]);
+			if (i + j < n - 1) this.#triangles.push([
+				index[i + 1][j],
+				index[i + 1][j + 1],
+				index[i][j + 1]
+			]);
+		}
+		this.lowest = Math.min(...this.#values);
+		this.highest = Math.max(...this.#values);
+	}
+	#cross(from, to, level) {
+		const t = (level - this.#values[from]) / (this.#values[to] - this.#values[from]);
+		const p = this.#points[from], q = this.#points[to];
+		return [p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t];
+	}
+	/** Path of everything at or above `level`. Painting levels low to high leaves no seams between bands. */
+	band(level) {
+		let d = "";
+		for (const corners of this.#triangles) {
+			const shape = [];
+			corners.forEach((corner, k) => {
+				const next = corners[(k + 1) % 3];
+				const inside = this.#values[corner] >= level, onward = this.#values[next] >= level;
+				if (inside) shape.push(this.#points[corner]);
+				if (inside !== onward) shape.push(this.#cross(corner, next, level));
+			});
+			if (shape.length > 2) d += `M${shape.map(([x, y]) => `${x.toFixed(1)},${y.toFixed(1)}`).join("L")}Z`;
+		}
+		return d;
+	}
+	/** The isoline at `level`, stitched into chains across triangles. */
+	lines(level) {
+		const places = /* @__PURE__ */ new Map();
+		const links = /* @__PURE__ */ new Map();
+		const link = (from, to) => {
+			const list = links.get(from);
+			if (list) list.push(to);
+			else links.set(from, [to]);
+		};
+		for (const corners of this.#triangles) {
+			const hits = [];
+			corners.forEach((corner, k) => {
+				const next = corners[(k + 1) % 3];
+				if (this.#values[corner] >= level === this.#values[next] >= level) return;
+				const key = `${Math.min(corner, next)}/${Math.max(corner, next)}`;
+				if (!places.has(key)) places.set(key, this.#cross(corner, next, level));
+				hits.push(key);
+			});
+			if (hits.length === 2) {
+				link(hits[0], hits[1]);
+				link(hits[1], hits[0]);
+			}
+		}
+		const visited = /* @__PURE__ */ new Set();
+		const walk = (start) => {
+			const chain = [];
+			for (let at = start; at && !visited.has(at); at = links.get(chain.at(-1)).find((next) => !visited.has(next))) {
+				visited.add(at);
+				chain.push(at);
+			}
+			return chain.map((key) => places.get(key));
+		};
+		return [...[...links.keys()].filter((key) => links.get(key).length === 1), ...links.keys()].flatMap((key) => visited.has(key) ? [] : [walk(key)]).filter((chain) => chain.length > 1);
+	}
+};
+export { SimplexContours };