@classytic/stage 0.1.0

package/dist/core/motion.d.mts

@@ -0,0 +1,73 @@
+//#region src/core/motion.d.ts
+/**
+ * Motion core — the "physics of feel" layer. Pure, dependency-free functions that
+ * turn time into eased / springy / oscillating values. They consume the `dtMs`
+ * (or `timeMs`) you already receive from `useFrameLoop`; they do NOT own a loop,
+ * schedule frames, or touch React — so they stay deterministic (same time → same
+ * value) and work identically under a Remotion fixed-frame driver.
+ *
+ * Discipline (mirrors clock.ts): for video-determinism prefer the time-driven
+ * helpers (`oscillate`, `timeline`) that are a pure function of `timeMs`. `spring`
+ * is stateful (it integrates a velocity) — fine for interactive feel, but it will
+ * not reproduce frame-for-frame across drivers, so don't use it for rendered video.
+ */
+/** Snap-to-end gate: honor the user's reduced-motion preference (SSR-safe). */
+declare function prefersReducedMotion(): boolean;
+declare const ease: {
+  readonly linear: (t: number) => number;
+  readonly quadInOut: (t: number) => number;
+  readonly cubicIn: (t: number) => number;
+  readonly cubicOut: (t: number) => number;
+  readonly cubicInOut: (t: number) => number;
+  readonly quintOut: (t: number) => number;
+  readonly sineInOut: (t: number) => number; /** Overshoots then settles — good for "pop" on appear. */
+  readonly backOut: (t: number) => number; /** Springy overshoot with decaying wobble — for playful reveals. */
+  readonly elasticOut: (t: number) => number;
+};
+type EaseName = keyof typeof ease;
+type EaseFn = (t: number) => number;
+/** Linear interpolate; the building block under `timeline`. */
+declare function lerp(a: number, b: number, t: number): number;
+interface SpringOpts {
+  /** Pull toward target (higher = snappier). Default 170. */
+  stiffness?: number;
+  /** Velocity drag (higher = less overshoot). Default 26 ≈ critically damped at 170. */
+  damping?: number;
+}
+/**
+ * Advance one spring step toward `target`, returning the next position and
+ * MUTATING `vel.current` (keep one `useRef({current:0})` per animated value).
+ * Semi-implicit Euler with a clamped dt so a long frame gap can't explode it.
+ * Reduced-motion callers should snap to `target` instead of stepping.
+ */
+declare function spring(current: number, target: number, vel: {
+  current: number;
+}, dtSec: number, opts?: SpringOpts): number;
+type WaveShape = 'sine' | 'square' | 'triangle' | 'saw';
+interface OscillateOpts {
+  /** Peak magnitude. Default 1. */
+  amp?: number;
+  /** Cycles per second. Default 1. */
+  freq?: number;
+  /** Phase offset in cycles (0..1). Default 0. */
+  phase?: number;
+  shape?: WaveShape;
+}
+/** A pure periodic signal of `timeSec` — the engine under AC sources, pendulums, waves. */
+declare function oscillate(timeSec: number, opts?: OscillateOpts): number;
+interface Keyframe {
+  /** Absolute time on the timeline, seconds. */
+  t: number;
+  /** Value at this key. */
+  v: number;
+  /** Easing into this key from the previous one. Default linear. */
+  ease?: EaseFn;
+}
+/**
+ * Value of a keyframed track at `timeSec`. Before the first key → its value;
+ * after the last → its value; between → eased interpolation. Keys must be sorted
+ * by `t`. Use for reveal-on-action choreography (sweep a tangent, fade step 2 in).
+ */
+declare function timeline(timeSec: number, keys: Keyframe[]): number;
+//#endregion
+export { EaseFn, EaseName, Keyframe, OscillateOpts, SpringOpts, WaveShape, ease, lerp, oscillate, prefersReducedMotion, spring, timeline };

package/dist/core/motion.mjs

@@ -0,0 +1,103 @@
+//#region src/core/motion.ts
+/**
+* Motion core — the "physics of feel" layer. Pure, dependency-free functions that
+* turn time into eased / springy / oscillating values. They consume the `dtMs`
+* (or `timeMs`) you already receive from `useFrameLoop`; they do NOT own a loop,
+* schedule frames, or touch React — so they stay deterministic (same time → same
+* value) and work identically under a Remotion fixed-frame driver.
+*
+* Discipline (mirrors clock.ts): for video-determinism prefer the time-driven
+* helpers (`oscillate`, `timeline`) that are a pure function of `timeMs`. `spring`
+* is stateful (it integrates a velocity) — fine for interactive feel, but it will
+* not reproduce frame-for-frame across drivers, so don't use it for rendered video.
+*/
+/** Snap-to-end gate: honor the user's reduced-motion preference (SSR-safe). */
+function prefersReducedMotion() {
+	return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+const clamp01 = (t) => t < 0 ? 0 : t > 1 ? 1 : t;
+const ease = {
+	linear: (t) => clamp01(t),
+	quadInOut: (t) => {
+		t = clamp01(t);
+		return t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+	},
+	cubicIn: (t) => clamp01(t) ** 3,
+	cubicOut: (t) => 1 - (1 - clamp01(t)) ** 3,
+	cubicInOut: (t) => {
+		t = clamp01(t);
+		return t < .5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+	},
+	quintOut: (t) => 1 - (1 - clamp01(t)) ** 5,
+	sineInOut: (t) => -(Math.cos(Math.PI * clamp01(t)) - 1) / 2,
+	/** Overshoots then settles — good for "pop" on appear. */
+	backOut: (t) => {
+		const c1 = 1.70158;
+		const c3 = 2.70158;
+		t = clamp01(t);
+		return 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2;
+	},
+	/** Springy overshoot with decaying wobble — for playful reveals. */
+	elasticOut: (t) => {
+		t = clamp01(t);
+		if (t === 0 || t === 1) return t;
+		const p = 2 * Math.PI / 3;
+		return 2 ** (-10 * t) * Math.sin((t * 10 - .75) * p) + 1;
+	}
+};
+/** Linear interpolate; the building block under `timeline`. */
+function lerp(a, b, t) {
+	return a + (b - a) * t;
+}
+/**
+* Advance one spring step toward `target`, returning the next position and
+* MUTATING `vel.current` (keep one `useRef({current:0})` per animated value).
+* Semi-implicit Euler with a clamped dt so a long frame gap can't explode it.
+* Reduced-motion callers should snap to `target` instead of stepping.
+*/
+function spring(current, target, vel, dtSec, opts = {}) {
+	const stiffness = opts.stiffness ?? 170;
+	const damping = opts.damping ?? 26;
+	const dt = Math.min(.064, Math.max(0, dtSec));
+	const accel = -stiffness * (current - target) - damping * vel.current;
+	vel.current += accel * dt;
+	return current + vel.current * dt;
+}
+/** A pure periodic signal of `timeSec` — the engine under AC sources, pendulums, waves. */
+function oscillate(timeSec, opts = {}) {
+	const { amp = 1, freq = 1, phase = 0, shape = "sine" } = opts;
+	const turns = freq * timeSec + phase;
+	const frac = turns - Math.floor(turns);
+	switch (shape) {
+		case "square": return amp * (frac < .5 ? 1 : -1);
+		case "triangle": return amp * (4 * Math.abs(frac - .5) - 1) * -1;
+		case "saw": return amp * (2 * frac - 1);
+		default: return amp * Math.sin(2 * Math.PI * turns);
+	}
+}
+/**
+* Value of a keyframed track at `timeSec`. Before the first key → its value;
+* after the last → its value; between → eased interpolation. Keys must be sorted
+* by `t`. Use for reveal-on-action choreography (sweep a tangent, fade step 2 in).
+*/
+function timeline(timeSec, keys) {
+	const n = keys.length;
+	if (n === 0) return 0;
+	const first = keys[0];
+	if (timeSec <= first.t) return first.v;
+	const last = keys[n - 1];
+	if (timeSec >= last.t) return last.v;
+	for (let i = 1; i < n; i++) {
+		const k = keys[i];
+		const prev = keys[i - 1];
+		if (timeSec < k.t) {
+			const span = k.t - prev.t;
+			const t = span > 0 ? (timeSec - prev.t) / span : 1;
+			return lerp(prev.v, k.v, (k.ease ?? ease.linear)(t));
+		}
+	}
+	return last.v;
+}
+
+//#endregion
+export { ease, lerp, oscillate, prefersReducedMotion, spring, timeline };

package/dist/core/richText.d.mts

@@ -0,0 +1,28 @@
+//#region src/core/richText.d.ts
+/**
+ * richText — the ONE grammar for inline subscript/superscript markup, shared by
+ * every renderer so the parsing lives in a single place and can't drift:
+ *   • stage's SVG `<Label>` turns spans into <tspan> (baseline-shifted), and
+ *   • labs' HTML `<RichText>` turns them into <sub>/<sup>.
+ *
+ * Grammar (LaTeX-ish, the universal science convention):
+ *   `_x` / `^x`        → a run of the SAME character class as the char right
+ *                        after the marker (all-letters OR all-digits). So
+ *                        `V_RC` → subscript "RC", `H_2O` → subscript "2" then
+ *                        base "O", `v_max` → subscript "max" — no braces needed.
+ *   `_{abc}` / `^{ab}` → an explicit group, taken verbatim (use for mixed runs
+ *                        or symbols, e.g. `10^{-3}`, `x^{n+1}`)
+ *   a lone `_` or `^`  → stays literal
+ * Examples: `V_C`, `V_{RC}`, `v_b`, `H_2O`, `x^2`, `V_A (rain)`, `10^{-3}`.
+ *
+ * Pure + dependency-free; no markers → a single base span (the fast path), so
+ * plain labels are untouched.
+ */
+type Script = 'base' | 'sub' | 'sup';
+interface RichSpan {
+  text: string;
+  script: Script;
+}
+declare function parseRichText(text: string): RichSpan[];
+//#endregion
+export { RichSpan, Script, parseRichText };

package/dist/core/richText.mjs

@@ -0,0 +1,52 @@
+//#region src/core/richText.ts
+const DIGIT = /[0-9]/;
+const LETTER = /[A-Za-z]/;
+function parseRichText(text) {
+	if (text.indexOf("_") < 0 && text.indexOf("^") < 0) return [{
+		text,
+		script: "base"
+	}];
+	const out = [];
+	let buf = "";
+	const flush = () => {
+		if (buf) {
+			out.push({
+				text: buf,
+				script: "base"
+			});
+			buf = "";
+		}
+	};
+	for (let i = 0; i < text.length;) {
+		const ch = text[i];
+		if (ch === "_" || ch === "^") {
+			const script = ch === "_" ? "sub" : "sup";
+			i++;
+			let grp = "";
+			if (text[i] === "{") {
+				i++;
+				while (i < text.length && text[i] !== "}") grp += text[i++];
+				if (text[i] === "}") i++;
+			} else {
+				const first = text[i];
+				const cls = first !== void 0 && DIGIT.test(first) ? DIGIT : first !== void 0 && LETTER.test(first) ? LETTER : null;
+				if (cls) while (i < text.length && cls.test(text[i])) grp += text[i++];
+			}
+			if (grp) {
+				flush();
+				out.push({
+					text: grp,
+					script
+				});
+			} else buf += ch;
+		} else {
+			buf += ch;
+			i++;
+		}
+	}
+	flush();
+	return out;
+}
+
+//#endregion
+export { parseRichText };

package/dist/core/vec.d.mts

@@ -0,0 +1,47 @@
+//#region src/core/vec.d.ts
+/**
+ * 2D vector + affine-matrix algebra. Points are {x,y} objects (serialize cleanly
+ * in the scene JSON). Matrices are SVG-order tuples [a,b,c,d,e,f] mapping
+ * (x,y) → (a·x + c·y + e, b·x + d·y + f), so `mat.toSvg` is a direct
+ * `matrix(a b c d e f)` attribute string — never a CSS variable (a CSS transform
+ * is not reliably composed into getScreenCTM()).
+ */
+interface Vec2 {
+  x: number;
+  y: number;
+}
+/** SVG-order affine matrix: [a, b, c, d, e, f]. */
+type Matrix = readonly [number, number, number, number, number, number];
+declare const vec: {
+  add: (a: Vec2, b: Vec2) => Vec2;
+  sub: (a: Vec2, b: Vec2) => Vec2;
+  scale: (a: Vec2, k: number) => Vec2;
+  mag: (a: Vec2) => number;
+  normalize: (a: Vec2) => Vec2;
+  dot: (a: Vec2, b: Vec2) => number;
+  dist: (a: Vec2, b: Vec2) => number;
+  lerp: (a: Vec2, b: Vec2, t: number) => Vec2;
+  midpoint: (a: Vec2, b: Vec2) => Vec2;
+  angle: (a: Vec2) => number;
+  perp: (a: Vec2) => Vec2;
+  rotate: (a: Vec2, rad: number) => Vec2;
+  rotateAbout: (a: Vec2, center: Vec2, rad: number) => Vec2;
+};
+declare class MatrixBuilder {
+  private m;
+  constructor(m?: Matrix);
+  translate(tx: number, ty: number): MatrixBuilder;
+  scale(s: number, sy?: number): MatrixBuilder;
+  rotate(rad: number): MatrixBuilder;
+  get(): Matrix;
+}
+declare const mat: {
+  identity: Matrix;
+  mul: (m: Matrix, n: Matrix) => Matrix;
+  invert: (m: Matrix) => Matrix;
+  apply: (v: Vec2, m: Matrix) => Vec2;
+  toSvg: (m: Matrix) => string;
+  builder: (m?: Matrix) => MatrixBuilder;
+};
+//#endregion
+export { Matrix, Vec2, mat, vec };

package/dist/core/vec.mjs

@@ -0,0 +1,144 @@
+//#region src/core/vec.ts
+const add = (a, b) => ({
+	x: a.x + b.x,
+	y: a.y + b.y
+});
+const sub = (a, b) => ({
+	x: a.x - b.x,
+	y: a.y - b.y
+});
+const scale = (a, k) => ({
+	x: a.x * k,
+	y: a.y * k
+});
+const mag = (a) => Math.hypot(a.x, a.y);
+const normalize = (a) => {
+	const m = mag(a) || 1;
+	return {
+		x: a.x / m,
+		y: a.y / m
+	};
+};
+const dot = (a, b) => a.x * b.x + a.y * b.y;
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+const lerp = (a, b, t) => ({
+	x: a.x + (b.x - a.x) * t,
+	y: a.y + (b.y - a.y) * t
+});
+const midpoint = (a, b) => ({
+	x: (a.x + b.x) / 2,
+	y: (a.y + b.y) / 2
+});
+const angle = (a) => Math.atan2(a.y, a.x);
+const perp = (a) => ({
+	x: -a.y,
+	y: a.x
+});
+const rotate = (a, rad) => {
+	const c = Math.cos(rad);
+	const s = Math.sin(rad);
+	return {
+		x: a.x * c - a.y * s,
+		y: a.x * s + a.y * c
+	};
+};
+const rotateAbout = (a, center, rad) => add(center, rotate(sub(a, center), rad));
+const vec = {
+	add,
+	sub,
+	scale,
+	mag,
+	normalize,
+	dot,
+	dist,
+	lerp,
+	midpoint,
+	angle,
+	perp,
+	rotate,
+	rotateAbout
+};
+const IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+const matMul = (m, n) => [
+	m[0] * n[0] + m[2] * n[1],
+	m[1] * n[0] + m[3] * n[1],
+	m[0] * n[2] + m[2] * n[3],
+	m[1] * n[2] + m[3] * n[3],
+	m[0] * n[4] + m[2] * n[5] + m[4],
+	m[1] * n[4] + m[3] * n[5] + m[5]
+];
+const matInvert = (m) => {
+	const id = 1 / (m[0] * m[3] - m[1] * m[2] || 1);
+	return [
+		m[3] * id,
+		-m[1] * id,
+		-m[2] * id,
+		m[0] * id,
+		(m[2] * m[5] - m[3] * m[4]) * id,
+		(m[1] * m[4] - m[0] * m[5]) * id
+	];
+};
+const matApply = (v, m) => ({
+	x: m[0] * v.x + m[2] * v.y + m[4],
+	y: m[1] * v.x + m[3] * v.y + m[5]
+});
+const matToSvg = (m) => `matrix(${m[0]} ${m[1]} ${m[2]} ${m[3]} ${m[4]} ${m[5]})`;
+var MatrixBuilder = class MatrixBuilder {
+	m;
+	constructor(m = IDENTITY) {
+		this.m = m;
+	}
+	translate(tx, ty) {
+		return new MatrixBuilder(matMul(this.m, [
+			1,
+			0,
+			0,
+			1,
+			tx,
+			ty
+		]));
+	}
+	scale(s, sy) {
+		return new MatrixBuilder(matMul(this.m, [
+			s,
+			0,
+			0,
+			sy ?? s,
+			0,
+			0
+		]));
+	}
+	rotate(rad) {
+		const c = Math.cos(rad);
+		const s = Math.sin(rad);
+		return new MatrixBuilder(matMul(this.m, [
+			c,
+			s,
+			-s,
+			c,
+			0,
+			0
+		]));
+	}
+	get() {
+		return this.m;
+	}
+};
+const mat = {
+	identity: IDENTITY,
+	mul: matMul,
+	invert: matInvert,
+	apply: matApply,
+	toSvg: matToSvg,
+	builder: (m) => new MatrixBuilder(m)
+};
+
+//#endregion
+export { mat, vec };

package/dist/field/index.d.mts

@@ -0,0 +1,58 @@
+import { Vec2 } from "../core/vec.mjs";
+
+//#region src/field/index.d.ts
+interface PointCharge {
+  kind: 'point';
+  at: Vec2;
+  /** Signed strength. >0 source / N-pole, <0 sink / S-pole. */
+  q: number;
+}
+interface LineCurrent {
+  kind: 'wire';
+  at: Vec2;
+  /** Signed current ⊥ to the plane; sets the circulation handedness. */
+  i: number;
+}
+type FieldSource = PointCharge | LineCurrent;
+interface Bounds {
+  xMin: number;
+  xMax: number;
+  yMin: number;
+  yMax: number;
+}
+/** Net field vector at point `p` from all sources (superposition). */
+declare function fieldAt(sources: readonly FieldSource[], p: Vec2): Vec2;
+declare function fieldMag(sources: readonly FieldSource[], p: Vec2): number;
+interface TraceOpts {
+  /** Follow the field (+1) or run against it (−1). Default +1. */
+  dir?: number;
+  /** Arc-length step in world units. Default 0.06. */
+  step?: number;
+  maxSteps?: number;
+  bounds?: Bounds;
+  /** Stop when this close to any source (a field line terminates at a source). */
+  stopRadius?: number;
+}
+/** Trace one field line from `start`, integrating along the unit field with RK4. */
+declare function traceLine(sources: readonly FieldSource[], start: Vec2, opts?: TraceOpts): Vec2[];
+interface FieldLinesOpts extends TraceOpts {
+  /** Lines seeded around each source. Default 12. */
+  perSource?: number;
+  /** Seed radius around a source. Default 0.2. */
+  seed?: number;
+}
+/** Convenience: a full set of field lines — radial from each charge/pole, circular
+ *  loops around each wire. Each line carries the sign of its originating source. */
+declare function fieldLines(sources: readonly FieldSource[], opts?: FieldLinesOpts): {
+  points: Vec2[];
+  sign: number;
+}[];
+/** Sample the field on a regular grid — for a quiver / arrow plot. */
+declare function fieldGrid(sources: readonly FieldSource[], bounds: Bounds, nx: number, ny: number): {
+  at: Vec2;
+  v: Vec2;
+}[];
+/** Build a bar magnet as an N(+)/S(−) pole pair, centred at `center` along `dir`. */
+declare function barMagnet(center: Vec2, dir: Vec2, strength?: number, length?: number): [PointCharge, PointCharge];
+//#endregion
+export { Bounds, FieldLinesOpts, FieldSource, LineCurrent, PointCharge, TraceOpts, barMagnet, fieldAt, fieldGrid, fieldLines, fieldMag, traceLine };

package/dist/field/index.mjs

@@ -0,0 +1,156 @@
+//#region src/field/index.ts
+const SOFT = .001;
+/** Net field vector at point `p` from all sources (superposition). */
+function fieldAt(sources, p) {
+	let fx = 0, fy = 0;
+	for (const s of sources) {
+		const dx = p.x - s.at.x, dy = p.y - s.at.y;
+		const r2 = dx * dx + dy * dy + SOFT;
+		const r = Math.sqrt(r2);
+		if (s.kind === "point") {
+			const c = s.q / r2;
+			fx += c * dx / r;
+			fy += c * dy / r;
+		} else {
+			const c = s.i / r2;
+			fx += c * -dy;
+			fy += c * dx;
+		}
+	}
+	return {
+		x: fx,
+		y: fy
+	};
+}
+function fieldMag(sources, p) {
+	const v = fieldAt(sources, p);
+	return Math.hypot(v.x, v.y);
+}
+function unit(v, dir) {
+	const m = Math.hypot(v.x, v.y);
+	if (m < 1e-9) return null;
+	return {
+		x: dir * v.x / m,
+		y: dir * v.y / m
+	};
+}
+/** Trace one field line from `start`, integrating along the unit field with RK4. */
+function traceLine(sources, start, opts = {}) {
+	const { dir = 1, step = .06, maxSteps = 900, bounds, stopRadius = .16 } = opts;
+	const pts = [start];
+	let p = start;
+	for (let n = 0; n < maxSteps; n++) {
+		const k1 = unit(fieldAt(sources, p), dir);
+		if (!k1) break;
+		const k2 = unit(fieldAt(sources, {
+			x: p.x + k1.x * step / 2,
+			y: p.y + k1.y * step / 2
+		}), dir) ?? k1;
+		const k3 = unit(fieldAt(sources, {
+			x: p.x + k2.x * step / 2,
+			y: p.y + k2.y * step / 2
+		}), dir) ?? k2;
+		const k4 = unit(fieldAt(sources, {
+			x: p.x + k3.x * step,
+			y: p.y + k3.y * step
+		}), dir) ?? k3;
+		p = {
+			x: p.x + (k1.x + 2 * k2.x + 2 * k3.x + k4.x) / 6 * step,
+			y: p.y + (k1.y + 2 * k2.y + 2 * k3.y + k4.y) / 6 * step
+		};
+		pts.push(p);
+		if (bounds && (p.x < bounds.xMin || p.x > bounds.xMax || p.y < bounds.yMin || p.y > bounds.yMax)) break;
+		for (const s of sources) if (Math.hypot(p.x - s.at.x, p.y - s.at.y) < stopRadius) return pts;
+	}
+	return pts;
+}
+/** Convenience: a full set of field lines — radial from each charge/pole, circular
+*  loops around each wire. Each line carries the sign of its originating source. */
+function fieldLines(sources, opts = {}) {
+	const { perSource = 12, seed = .2, ...trace } = opts;
+	const out = [];
+	const hasPositive = sources.some((s) => s.kind === "point" && s.q > 0);
+	for (const s of sources) if (s.kind === "point") {
+		if (s.q === 0) continue;
+		const sign = Math.sign(s.q);
+		if (sign < 0 && hasPositive) continue;
+		for (let k = 0; k < perSource; k++) {
+			const a = k / perSource * Math.PI * 2;
+			const startPt = {
+				x: s.at.x + Math.cos(a) * seed,
+				y: s.at.y + Math.sin(a) * seed
+			};
+			out.push({
+				points: traceLine(sources, startPt, {
+					...trace,
+					dir: sign,
+					stopRadius: trace.stopRadius ?? seed * .85
+				}),
+				sign
+			});
+		}
+	} else {
+		const sign = Math.sign(s.i) || 1;
+		for (const rr of [
+			.4,
+			.8,
+			1.3,
+			1.9,
+			2.6
+		]) {
+			const startPt = {
+				x: s.at.x + rr,
+				y: s.at.y
+			};
+			out.push({
+				points: traceLine(sources, startPt, {
+					...trace,
+					dir: sign,
+					stopRadius: 0
+				}),
+				sign
+			});
+		}
+	}
+	return out;
+}
+/** Sample the field on a regular grid — for a quiver / arrow plot. */
+function fieldGrid(sources, bounds, nx, ny) {
+	const out = [];
+	const dx = (bounds.xMax - bounds.xMin) / (nx + 1);
+	const dy = (bounds.yMax - bounds.yMin) / (ny + 1);
+	for (let i = 1; i <= nx; i++) for (let j = 1; j <= ny; j++) {
+		const at = {
+			x: bounds.xMin + i * dx,
+			y: bounds.yMin + j * dy
+		};
+		out.push({
+			at,
+			v: fieldAt(sources, at)
+		});
+	}
+	return out;
+}
+/** Build a bar magnet as an N(+)/S(−) pole pair, centred at `center` along `dir`. */
+function barMagnet(center, dir, strength = 1, length = 1.6) {
+	const m = Math.hypot(dir.x, dir.y) || 1;
+	const ux = dir.x / m * (length / 2), uy = dir.y / m * (length / 2);
+	return [{
+		kind: "point",
+		at: {
+			x: center.x + ux,
+			y: center.y + uy
+		},
+		q: strength
+	}, {
+		kind: "point",
+		at: {
+			x: center.x - ux,
+			y: center.y - uy
+		},
+		q: -strength
+	}];
+}
+
+//#endregion
+export { barMagnet, fieldAt, fieldGrid, fieldLines, fieldMag, traceLine };