@classytic/stage 0.1.0

package/dist/builder/icons.mjs

@@ -0,0 +1,143 @@
+'use client';
+
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/builder/icons.tsx
+const PATHS = {
+	select: /* @__PURE__ */ jsx("path", { d: "M5 3l6 15 2-6 6-2z" }),
+	point: /* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "3.5",
+		fill: "currentColor",
+		stroke: "none"
+	}),
+	segment: /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("line", {
+			x1: "6",
+			y1: "18",
+			x2: "18",
+			y2: "6"
+		}),
+		/* @__PURE__ */ jsx("circle", {
+			cx: "6",
+			cy: "18",
+			r: "2.2",
+			fill: "currentColor",
+			stroke: "none"
+		}),
+		/* @__PURE__ */ jsx("circle", {
+			cx: "18",
+			cy: "6",
+			r: "2.2",
+			fill: "currentColor",
+			stroke: "none"
+		})
+	] }),
+	line: /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("line", {
+			x1: "3",
+			y1: "20",
+			x2: "21",
+			y2: "4"
+		}),
+		/* @__PURE__ */ jsx("circle", {
+			cx: "9",
+			cy: "14.7",
+			r: "1.8",
+			fill: "currentColor",
+			stroke: "none"
+		}),
+		/* @__PURE__ */ jsx("circle", {
+			cx: "15",
+			cy: "9.3",
+			r: "1.8",
+			fill: "currentColor",
+			stroke: "none"
+		})
+	] }),
+	circle: /* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "8"
+	}),
+	midpoint: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("line", {
+		x1: "5",
+		y1: "12",
+		x2: "19",
+		y2: "12"
+	}), /* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "2.6",
+		fill: "currentColor",
+		stroke: "none"
+	})] }),
+	intersect: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("circle", {
+		cx: "9",
+		cy: "12",
+		r: "6"
+	}), /* @__PURE__ */ jsx("circle", {
+		cx: "15",
+		cy: "12",
+		r: "6"
+	})] }),
+	measure: /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("line", {
+			x1: "4",
+			y1: "12",
+			x2: "20",
+			y2: "12"
+		}),
+		/* @__PURE__ */ jsx("path", { d: "M7 9l-3 3 3 3" }),
+		/* @__PURE__ */ jsx("path", { d: "M17 9l3 3-3 3" })
+	] }),
+	scalar: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("line", {
+		x1: "4",
+		y1: "12",
+		x2: "20",
+		y2: "12"
+	}), /* @__PURE__ */ jsx("circle", {
+		cx: "14",
+		cy: "12",
+		r: "3.2",
+		fill: "currentColor",
+		stroke: "none"
+	})] }),
+	note: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M6 6h12" }), /* @__PURE__ */ jsx("line", {
+		x1: "12",
+		y1: "6",
+		x2: "12",
+		y2: "18"
+	})] }),
+	delete: /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("path", { d: "M5 7h14" }),
+		/* @__PURE__ */ jsx("path", { d: "M9 7V5h6v2" }),
+		/* @__PURE__ */ jsx("path", { d: "M7 7l1 12h8l1-12" })
+	] }),
+	undo: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M9 7L4 12l5 5" }), /* @__PURE__ */ jsx("path", { d: "M4 12h10a6 6 0 0 1 0 12" })] }),
+	redo: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("path", { d: "M15 7l5 5-5 5" }), /* @__PURE__ */ jsx("path", { d: "M20 12H10a6 6 0 0 0 0 12" })] })
+};
+/** A single builder icon. `size` in px; inherits `currentColor`. Decorative. */
+function ToolIcon({ name, size = 16 }) {
+	return /* @__PURE__ */ jsx("svg", {
+		width: size,
+		height: size,
+		viewBox: "0 0 24 24",
+		fill: "none",
+		stroke: "currentColor",
+		strokeWidth: 2,
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		"aria-hidden": true,
+		focusable: "false",
+		style: {
+			display: "block",
+			flex: "none"
+		},
+		children: PATHS[name]
+	});
+}
+
+//#endregion
+export { ToolIcon };

package/dist/builder/index.d.mts

@@ -0,0 +1,6 @@
+import { DispatchOpts, Editor, useEditor } from "./editor.mjs";
+import { ControlPick, controlsFromScene } from "./controls.mjs";
+import { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT, Tool, ToolCtx } from "./tools.mjs";
+import { SceneBuilder, SceneBuilderProps } from "./SceneBuilder.mjs";
+import { Palette, PaletteProps } from "./Palette.mjs";
+export { AUTHORING_TOOLS, CIRCLE, type ControlPick, DELETE, type DispatchOpts, Editor, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, Palette, type PaletteProps, SCALAR, SEGMENT, SELECT, SceneBuilder, type SceneBuilderProps, type Tool, type ToolCtx, controlsFromScene, useEditor };

package/dist/builder/index.mjs

@@ -0,0 +1,7 @@
+import { Editor, useEditor } from "./editor.mjs";
+import { controlsFromScene } from "./controls.mjs";
+import { Palette } from "./Palette.mjs";
+import { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT } from "./tools.mjs";
+import { SceneBuilder } from "./SceneBuilder.mjs";
+
+export { AUTHORING_TOOLS, CIRCLE, DELETE, Editor, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, Palette, SCALAR, SEGMENT, SELECT, SceneBuilder, controlsFromScene, useEditor };

package/dist/builder/tools.d.mts

@@ -0,0 +1,47 @@
+import { Vec2 } from "../core/vec.mjs";
+import { Id } from "../scene/types.mjs";
+import { Editor } from "./editor.mjs";
+import { IconName } from "./icons.mjs";
+
+//#region src/builder/tools.d.ts
+interface ToolCtx {
+  editor: Editor;
+  /** nearest existing point id within tolerance, or null. */
+  hitPoint: (m: Vec2) => Id | null;
+  /** nearest circle/line id within tolerance, or null. */
+  hitElement: (m: Vec2) => Id | null;
+  /** ids selected so far in a multi-click construct. */
+  pending: Id[];
+  setPending: (ids: Id[]) => void;
+  /** snap a math point to the working grid. */
+  snap: (m: Vec2) => Vec2;
+  /** fresh id with a prefix (A,B,C… for points). */
+  nextId: (prefix: string) => Id;
+}
+interface Tool {
+  id: string;
+  /** Internal builder-icon name (rendered by the palette; no React-icon peer). */
+  icon: IconName;
+  /** Plain text label (also the button's a11y name). */
+  label: string;
+  hint: string;
+  onPoint(ctx: ToolCtx, m: Vec2): void;
+}
+declare const SELECT: Tool;
+declare const POINT: Tool;
+declare const SEGMENT: Tool;
+declare const LINE: Tool;
+declare const CIRCLE: Tool;
+declare const MIDPOINT: Tool;
+declare const INTERSECT: Tool;
+declare const MEASURE: Tool;
+declare const DELETE: Tool;
+/** A free scalar parameter — appears as a live slider in the authoring strip. */
+declare const SCALAR: Tool;
+/** A free text note placed in the scene. */
+declare const NOTE: Tool;
+declare const GEOMETRY_TOOLS: Tool[];
+/** Geometry construction + the authoring primitives (sliders, labels). */
+declare const AUTHORING_TOOLS: Tool[];
+//#endregion
+export { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT, Tool, ToolCtx };

package/dist/builder/tools.mjs

@@ -0,0 +1,303 @@
+'use client';
+
+//#region src/builder/tools.ts
+const colors = {
+	point: "var(--stage-accent)",
+	seg: "var(--stage-good)",
+	line: "var(--stage-muted)",
+	circle: "var(--stage-accent)",
+	derived: "var(--stage-warn)"
+};
+/** Collect `n` distinct points by click; when full, run `done(ids)` and reset. */
+function collectPoints(ctx, m, n, done) {
+	const pid = ctx.hitPoint(m);
+	if (!pid) return;
+	const next = [...ctx.pending, pid];
+	if (next.length < n) {
+		ctx.setPending(next);
+		return;
+	}
+	done(next);
+	ctx.setPending([]);
+}
+const SELECT = {
+	id: "select",
+	icon: "select",
+	label: "Move",
+	hint: "Drag a labelled point to move it.",
+	onPoint: () => {}
+};
+const POINT = {
+	id: "point",
+	icon: "point",
+	label: "Point",
+	hint: "Click empty space to place a point.",
+	onPoint: (ctx, m) => {
+		const id = ctx.nextId("P");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "point",
+				label: id,
+				style: { color: colors.point },
+				free: {
+					at: ctx.snap(m),
+					draggable: true
+				}
+			}
+		});
+	}
+};
+const SEGMENT = {
+	id: "segment",
+	icon: "segment",
+	label: "Segment",
+	hint: "Click two points.",
+	onPoint: (ctx, m) => collectPoints(ctx, m, 2, ([a, b]) => {
+		const id = ctx.nextId("s");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "segment",
+				style: { color: colors.seg },
+				def: {
+					op: "segment",
+					from: { ref: a },
+					to: { ref: b }
+				}
+			}
+		});
+	})
+};
+const LINE = {
+	id: "line",
+	icon: "line",
+	label: "Line",
+	hint: "Click two points.",
+	onPoint: (ctx, m) => collectPoints(ctx, m, 2, ([a, b]) => {
+		const id = ctx.nextId("l");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "line",
+				style: { color: colors.line },
+				def: {
+					op: "line",
+					through: [{ ref: a }, { ref: b }]
+				}
+			}
+		});
+	})
+};
+const CIRCLE = {
+	id: "circle",
+	icon: "circle",
+	label: "Circle",
+	hint: "Click centre, then a point on it.",
+	onPoint: (ctx, m) => collectPoints(ctx, m, 2, ([c, t]) => {
+		const id = ctx.nextId("c");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "circle",
+				style: { color: colors.circle },
+				def: {
+					op: "circle",
+					center: { ref: c },
+					through: { ref: t }
+				}
+			}
+		});
+	})
+};
+const MIDPOINT = {
+	id: "midpoint",
+	icon: "midpoint",
+	label: "Midpoint",
+	hint: "Click two points.",
+	onPoint: (ctx, m) => collectPoints(ctx, m, 2, ([a, b]) => {
+		const id = ctx.nextId("M");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "point",
+				label: id,
+				style: { color: colors.derived },
+				def: {
+					op: "midpoint",
+					of: [{ ref: a }, { ref: b }]
+				}
+			}
+		});
+	})
+};
+const INTERSECT = {
+	id: "intersect",
+	icon: "intersect",
+	label: "Intersect",
+	hint: "Click two circles/lines.",
+	onPoint: (ctx, m) => {
+		const eid = ctx.hitElement(m);
+		if (!eid) return;
+		const next = [...ctx.pending, eid];
+		if (next.length < 2) {
+			ctx.setPending(next);
+			return;
+		}
+		const id1 = ctx.nextId("X");
+		ctx.editor.dispatch({
+			op: "create",
+			id: id1,
+			element: {
+				id: id1,
+				kind: "point",
+				label: id1,
+				style: { color: colors.derived },
+				def: {
+					op: "intersect",
+					of: [{ ref: next[0] }, { ref: next[1] }],
+					pick: 0
+				}
+			}
+		});
+		const id2 = ctx.nextId("X");
+		ctx.editor.dispatch({
+			op: "create",
+			id: id2,
+			element: {
+				id: id2,
+				kind: "point",
+				label: id2,
+				style: { color: colors.derived },
+				def: {
+					op: "intersect",
+					of: [{ ref: next[0] }, { ref: next[1] }],
+					pick: 1
+				}
+			}
+		});
+		ctx.setPending([]);
+	}
+};
+const MEASURE = {
+	id: "measure",
+	icon: "measure",
+	label: "Measure",
+	hint: "Click two points to measure the distance.",
+	onPoint: (ctx, m) => collectPoints(ctx, m, 2, ([a, b]) => {
+		const id = ctx.nextId("d");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "measure",
+				label: `|${a}${b}|`,
+				def: {
+					op: "distance",
+					of: [{ ref: a }, { ref: b }]
+				}
+			}
+		});
+	})
+};
+const DELETE = {
+	id: "delete",
+	icon: "delete",
+	label: "Delete",
+	hint: "Click a point or curve to remove it (and anything built on it).",
+	onPoint: (ctx, m) => {
+		const id = ctx.hitPoint(m) ?? ctx.hitElement(m);
+		if (id) ctx.editor.dispatch({
+			op: "remove",
+			id
+		});
+	}
+};
+/** A free scalar parameter — appears as a live slider in the authoring strip. */
+const SCALAR = {
+	id: "scalar",
+	icon: "scalar",
+	label: "Slider",
+	hint: "Click to add a value/slider parameter (drives equations + assets).",
+	onPoint: (ctx) => {
+		const id = ctx.nextId("k");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "scalar",
+				label: id,
+				a11y: { label: `parameter ${id}` },
+				free: {
+					value: 1,
+					min: 0,
+					max: 10,
+					step: 1
+				}
+			}
+		});
+	}
+};
+/** A free text note placed in the scene. */
+const NOTE = {
+	id: "note",
+	icon: "note",
+	label: "Label",
+	hint: "Click to drop a text label (edit it in the inspector).",
+	onPoint: (ctx, m) => {
+		const id = ctx.nextId("t");
+		ctx.editor.dispatch({
+			op: "create",
+			id,
+			element: {
+				id,
+				kind: "note",
+				style: { color: "var(--stage-fg)" },
+				free: {
+					at: ctx.snap(m),
+					text: "label"
+				}
+			}
+		});
+	}
+};
+const GEOMETRY_TOOLS = [
+	SELECT,
+	POINT,
+	SEGMENT,
+	LINE,
+	CIRCLE,
+	MIDPOINT,
+	INTERSECT,
+	MEASURE,
+	DELETE
+];
+/** Geometry construction + the authoring primitives (sliders, labels). */
+const AUTHORING_TOOLS = [
+	SELECT,
+	POINT,
+	SEGMENT,
+	LINE,
+	CIRCLE,
+	MIDPOINT,
+	INTERSECT,
+	MEASURE,
+	SCALAR,
+	NOTE,
+	DELETE
+];
+
+//#endregion
+export { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT };

package/dist/chem/index.d.mts

@@ -0,0 +1,118 @@
+//#region src/chem/index.d.ts
+/**
+ * `chem` — acid–base / pH AND electrochemistry / Nernst, as a PURE kernel (no
+ * React, no pixels). The engine behind titration curves, pH problems, and galvanic
+ * cells.
+ *
+ * pH at any point is found by solving the exact charge balance for [H⁺] = h:
+ *
+ *     [titrant cation] + h  =  [OH⁻] + [A⁻]
+ *     n_b/V + h  =  K_w/h  +  (n_a/V)·K_a/(K_a + h)
+ *
+ * where n_a is the acid initially present, n_b the strong base added, V the total
+ * volume. A strong acid is just the K_a → ∞ limit (fully dissociated). Solving the
+ * balance (monotonic in h → bisection) is robust everywhere — initial point, buffer
+ * region, equivalence, and past it — with no piecewise approximations to get wrong.
+ *
+ * Concentrations in mol/L, volumes in litres. Currently models an ACID analyte
+ * titrated by a STRONG BASE (covers strong-acid and weak-acid curves).
+ */
+declare const Kw = 1e-14;
+type Analyte = 'strong-acid' | 'weak-acid';
+interface TitrationSpec {
+  analyte: Analyte;
+  /** Analyte concentration, mol/L. */
+  Ca: number;
+  /** Analyte volume, L. */
+  Va: number;
+  /** Strong-base titrant concentration, mol/L. */
+  Cb: number;
+  /** Acid pKa (weak acid only; ignored for a strong acid). */
+  pKa?: number;
+}
+/** pH after adding `Vb` litres of titrant. */
+declare function pHAt(spec: TitrationSpec, Vb: number): number;
+interface TitrationCurve {
+  points: {
+    v: number;
+    pH: number;
+  }[];
+  /** Equivalence volume, L (moles base = moles acid). */
+  vEq: number;
+  /** pH at the equivalence point. */
+  pHEq: number;
+  /** Half-equivalence pH (= pKa for a weak acid). */
+  pHHalf: number;
+  pKa: number;
+}
+/** Sample the full titration curve from 0 to `span`·vEq (default 2×). */
+declare function titrationCurve(spec: TitrationSpec, n?: number, span?: number): TitrationCurve;
+/** Universal gas constant, J/(mol·K). */
+declare const R = 8.314462618;
+/** Faraday constant, C/mol. */
+declare const F = 96485.332;
+/** Standard temperature, K (25 °C). */
+declare const T_STD = 298.15;
+interface HalfCell {
+  /** Electrode metal symbol (e.g. 'Zn'). */
+  metal: string;
+  /** Ion charge z in Mᶻ⁺ (e.g. 2 for Zn²⁺). */
+  z: number;
+  /** Standard reduction potential E°, volts. */
+  E0: number;
+  /** Ion concentration [Mᶻ⁺], mol/L. */
+  conc: number;
+}
+interface CellResult {
+  cathode: HalfCell;
+  anode: HalfCell;
+  /** Standard cell potential E°cell = E°cathode − E°anode, V. */
+  E0cell: number;
+  /** Electrons transferred (balances the half-reactions). */
+  n: number;
+  /** Reaction quotient Q = [anode ion]^(n/zₐ) / [cathode ion]^(n/z_c). */
+  Q: number;
+  /** Actual cell potential from the Nernst equation, V. */
+  E: number;
+  /** Does the cell drive current as written (E > 0)? */
+  spontaneous: boolean;
+}
+/** Galvanic cell from two half-cells; cathode/anode assigned by standard potential. */
+declare function galvanicCell(x: HalfCell, y: HalfCell, T?: number): CellResult;
+/** Arrhenius rate constant k = A·e^(−Ea/RT). */
+declare function arrhenius(A: number, Ea: number, T: number): number;
+/** Ratio k(T)/k(Tref) at fixed Ea — the stable way to scale a rate without a raw A. */
+declare function arrheniusRatio(Ea: number, T: number, Tref?: number): number;
+/** Fraction of molecules with energy ≥ Ea (Boltzmann) ≈ e^(−Ea/RT). */
+declare function fractionAboveEa(Ea: number, T: number): number;
+type RateOrder = 0 | 1 | 2;
+/** Concentration [A] at time t for a reaction of the given order, rate = k·[A]^order. */
+declare function concAt(order: RateOrder, A0: number, k: number, t: number): number;
+/** Half-life for the given order (constant only for first order). */
+declare function halfLife(order: RateOrder, A0: number, k: number): number;
+interface StoichSpecies {
+  name: string;
+  /** Stoichiometric coefficient in the balanced equation. */
+  coeff: number;
+  /** Molar mass, g/mol (optional — enables grams in the result). */
+  molarMass?: number;
+}
+interface StoichResult {
+  /** Reaction extent ξ = min(moles/coeff) over the reactants. */
+  extent: number;
+  /** Name(s) of the limiting reactant(s) (more than one on an exact-ratio tie). */
+  limiting: string[];
+  /** Moles of each reactant consumed (aligned with the reactants array). */
+  consumed: number[];
+  /** Moles of each reactant left over. */
+  leftover: number[];
+  products: {
+    name: string;
+    moles: number;
+    grams?: number;
+  }[];
+}
+/** Solve a balanced reaction for the limiting reagent, extent, products and leftovers. */
+declare function solveStoichiometry(reactants: StoichSpecies[], products: StoichSpecies[], amountsMol: number[]): StoichResult;
+//#endregion
+export { Analyte, CellResult, F, HalfCell, Kw, R, RateOrder, StoichResult, StoichSpecies, T_STD, TitrationCurve, TitrationSpec, arrhenius, arrheniusRatio, concAt, fractionAboveEa, galvanicCell, halfLife, pHAt, solveStoichiometry, titrationCurve };