@classytic/labs 0.3.0 → 0.4.0

package/dist/physics/vector-board/preset.mjs

@@ -7,8 +7,8 @@ import { HintLadder, useHints } from "../../kit/pedagogy.mjs";
 import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../kit/authored-activity-runtime.mjs";
 import { SceneSurface } from "../mechanics/presentation.mjs";
 import { AngleArc, LabeledVector, RightAngleMark } from "../../kit/diagram/annotations.mjs";
-import { PlaneAxes, dotZone } from "../../kit/coords.mjs";
-import { Fragment, useEffect, useMemo, useState } from "react";
+import { PlaneAxes, clearOfLabel, dotZone } from "../../kit/coords.mjs";
+import { useEffect, useMemo, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Label, MovableDot, Segment, Stage, Vector, vec } from "@classytic/stage";
 
@@ -211,6 +211,82 @@ function VectorBoardLab({ view: viewProp, vectors, combine = "sum", resultantLab
 	const resDeg = resultant ? Math.round(toDeg(vec.angle(resultant))) : 0;
 	const resColor = solved ? "var(--stage-good)" : resultantColor;
 	const showResultant = !!resultant && !(combine === "sum" && vectors.length === 1);
+	const LABEL_SIZE = 12;
+	/**
+	* Where each magnitude label sits, resolved BEFORE anything is drawn.
+	*
+	* Two things went wrong when the offset was a flat 26px perpendicular. A wide label on a
+	* diagonal shaft still straddled the arrow, because 26px clears the line at the label's
+	* CENTRE and says nothing about its ends: "|(2/5)AB| = 5.7" is ~110px of text pushed off a
+	* 45° arrow, so both ends came back over it. And the flip that pushes a label away from the
+	* resultant reads a dot product that is exactly ZERO when the vector is parallel to the
+	* resultant, which is the normal case in chain mode, so the coin landed on the arrow.
+	*
+	* The offset is now the label box's own support in the perpendicular direction (half-width
+	* and half-height, each weighted by how much of that axis the perpendicular points along)
+	* plus a margin, so a long label moves further than a short one and no label can reach back
+	* across its shaft. The degenerate flip falls back to the side away from the origin, which is
+	* the empty half of the frame in a chain.
+	*/
+	const vectorLabels = vectors.flatMap((v, i) => {
+		const c = comps[i];
+		if (!c) return [];
+		const t = tailOf(i);
+		const magStr = vec.mag(c).toFixed(1);
+		const text = v.label ? show.magnitude ? `|${v.label}| = ${magStr}` : v.label : show.magnitude ? magStr : "";
+		if (!text) return [];
+		const at = {
+			x: t.x + c.x * .62,
+			y: t.y + c.y * .62
+		};
+		const L = Math.hypot(c.x, c.y) || 1;
+		let pmx = -c.y / L;
+		let pmy = c.x / L;
+		const ref = resultant ?? {
+			x: c.x,
+			y: c.y
+		};
+		const awayFrom = pmx * (ref.x - at.x) + pmy * (ref.y - at.y);
+		const towardsOrigin = pmx * -at.x + pmy * -at.y;
+		if (awayFrom > 1e-6 || Math.abs(awayFrom) <= 1e-6 && towardsOrigin > 0) {
+			pmx = -pmx;
+			pmy = -pmy;
+		}
+		const halfW = text.length * LABEL_SIZE * .58 / 2 + 3;
+		const push = Math.abs(pmx) * halfW + Math.abs(pmy) * 8 + 6;
+		return [{
+			key: v.id ?? i,
+			tail: t,
+			comp: c,
+			color: v.color ?? PALETTE[i % PALETTE.length],
+			text,
+			at,
+			dx: pmx * push,
+			dy: -pmy * push
+		}];
+	});
+	/**
+	* Everything the axis numbers must print around: the drag handles, and every label the board
+	* draws. A magnitude label pushed clear of its own shaft can still land on a tick number, and
+	* "|a| = 3.2" printed over the x axis "4" is unreadable twice over.
+	*/
+	const keepClear = [
+		...comps.map((c, i) => dotZone({
+			x: tailOf(i).x + c.x,
+			y: tailOf(i).y + c.y
+		})),
+		...resultant ? [dotZone(resultant)] : [],
+		...vectorLabels.map((l) => clearOfLabel(l.at.x, l.at.y, l.text, {
+			size: LABEL_SIZE,
+			dx: l.dx,
+			dy: l.dy
+		})),
+		...resultant && showResultant ? [clearOfLabel(resultant.x, resultant.y, resultantLabel, {
+			size: 13,
+			dx: 12,
+			dy: -10
+		})] : []
+	];
 	const misconception = goal && !solved && resultant && Math.abs(vec.mag(resultant) - vec.mag(goal.match)) < tol ? "Right length, now fix the direction (rotate it onto the target)." : void 0;
 	const figure = /* @__PURE__ */ jsx(SceneSurface, {
 		className: "physics-vector-board-scene",
@@ -223,10 +299,7 @@ function VectorBoardLab({ view: viewProp, vectors, combine = "sum", resultantLab
 			children: [
 				/* @__PURE__ */ jsx(PlaneAxes, {
 					labels: true,
-					keepClear: [...comps.map((c, i) => dotZone({
-						x: tailOf(i).x + c.x,
-						y: tailOf(i).y + c.y
-					})), ...resultant ? [dotZone(resultant)] : []]
+					keepClear
 				}),
 				goal && /* @__PURE__ */ jsx(Vector, {
 					tail: ORIGIN,
@@ -251,42 +324,23 @@ function VectorBoardLab({ view: viewProp, vectors, combine = "sum", resultantLab
 					opacity: .6
 				})] }),
 				vectors.map((v, i) => {
-					const col = v.color ?? PALETTE[i % PALETTE.length];
 					const c = comps[i];
 					if (!c) return null;
-					const t = tailOf(i);
-					const magStr = vec.mag(c).toFixed(1);
-					const text = v.label ? show.magnitude ? `|${v.label}| = ${magStr}` : v.label : show.magnitude ? magStr : "";
-					const at = {
-						x: t.x + c.x * .62,
-						y: t.y + c.y * .62
-					};
-					const L = Math.hypot(c.x, c.y) || 1;
-					let pmx = -c.y / L, pmy = c.x / L;
-					const ref = resultant ?? {
-						x: c.x,
-						y: c.y
-					};
-					if (pmx * (ref.x - at.x) + pmy * (ref.y - at.y) > 0) {
-						pmx = -pmx;
-						pmy = -pmy;
-					}
-					const dx = pmx * 26;
-					const dy = -pmy * 26;
-					return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(LabeledVector, {
-						tail: t,
+					return /* @__PURE__ */ jsx(LabeledVector, {
+						tail: tailOf(i),
 						comp: c,
-						color: col
-					}), text && /* @__PURE__ */ jsx(Label, {
-						x: at.x,
-						y: at.y,
-						text,
-						color: col,
-						dx,
-						dy,
-						size: 12
-					})] }, v.id ?? i);
+						color: v.color ?? PALETTE[i % PALETTE.length]
+					}, v.id ?? i);
 				}),
+				vectorLabels.map((l) => /* @__PURE__ */ jsx(Label, {
+					x: l.at.x,
+					y: l.at.y,
+					text: l.text,
+					color: l.color,
+					dx: l.dx,
+					dy: l.dy,
+					size: LABEL_SIZE
+				}, `l${l.key}`)),
 				resultant && /* @__PURE__ */ jsxs(Fragment$1, { children: [
 					show.components && /* @__PURE__ */ jsxs(Fragment$1, { children: [
 						/* @__PURE__ */ jsx(Segment, {
@@ -432,4 +486,4 @@ function VectorBoardLab({ view: viewProp, vectors, combine = "sum", resultantLab
 }
 
 //#endregion
-export { VectorBoardLab };
+export { VectorBoardLab, dragTo };

package/dist/physics/vector-types/index.d.mts

@@ -1 +1,2 @@
-import { TypePanel, VectorTypesLab, VectorTypesProps } from "./preset.mjs";
+import { TypePanel, VectorTypesLab, VectorTypesProps } from "./preset.mjs";
+export { type TypePanel, VectorTypesLab, type VectorTypesProps };

package/dist/physics/vector-types/preset.d.mts

@@ -1,7 +1,6 @@
 import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
 import { ReactNode } from "react";
 import { Vec2 } from "@classytic/stage";
-
 //#region src/physics/vector-types/preset.d.ts
 interface PanelVec {
   tail?: Vec2;
@@ -23,12 +22,6 @@ interface VectorTypesProps {
   objectives?: string[];
   activity?: string | AuthoredActivity;
 }
-declare function VectorTypesLab({
-  types,
-  title,
-  prompt,
-  objectives,
-  activity
-}: VectorTypesProps): ReactNode;
+declare function VectorTypesLab({ types, title, prompt, objectives, activity }: VectorTypesProps): ReactNode;
 //#endregion
 export { TypePanel, VectorTypesLab, VectorTypesProps };

package/dist/physics/venturi/core.mjs

@@ -64,4 +64,4 @@ function throat(f) {
 }
 
 //#endregion
-export { PIPE, headAt, radiusAt, speedAt, throat };
+export { G, PIPE, WATER_DENSITY, headAt, pressureDrop, radiusAt, speedAt, throat };

package/dist/physics/venturi/index.d.mts

@@ -1 +1,2 @@
-import { VenturiLab, VenturiProps } from "./preset.mjs";
+import { VenturiLab, VenturiProps } from "./preset.mjs";
+export { VenturiLab, type VenturiProps };

package/dist/physics/venturi/preset.d.mts

@@ -1,5 +1,4 @@
 import { ReactNode } from "react";
-
 //#region src/physics/venturi/preset.d.ts
 interface VenturiProps {
   /** Water speed in the wide pipe, m/s. */
@@ -14,14 +13,6 @@ interface VenturiProps {
   prompt?: string;
   activity?: string;
 }
-declare function VenturiLab({
-  inletSpeed: initialSpeed,
-  throatRatio: initialRatio,
-  inletHead,
-  predict,
-  title,
-  prompt,
-  activity
-}?: VenturiProps): ReactNode;
+declare function VenturiLab({ inletSpeed: initialSpeed, throatRatio: initialRatio, inletHead, predict, title, prompt, activity }?: VenturiProps): ReactNode;
 //#endregion
 export { VenturiLab, VenturiProps };

package/dist/physics/venturi/preset.mjs

@@ -130,7 +130,8 @@ function VenturiLab({ inletSpeed: initialSpeed = 1, throatRatio: initialRatio =
 	const perRow = 18;
 	ROWS.forEach((row, ri) => {
 		for (let i = 0; i < perRow; i++) {
-			const x = positionAt(table, clock + table.total * (i + ri * .37) / perRow);
+			const tau = clock + table.total * (i + ri * .37) / perRow;
+			const x = positionAt(table, tau);
 			const v = speedAt(flow, x);
 			const y = AXIS_Y + row * radiusAt(x, ratio) * R1 * K;
 			const len = Math.min(26, 3 + v * 5);

package/dist/physics/water-density/index.d.mts

@@ -1 +1,2 @@
-import { WaterDensityLab, WaterDensityProps } from "./preset.mjs";
+import { WaterDensityLab, WaterDensityProps } from "./preset.mjs";
+export { WaterDensityLab, type WaterDensityProps };

package/dist/physics/water-density/preset.d.mts

@@ -1,6 +1,5 @@
 import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
 import { ReactNode } from "react";
-
 //#region src/physics/water-density/preset.d.ts
 type Mode = 'anomaly' | 'lake';
 interface WaterDensityProps {
@@ -10,12 +9,6 @@ interface WaterDensityProps {
   objectives?: string[];
   activity?: string | AuthoredActivity;
 }
-declare function WaterDensityLab({
-  mode: mode0,
-  title,
-  prompt,
-  objectives,
-  activity
-}?: WaterDensityProps): ReactNode;
+declare function WaterDensityLab({ mode: mode0, title, prompt, objectives, activity }?: WaterDensityProps): ReactNode;
 //#endregion
 export { WaterDensityLab, WaterDensityProps };

package/dist/physics/water-density/preset.mjs

@@ -7,6 +7,7 @@ import { thermalColor } from "../../kit/thermal.mjs";
 import { ThermalActivity } from "../thermal/activity.mjs";
 import { useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { waterDensityKgM3 } from "@classytic/stage/thermo";
 
 //#region src/physics/water-density/preset.tsx
 /**
@@ -24,30 +25,22 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 * If water behaved "normally", lakes would freeze solid from the bottom up and kill
 * everything in them. Interactive, no simulation loop. Pure SVG, themed.
 */
-const W = 640, H = 360;
-const SAMPLES = [
-	[0, 999.84],
-	[1, 999.9],
-	[2, 999.94],
-	[3, 999.96],
-	[4, 999.97],
-	[5, 999.96],
-	[6, 999.94],
-	[8, 999.85],
-	[10, 999.7],
-	[15, 999.1],
-	[20, 998.2],
-	[25, 997.05]
-];
+const W = 640;
+const H = 360;
 const ICE_RHO = 916.7;
-const T_MAX = 25, RHO_LO = 997, RHO_HI = 1000.15;
+const T_MAX = 25;
+const RHO_LO = 997;
+/**
+* Density of liquid water at t °C, clamped to the window this lesson draws.
+*
+* This was a twelve-point sample table interpolated linearly, which put
+* visible corners in a curve whose whole point is that it is smooth and turns
+* over. `waterDensityKgM3` is the Thiesen-Scheel-Diesselhorst fit, accurate to
+* about one part in 10^5 across the liquid range, so the peak now sits at the
+* measured 3.9863 °C rather than at whichever sample happened to be highest.
+*/
 function densityOf(t) {
-	const tc = Math.max(0, Math.min(T_MAX, t));
-	for (let i = 0; i < SAMPLES.length - 1; i++) {
-		const [t0, r0] = SAMPLES[i], [t1, r1] = SAMPLES[i + 1];
-		if (tc <= t1) return r0 + (r1 - r0) * ((tc - t0) / (t1 - t0));
-	}
-	return SAMPLES[SAMPLES.length - 1][1];
+	return waterDensityKgM3(Math.max(0, Math.min(T_MAX, t)));
 }
 function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C anomaly: why ice floats", prompt = "Almost everything shrinks as it cools, but water is densest at 4 °C and expands again toward freezing, so ice floats and lakes freeze from the top down.", objectives = [
 	"See water reach maximum density at about 4 °C (not at 0 °C)",
@@ -57,12 +50,16 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 	const [mode, setMode] = useState(mode0);
 	const [tC, setTC] = useState(12);
 	const GX0 = 70, GX1 = 600, GY0 = 40, GY1 = 300;
-	const PX = (t) => GX0 + t / T_MAX * (GX1 - GX0);
-	const PY = (r) => GY1 - (r - RHO_LO) / (RHO_HI - RHO_LO) * (GY1 - GY0);
+	const PX = (t) => GX0 + t / T_MAX * 530;
+	const PY = (r) => GY1 - (r - RHO_LO) / 3.1499999999999773 * 260;
 	const rho = densityOf(tC);
 	let figure;
 	if (mode === "anomaly") {
-		const curve = SAMPLES.map(([t, r]) => `${PX(t).toFixed(1)},${PY(r).toFixed(1)}`).join(" ");
+		const CURVE_SAMPLES = 100;
+		const curve = Array.from({ length: 101 }, (_, i) => {
+			const t = i / CURVE_SAMPLES * T_MAX;
+			return `${PX(t).toFixed(1)},${PY(densityOf(t)).toFixed(1)}`;
+		}).join(" ");
 		figure = /* @__PURE__ */ jsx(SceneSurface, {
 			className: "physics-water-density-scene",
 			children: /* @__PURE__ */ jsxs("svg", {
@@ -89,14 +86,14 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 					}),
 					/* @__PURE__ */ jsx("text", {
 						x: GX0,
-						y: GY0 - 12,
+						y: 28,
 						textAnchor: "start",
 						fontSize: 12,
 						fill: "var(--stage-muted)",
 						children: "density (zoomed)"
 					}),
 					/* @__PURE__ */ jsx("text", {
-						x: 670 / 2,
+						x: 335,
 						y: 332,
 						textAnchor: "middle",
 						fontSize: 13,
@@ -179,7 +176,6 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 		});
 	} else {
 		const lx = 72, rx = 520, top = 60, bot = 300;
-		const iceBot = 94;
 		figure = /* @__PURE__ */ jsx(SceneSurface, {
 			className: "physics-water-density-scene",
 			children: /* @__PURE__ */ jsxs("svg", {
@@ -190,21 +186,21 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 				children: [
 					/* @__PURE__ */ jsx("rect", {
 						x: lx,
-						y: top - 30,
-						width: rx - lx,
+						y: 30,
+						width: 448,
 						height: 30,
 						fill: "color-mix(in oklab, var(--stage-accent) 8%, var(--stage-bg))"
 					}),
 					/* @__PURE__ */ jsx("text", {
 						x: 80,
-						y: top - 12,
+						y: 48,
 						fontSize: 14,
 						fill: "var(--stage-muted)",
 						children: "cold air"
 					}),
 					[
 						{
-							y0: iceBot,
+							y0: 94,
 							y1: 150,
 							t: 0,
 							label: "0 °C"
@@ -230,7 +226,7 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 					].map((b, i) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("rect", {
 						x: lx,
 						y: b.y0,
-						width: rx - lx,
+						width: 448,
 						height: b.y1 - b.y0,
 						fill: thermalColor(b.t / T_MAX),
 						opacity: .4
@@ -246,8 +242,8 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 					/* @__PURE__ */ jsx("rect", {
 						x: lx,
 						y: top,
-						width: rx - lx,
-						height: iceBot - top,
+						width: 448,
+						height: 34,
 						fill: "color-mix(in oklab, var(--stage-accent) 14%, var(--stage-bg))",
 						stroke: "color-mix(in oklab, var(--stage-accent) 52%, transparent)",
 						strokeWidth: 1.5
@@ -290,18 +286,18 @@ function WaterDensityLab({ mode: mode0 = "anomaly", title = "Water’s 4 °C ano
 						strokeWidth: 3
 					}),
 					/* @__PURE__ */ jsx("path", {
-						d: `M 594 225 V ${bot - 24}`,
+						d: `M 594 225 V 276`,
 						stroke: "var(--stage-good)",
 						strokeWidth: "2"
 					}),
 					/* @__PURE__ */ jsx("path", {
-						d: `M 587 ${bot - 32} L 594 ${bot - 20} L 601 ${bot - 32}`,
+						d: `M 587 268 L 594 280 L 601 268`,
 						fill: "none",
 						stroke: "var(--stage-good)",
 						strokeWidth: "2"
 					}),
 					/* @__PURE__ */ jsx("text", {
-						x: W - 16,
+						x: 624,
 						y: 320,
 						textAnchor: "end",
 						fontSize: 12,

package/dist/physics/waves/doppler-core.d.mts

@@ -0,0 +1,106 @@
+//#region src/physics/waves/doppler-core.d.ts
+/**
+ * The Doppler effect: moving source, moving observer, and the wall at Mach 1.
+ *
+ * This was the one piece of physics in the package still living inside a component
+ * (`waves/doppler.tsx`, in the frame loop), which meant it could not be unit tested, could not be
+ * reused by a question generator, and could not be driven by anything other than that lab's own
+ * animation. Every other engine here is a pure kernel with a test beside it; this brings the last
+ * one into line.
+ *
+ * ── The two cases are NOT the same formula ──────────────────────────────────────────────────────
+ * 9702 topic 7 asks only for the moving SOURCE, and that is the one students meet:
+ *
+ *     moving source,   still observer:   f_o = f_s * v / (v -+ v_s)
+ *     moving observer, still source:     f_o = f_s * (v +- v_o) / v
+ *
+ * They give different answers for the same relative speed, and that is the point rather than a
+ * footnote: a moving source changes the WAVELENGTH in the medium, because each crest leaves from a
+ * point further along than the last. A moving observer meets an unchanged wave more often. The
+ * medium is not symmetric between them, which is exactly why sound is not relativity.
+ *
+ * ── The asymmetry that gets asked ──────────────────────────────────────────────────────────────
+ * Approaching raises the pitch by MORE than receding lowers it, because the source speed divides in
+ * one case and adds in the other. At 0.5 v it is 2 f_s coming and 0.67 f_s going, so the rise is
+ * three times the fall. `frequencyShiftAsymmetry` returns both so a lab can show it rather than
+ * assert it.
+ *
+ * ── Mach 1 is a real divergence, not a guard ───────────────────────────────────────────────────
+ * As v_s approaches v the denominator goes to zero and the predicted frequency to infinity. That is
+ * not a numerical problem to be clamped away: every crest arrives at once, which is the shock wave.
+ * `observedFrequencyMovingSource` returns `Infinity` at exactly Mach 1 and the caller decides what
+ * to draw, because a lab that silently clamps teaches that nothing special happens there.
+ */
+interface Vec2 {
+  readonly x: number;
+  readonly y: number;
+}
+/**
+ * Component of a velocity along the line from source to observer, positive when closing.
+ *
+ * This is what turns the one-dimensional textbook formula into something a scene can use: only the
+ * radial part shifts the pitch, so a source passing to one side is at its unshifted frequency at
+ * the moment of closest approach, when all of its motion is transverse. That instant is the thing a
+ * learner should see and almost never does.
+ */
+declare function radialSpeed(source: Vec2, observer: Vec2, velocity: Vec2): number;
+/**
+ * Observed frequency for a source moving through a still medium: `f_s v / (v - v_r)`.
+ *
+ * `radialSourceSpeed` is positive when the source is closing on the observer. Returns `Infinity` at
+ * exactly Mach 1 (see the header) and a NEGATIVE frequency above it, which is the honest reading of
+ * the formula in a regime where it no longer describes anything: past the sound barrier the wave
+ * arrives before the source does, and this expression stops being the right model. Callers should
+ * branch on `machNumber >= 1` rather than trusting the number.
+ */
+declare function observedFrequencyMovingSource(sourceFrequency: number, waveSpeed: number, radialSourceSpeed: number): number;
+/**
+ * Observed frequency for an observer moving through a still medium: `f_s (v + v_r) / v`.
+ *
+ * Note the different shape: this one cannot diverge, because the observer cannot outrun the wave
+ * into a zero denominator. Racing away at exactly the wave speed gives zero, which is right, as the
+ * crests never catch up.
+ */
+declare function observedFrequencyMovingObserver(sourceFrequency: number, waveSpeed: number, radialObserverSpeed: number): number;
+/**
+ * Both moving, the general case: `f_s (v + v_o) / (v - v_s)`.
+ *
+ * Provided because a scene with a moving listener needs it, not because the syllabus asks. Radial
+ * speeds are positive when closing, for both.
+ */
+declare function observedFrequency(sourceFrequency: number, waveSpeed: number, radialSourceSpeed: number, radialObserverSpeed?: number): number;
+/** Wavelength in the medium ahead of a moving source: `(v - v_s) / f_s`. Goes to zero at Mach 1. */
+declare function wavelengthAhead(sourceFrequency: number, waveSpeed: number, sourceSpeed: number): number;
+/** Wavelength behind a moving source: `(v + v_s) / f_s`. */
+declare function wavelengthBehind(sourceFrequency: number, waveSpeed: number, sourceSpeed: number): number;
+/**
+ * The rise coming and the fall going, as multiples of the source frequency.
+ *
+ * Returns `{ approaching, receding, riseOverFall }`. The third number is the one worth showing: it
+ * is never 1, and it grows with speed, so "the pitch drops as it passes" is only half the story.
+ */
+declare function frequencyShiftAsymmetry(waveSpeed: number, sourceSpeed: number): {
+  approaching: number;
+  receding: number;
+  riseOverFall: number;
+};
+/** Mach number: source speed as a multiple of the wave speed. */
+declare function machNumber(sourceSpeed: number, waveSpeed: number): number;
+/**
+ * Half-angle of the Mach cone, radians: `asin(1 / M)`.
+ *
+ * `null` below Mach 1, because there is no cone: the wavefronts still nest inside one another and
+ * nothing piles up. Returning null rather than NaN lets a scene ask "is there a cone" by asking.
+ */
+declare function machConeHalfAngle(mach: number): number | null;
+/** Radius a wavefront has reached, given when it left and the time now. */
+declare function wavefrontRadius(waveSpeed: number, emittedAt: number, now: number): number;
+/**
+ * Speed of a source from a measured frequency shift, which is the direction the astronomy and radar
+ * uses run in: you have `f_o` and want `v`.
+ *
+ * `v_s = v (1 - f_s / f_o)`, positive when closing.
+ */
+declare function sourceSpeedFromShift(sourceFrequency: number, observedFrequency: number, waveSpeed: number): number;
+//#endregion
+export { Vec2, frequencyShiftAsymmetry, machConeHalfAngle, machNumber, observedFrequency, observedFrequencyMovingObserver, observedFrequencyMovingSource, radialSpeed, sourceSpeedFromShift, wavefrontRadius, wavelengthAhead, wavelengthBehind };