@classytic/stage 0.1.0

package/dist/scene/commands.d.mts

@@ -0,0 +1,47 @@
+import { Binding, DerivedDef, ElementStyle, Id, SceneDoc, SceneElement } from "./types.mjs";
+
+//#region src/scene/commands.d.ts
+interface MutatePatch {
+  free?: Record<string, unknown>;
+  def?: Partial<DerivedDef>;
+  style?: ElementStyle;
+  label?: string;
+}
+type Command = {
+  op: 'create';
+  id: Id;
+  element: SceneElement;
+  index?: number;
+} | {
+  op: 'mutate';
+  id: Id;
+  patch: MutatePatch;
+} | {
+  op: 'bind';
+  binding: Binding;
+} | {
+  op: 'unbind';
+  id: Id;
+} | {
+  op: 'remove';
+  id: Id;
+} | {
+  op: 'batch';
+  label: string;
+  commands: Command[];
+};
+interface CommandResult {
+  ok: boolean;
+  createdIds?: Id[];
+  error?: string;
+}
+/** Elements transitively depending on `id` (plus `id` itself), in document order
+ *  (= creation order, parents before children), and the bindings touching them. */
+declare function collectRemoved(doc: SceneDoc, id: Id): {
+  elements: SceneElement[];
+  bindings: Binding[];
+};
+declare function applyCommand(doc: SceneDoc, cmd: Command): SceneDoc;
+declare function inverse(cmd: Command, prev: SceneDoc): Command;
+//#endregion
+export { Command, CommandResult, MutatePatch, applyCommand, collectRemoved, inverse };

package/dist/scene/commands.mjs

@@ -0,0 +1,162 @@
+import { isDerived, isFree } from "./types.mjs";
+import { parentIds } from "./schema.mjs";
+
+//#region src/scene/commands.ts
+/**
+* Commands — JSON, agent-emittable mutations. ALL changes funnel through these
+* (builder, agent, undo, control-surface bridge). GeoGebra create-vs-mutate split.
+* `applyCommand` is a pure reducer; `inverse` produces the undo command, including
+* a concrete cascading-remove inverse that re-creates descendants + bindings in
+* dependency order.
+*/
+function mutateElement(el, patch) {
+	const next = { ...el };
+	if (patch.label !== void 0) next.label = patch.label;
+	if (patch.style) next.style = {
+		...el.style,
+		...patch.style
+	};
+	if (patch.free && isFree(next) && isFree(el)) next.free = {
+		...el.free,
+		...patch.free
+	};
+	if (patch.def && isDerived(next) && isDerived(el)) next.def = {
+		...el.def,
+		...patch.def
+	};
+	return next;
+}
+/** Elements transitively depending on `id` (plus `id` itself), in document order
+*  (= creation order, parents before children), and the bindings touching them. */
+function collectRemoved(doc, id) {
+	const removed = new Set([id]);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const el of doc.elements) {
+			if (removed.has(el.id)) continue;
+			const ps = parentIds(el);
+			const boundTo = doc.bindings.filter((b) => b.from.ref === el.id).map((b) => b.to.ref);
+			if ([...ps, ...boundTo].some((p) => removed.has(p))) {
+				removed.add(el.id);
+				changed = true;
+			}
+		}
+	}
+	return {
+		elements: doc.elements.filter((e) => removed.has(e.id)),
+		bindings: doc.bindings.filter((b) => removed.has(b.from.ref) || removed.has(b.to.ref))
+	};
+}
+function applyCommand(doc, cmd) {
+	switch (cmd.op) {
+		case "create": {
+			if (cmd.index == null) return {
+				...doc,
+				elements: [...doc.elements, cmd.element]
+			};
+			const els = doc.elements.slice();
+			els.splice(cmd.index, 0, cmd.element);
+			return {
+				...doc,
+				elements: els
+			};
+		}
+		case "mutate": return {
+			...doc,
+			elements: doc.elements.map((el) => el.id === cmd.id ? mutateElement(el, cmd.patch) : el)
+		};
+		case "bind": return {
+			...doc,
+			bindings: [...doc.bindings, cmd.binding]
+		};
+		case "unbind": return {
+			...doc,
+			bindings: doc.bindings.filter((b) => b.id !== cmd.id)
+		};
+		case "remove": {
+			const { elements, bindings } = collectRemoved(doc, cmd.id);
+			const elIds = new Set(elements.map((e) => e.id));
+			const bIds = new Set(bindings.map((b) => b.id));
+			return {
+				...doc,
+				elements: doc.elements.filter((e) => !elIds.has(e.id)),
+				bindings: doc.bindings.filter((b) => !bIds.has(b.id))
+			};
+		}
+		case "batch": return cmd.commands.reduce(applyCommand, doc);
+	}
+}
+function inverse(cmd, prev) {
+	switch (cmd.op) {
+		case "create": return {
+			op: "remove",
+			id: cmd.id
+		};
+		case "mutate": {
+			const el = prev.elements.find((e) => e.id === cmd.id);
+			const patch = {};
+			if (el) {
+				if (cmd.patch.label !== void 0) patch.label = el.label ?? "";
+				if (cmd.patch.style) patch.style = el.style ?? {};
+				if (cmd.patch.free && isFree(el)) patch.free = { ...el.free };
+				if (cmd.patch.def && isDerived(el)) patch.def = { ...el.def };
+			}
+			return {
+				op: "mutate",
+				id: cmd.id,
+				patch
+			};
+		}
+		case "bind": return {
+			op: "unbind",
+			id: cmd.binding.id
+		};
+		case "unbind": {
+			const b = prev.bindings.find((x) => x.id === cmd.id);
+			if (!b) return {
+				op: "batch",
+				label: "noop",
+				commands: []
+			};
+			return {
+				op: "bind",
+				binding: b
+			};
+		}
+		case "remove": {
+			const { elements, bindings } = collectRemoved(prev, cmd.id);
+			return {
+				op: "batch",
+				label: "undo remove",
+				commands: [...elements.map((element) => ({
+					op: "create",
+					id: element.id,
+					element,
+					index: prev.elements.indexOf(element)
+				})), ...bindings.map((binding) => ({
+					op: "bind",
+					binding
+				}))]
+			};
+		}
+		case "batch": {
+			const inverses = [];
+			let cursor = prev;
+			const states = [];
+			for (const c of cmd.commands) {
+				states.push(cursor);
+				cursor = applyCommand(cursor, c);
+			}
+			for (let i = cmd.commands.length - 1; i >= 0; i--) inverses.push(inverse(cmd.commands[i], states[i]));
+			return {
+				op: "batch",
+				label: `undo ${cmd.label}`,
+				commands: inverses
+			};
+		}
+	}
+}
+
+//#endregion
+export { applyCommand, collectRemoved, inverse };

package/dist/scene/evaluators.d.mts

@@ -0,0 +1,17 @@
+import { Vec2 } from "../core/vec.mjs";
+import { DerivedDef, Id, NumOrRef, Ref, Val } from "./types.mjs";
+
+//#region src/scene/evaluators.d.ts
+interface EvalCtx {
+  get(r: Ref): Val | undefined;
+  vec(r: Ref): Vec2 | undefined;
+  num(x: NumOrRef): number;
+  prevVal(id: Id): Val | undefined;
+  /** Read a live sim-state field (external input, like a drag overlay). */
+  simField(sim: Id, field: string): unknown;
+  selfId: Id;
+}
+type Evaluator = (def: DerivedDef, ctx: EvalCtx) => Val;
+declare const EVALUATORS: Record<string, Evaluator>;
+//#endregion
+export { EVALUATORS, EvalCtx };

package/dist/scene/evaluators.mjs

@@ -0,0 +1,210 @@
+import { vec } from "../core/vec.mjs";
+import { isCircleVal, isLineVal, isVec2, numOf } from "./types.mjs";
+import { getAsset } from "./assets.mjs";
+import { compileExpr } from "../math/index.mjs";
+
+//#region src/scene/evaluators.ts
+/**
+* Evaluator registry, keyed by def.op. Each evaluator turns a derived def into a
+* Val, reading parent values through `ctx`. Geometry intersection math is ported
+* from the legacy labs GeometryBoard; intersect picks the solution nearest the previous
+* frame's resolved point (continuity — never swaps P/Q on drag).
+*/
+const exprCache = /* @__PURE__ */ new Map();
+function compiledExpr(src) {
+	if (exprCache.has(src)) return exprCache.get(src) ?? null;
+	const r = compileExpr(src);
+	const compiled = "fn" in r && typeof r.fn === "function" ? r : null;
+	exprCache.set(src, compiled);
+	return compiled;
+}
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function intersectCircleCircle(A, B) {
+	const d = dist(A.center, B.center);
+	if (d < 1e-9 || d > A.r + B.r || d < Math.abs(A.r - B.r)) return [];
+	const a = (d * d + A.r * A.r - B.r * B.r) / (2 * d);
+	const h2 = A.r * A.r - a * a;
+	if (h2 < 0) return [];
+	const h = Math.sqrt(h2);
+	const ux = (B.center.x - A.center.x) / d;
+	const uy = (B.center.y - A.center.y) / d;
+	const mx = A.center.x + a * ux;
+	const my = A.center.y + a * uy;
+	return [{
+		x: mx - h * uy,
+		y: my + h * ux
+	}, {
+		x: mx + h * uy,
+		y: my - h * ux
+	}];
+}
+function intersectLineLine(L1, L2) {
+	const { a: p1, b: p2 } = L1;
+	const { a: p3, b: p4 } = L2;
+	const d = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x);
+	if (Math.abs(d) < 1e-9) return [];
+	const a = p1.x * p2.y - p1.y * p2.x;
+	const b = p3.x * p4.y - p3.y * p4.x;
+	return [{
+		x: (a * (p3.x - p4.x) - (p1.x - p2.x) * b) / d,
+		y: (a * (p3.y - p4.y) - (p1.y - p2.y) * b) / d
+	}];
+}
+function intersectLineCircle(L, C) {
+	const dx = L.b.x - L.a.x;
+	const dy = L.b.y - L.a.y;
+	const fx = L.a.x - C.center.x;
+	const fy = L.a.y - C.center.y;
+	const a = dx * dx + dy * dy;
+	const b = 2 * (fx * dx + fy * dy);
+	const c = fx * fx + fy * fy - C.r * C.r;
+	const disc = b * b - 4 * a * c;
+	if (disc < 0 || a < 1e-12) return [];
+	const s = Math.sqrt(disc);
+	const t1 = (-b - s) / (2 * a);
+	const t2 = (-b + s) / (2 * a);
+	return [{
+		x: L.a.x + t1 * dx,
+		y: L.a.y + t1 * dy
+	}, {
+		x: L.a.x + t2 * dx,
+		y: L.a.y + t2 * dy
+	}];
+}
+function need(v, msg) {
+	if (v === void 0) throw new Error(msg);
+	return v;
+}
+const EVALUATORS = {
+	midpoint: (d, ctx) => {
+		const def = d;
+		return vec.midpoint(need(ctx.vec(def.of[0]), "midpoint: parent A missing"), need(ctx.vec(def.of[1]), "midpoint: parent B missing"));
+	},
+	circle: (d, ctx) => {
+		const def = d;
+		const center = need(ctx.vec(def.center), "circle: center missing");
+		return {
+			kind: "circle",
+			center,
+			r: def.radius != null ? def.radius : def.through ? dist(center, need(ctx.vec(def.through), "circle: through missing")) : 1
+		};
+	},
+	line: (d, ctx) => {
+		const def = d;
+		return {
+			kind: "line",
+			a: need(ctx.vec(def.through[0]), "line: A missing"),
+			b: need(ctx.vec(def.through[1]), "line: B missing")
+		};
+	},
+	segment: (d, ctx) => {
+		const def = d;
+		return {
+			kind: "segment",
+			a: need(ctx.vec(def.from), "segment: from missing"),
+			b: need(ctx.vec(def.to), "segment: to missing")
+		};
+	},
+	polygon: (d, ctx) => {
+		return d.vertices.map((r, i) => need(ctx.vec(r), `polygon: vertex ${i} missing`));
+	},
+	intersect: (d, ctx) => {
+		const def = d;
+		const v1 = ctx.get(def.of[0]);
+		const v2 = ctx.get(def.of[1]);
+		let sols = [];
+		if (isCircleVal(v1) && isCircleVal(v2)) sols = intersectCircleCircle(v1, v2);
+		else if (isLineVal(v1) && isLineVal(v2)) sols = intersectLineLine(v1, v2);
+		else if (isLineVal(v1) && isCircleVal(v2)) sols = intersectLineCircle(v1, v2);
+		else if (isCircleVal(v1) && isLineVal(v2)) sols = intersectLineCircle(v2, v1);
+		if (!sols.length) throw new Error("intersect: no solution");
+		const prev = ctx.prevVal(ctx.selfId);
+		if (isVec2(prev)) return sols.reduce((best, s) => dist(s, prev) < dist(best, prev) ? s : best, sols[0]);
+		return sols[def.pick ?? 0] ?? sols[0];
+	},
+	distance: (d, ctx) => {
+		const def = d;
+		return dist(need(ctx.vec(def.of[0]), "distance: A missing"), need(ctx.vec(def.of[1]), "distance: B missing"));
+	},
+	angle: (d, ctx) => {
+		const def = d;
+		const a = need(ctx.vec(def.of[0]), "angle: A");
+		const o = need(ctx.vec(def.of[1]), "angle: vertex");
+		const b = need(ctx.vec(def.of[2]), "angle: C");
+		const u = vec.sub(a, o);
+		const w = vec.sub(b, o);
+		const cos = vec.dot(u, w) / ((vec.mag(u) || 1) * (vec.mag(w) || 1));
+		return Math.acos(Math.max(-1, Math.min(1, cos))) * (180 / Math.PI);
+	},
+	linop: (d, ctx) => {
+		const def = d;
+		return def.terms.reduce((sum, t) => sum + t.coef * numOf(ctx.get(t.in)), def.const ?? 0);
+	},
+	clamp: (d, ctx) => {
+		const def = d;
+		return Math.max(def.min, Math.min(def.max, numOf(ctx.get(def.in))));
+	},
+	lerp: (d, ctx) => {
+		const def = d;
+		const a = numOf(ctx.get(def.a));
+		return a + (numOf(ctx.get(def.b)) - a) * ctx.num(def.t);
+	},
+	reduce: (d, ctx) => {
+		const def = d;
+		const xs = def.inputs.map((r) => numOf(ctx.get(r)));
+		if (!xs.length) return 0;
+		if (def.reducer === "sum") return xs.reduce((a, b) => a + b, 0);
+		if (def.reducer === "mean") return xs.reduce((a, b) => a + b, 0) / xs.length;
+		if (def.reducer === "max") return Math.max(...xs);
+		return Math.min(...xs);
+	},
+	product: (d, ctx) => {
+		const def = d;
+		return numOf(ctx.get(def.of[0])) * numOf(ctx.get(def.of[1]));
+	},
+	compare: (d, ctx) => {
+		const def = d;
+		const a = numOf(ctx.get(def.a));
+		const b = ctx.num(def.b);
+		const eps = def.eps ?? 0;
+		switch (def.cmp) {
+			case "lt": return a < b - eps;
+			case "le": return a <= b + eps;
+			case "eq": return Math.abs(a - b) <= eps;
+			case "ge": return a >= b - eps;
+			case "gt": return a > b + eps;
+		}
+	},
+	select: (d, ctx) => {
+		const def = d;
+		return numOf(ctx.get(def.cond)) !== 0 ? ctx.num(def.then) : ctx.num(def.else);
+	},
+	expr: (d, ctx) => {
+		const def = d;
+		const compiled = compiledExpr(def.fn);
+		if (!compiled) return NaN;
+		const scope = {};
+		for (const [name, ref] of Object.entries(def.inputs)) scope[name] = numOf(ctx.get(ref));
+		return compiled.fn(scope);
+	},
+	asset: (d, ctx) => {
+		const def = d;
+		const spec = getAsset(def.asset);
+		if (!spec) throw new Error(`asset '${def.asset}' not registered`);
+		const bound = {};
+		for (const [k, ref] of Object.entries(def.bind)) bound[k] = ctx.get(ref);
+		let sim;
+		if (def.simBind) {
+			sim = {};
+			for (const [k, b] of Object.entries(def.simBind)) sim[k] = ctx.simField(b.sim, b.field);
+		}
+		return spec.resolver({
+			params: def.params,
+			bound,
+			sim
+		});
+	}
+};
+
+//#endregion
+export { EVALUATORS };

package/dist/scene/index.d.mts

@@ -0,0 +1,13 @@
+import { Vec2 } from "../core/vec.mjs";
+import { AssetGeometry, Binding, CircleVal, DerivedDef, DerivedElement, DerivedKind, ElementBase, ElementStyle, FreeElement, FreeNote, FreePoint, FreeScalar, Id, LabMeta, NumOrRef, Op, Ref, SceneDoc, SceneElement, SceneMeta, ShapeLineVal, SimDecl, Val, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isVec2, numOf } from "./types.mjs";
+import { Command, CommandResult, MutatePatch, applyCommand, collectRemoved, inverse } from "./commands.mjs";
+import { Resolved, resolve } from "./resolve.mjs";
+import { OP_REFS, isRef, parentIds } from "./schema.mjs";
+import { EVALUATORS, EvalCtx } from "./evaluators.mjs";
+import { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize } from "./migrate.mjs";
+import { InstanceState, SceneStore } from "./store.mjs";
+import { Scene, SceneProps } from "./Scene.mjs";
+import { RenderOpts, renderElements } from "./render.mjs";
+import { AssetResolveArgs, AssetSpec, assetMeta, getAsset, listAssets, registerAsset } from "./assets.mjs";
+import { SimStates, initSims, stepSims } from "./sims.mjs";
+export { type AssetGeometry, type AssetResolveArgs, type AssetSpec, type Binding, CURRENT_SCHEMA_VERSION, type CircleVal, type Command, type CommandResult, type DerivedDef, type DerivedElement, type DerivedKind, EVALUATORS, type ElementBase, type ElementStyle, type EvalCtx, type FreeElement, type FreeNote, type FreePoint, type FreeScalar, type Id, type InstanceState, type LabMeta, type MutatePatch, type NumOrRef, OP_REFS, type Op, type Ref, type RenderOpts, type Resolved, Scene, type SceneDoc, type SceneElement, type SceneMeta, type SceneProps, SceneStore, type Vec2 as SceneVec2, type ShapeLineVal, type SimDecl, type SimStates, type Val, applyCommand, assetMeta, collectRemoved, emptyDoc, getAsset, initSims, inverse, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isRef, isVec2, listAssets, migrate, numOf, parentIds, parse, registerAsset, renderElements, resolve, serialize, stepSims };

package/dist/scene/index.mjs

@@ -0,0 +1,13 @@
+import { isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isVec2, numOf } from "./types.mjs";
+import { OP_REFS, isRef, parentIds } from "./schema.mjs";
+import { assetMeta, getAsset, listAssets, registerAsset } from "./assets.mjs";
+import { EVALUATORS } from "./evaluators.mjs";
+import { resolve } from "./resolve.mjs";
+import { applyCommand, collectRemoved, inverse } from "./commands.mjs";
+import { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize } from "./migrate.mjs";
+import { SceneStore } from "./store.mjs";
+import { renderElements } from "./render.mjs";
+import { initSims, stepSims } from "./sims.mjs";
+import { Scene } from "./Scene.mjs";
+
+export { CURRENT_SCHEMA_VERSION, EVALUATORS, OP_REFS, Scene, SceneStore, applyCommand, assetMeta, collectRemoved, emptyDoc, getAsset, initSims, inverse, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isRef, isVec2, listAssets, migrate, numOf, parentIds, parse, registerAsset, renderElements, resolve, serialize, stepSims };

package/dist/scene/migrate.d.mts

@@ -0,0 +1,11 @@
+import { SceneDoc } from "./types.mjs";
+
+//#region src/scene/migrate.d.ts
+declare const CURRENT_SCHEMA_VERSION: 2;
+declare function emptyDoc(): SceneDoc;
+declare function migrate(raw: unknown): SceneDoc;
+/** Stable JSON serialize (sorted nowhere needed yet; element order is meaningful). */
+declare function serialize(doc: SceneDoc): string;
+declare function parse(json: string): SceneDoc;
+//#endregion
+export { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize };

package/dist/scene/migrate.mjs

@@ -0,0 +1,35 @@
+//#region src/scene/migrate.ts
+const CURRENT_SCHEMA_VERSION = 2;
+function emptyDoc() {
+	return {
+		schemaVersion: 2,
+		type: "stage-scene",
+		elements: [],
+		bindings: []
+	};
+}
+function migrate(raw) {
+	if (Array.isArray(raw)) throw new Error("legacy GeoElement[] array — use the geoToScene codec (Phase 6)");
+	if (!raw || typeof raw !== "object") return emptyDoc();
+	const doc = raw;
+	return {
+		schemaVersion: 2,
+		type: "stage-scene",
+		view: doc.view,
+		width: doc.width,
+		height: doc.height,
+		elements: doc.elements ?? [],
+		bindings: doc.bindings ?? [],
+		meta: doc.meta
+	};
+}
+/** Stable JSON serialize (sorted nowhere needed yet; element order is meaningful). */
+function serialize(doc) {
+	return JSON.stringify(doc);
+}
+function parse(json) {
+	return migrate(JSON.parse(json));
+}
+
+//#endregion
+export { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize };

package/dist/scene/render.d.mts

@@ -0,0 +1,14 @@
+import { Vec2 } from "../core/vec.mjs";
+import { Id, SceneDoc } from "./types.mjs";
+import { Resolved } from "./resolve.mjs";
+import { ReactNode } from "react";
+
+//#region src/scene/render.d.ts
+interface RenderOpts {
+  draggablePoints: boolean;
+  onPointMove?: (id: Id, p: Vec2, phase: 'move' | 'commit') => void;
+  selection?: Id | null;
+}
+declare function renderElements(doc: SceneDoc, resolved: Resolved, opts: RenderOpts): ReactNode;
+//#endregion
+export { RenderOpts, renderElements };

package/dist/scene/render.mjs

@@ -0,0 +1,126 @@
+'use client';
+
+import { vec } from "../core/vec.mjs";
+import { Point } from "../primitives/Dot.mjs";
+import { Line, Segment } from "../primitives/Lines.mjs";
+import { Circle, Polygon } from "../primitives/Shapes.mjs";
+import { Label } from "../primitives/Label.mjs";
+import { MovableDot } from "../interaction/MovableDot.mjs";
+import { isAssetGeom, isCircleVal, isDerived, isLineVal, isVec2 } from "./types.mjs";
+import { getAsset } from "./assets.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/scene/render.tsx
+function parentRef(el, i) {
+	if (!isDerived(el)) return "";
+	const def = el.def;
+	if (def.op === "distance" || def.op === "angle") return def.of[i]?.ref ?? "";
+	return "";
+}
+function renderElements(doc, resolved, opts) {
+	const shapes = [];
+	const overlays = [];
+	const point = (ref) => {
+		const v = resolved.values.get(ref);
+		return isVec2(v) ? v : void 0;
+	};
+	for (const el of doc.elements) {
+		if (el.style?.hidden) continue;
+		const val = resolved.values.get(el.id);
+		const color = el.style?.color;
+		if (el.kind === "asset" && isAssetGeom(val) && isDerived(el) && el.def.op === "asset") {
+			const spec = getAsset(el.def.asset);
+			if (spec) {
+				const C = spec.Component;
+				shapes.push(/* @__PURE__ */ jsx(C, {
+					geom: val,
+					style: el.style,
+					label: el.label
+				}, el.id));
+			}
+		} else if (el.kind === "circle" && isCircleVal(val)) shapes.push(/* @__PURE__ */ jsx(Circle, {
+			center: val.center,
+			r: val.r,
+			color: color ?? "var(--stage-accent)",
+			fill: el.style?.fill ?? "none"
+		}, el.id));
+		else if ((el.kind === "line" || el.kind === "segment") && isLineVal(val)) shapes.push(el.kind === "line" ? /* @__PURE__ */ jsx(Line, {
+			from: val.a,
+			to: val.b,
+			color: color ?? "var(--stage-muted)",
+			dashed: el.style?.dashed
+		}, el.id) : /* @__PURE__ */ jsx(Segment, {
+			from: val.a,
+			to: val.b,
+			color: color ?? "var(--stage-good)",
+			dashed: el.style?.dashed
+		}, el.id));
+		else if (el.kind === "polygon" && Array.isArray(val)) shapes.push(/* @__PURE__ */ jsx(Polygon, {
+			points: val,
+			color: color ?? "var(--stage-accent)",
+			fill: el.style?.fill ?? "var(--stage-accent)"
+		}, el.id));
+		else if (el.kind === "measure" && isDerived(el)) {
+			const value = typeof val === "number" ? val : NaN;
+			const a = point(parentRef(el, 0));
+			const b = point(parentRef(el, 1));
+			const at = a && b ? vec.midpoint(a, b) : a;
+			if (at && Number.isFinite(value)) {
+				if (el.def.op === "distance" && a && b) shapes.push(/* @__PURE__ */ jsx(Segment, {
+					from: a,
+					to: b,
+					color: "var(--stage-muted)",
+					dashed: true,
+					weight: 1.5
+				}, `${el.id}-seg`));
+				overlays.push(/* @__PURE__ */ jsx(Label, {
+					x: at.x,
+					y: at.y,
+					dy: -8,
+					text: `${el.label ? el.label + " = " : ""}${value.toFixed(2)}`,
+					color: "var(--stage-warn)",
+					size: 13
+				}, el.id));
+			}
+		}
+	}
+	for (const el of doc.elements) {
+		if (el.style?.hidden) continue;
+		const val = resolved.values.get(el.id);
+		if (el.kind === "note" && isVec2(val)) overlays.push(/* @__PURE__ */ jsx(Label, {
+			x: val.x,
+			y: val.y,
+			text: "free" in el ? el.free.text : "",
+			color: el.style?.color ?? "var(--stage-fg)"
+		}, el.id));
+		else if (el.kind === "point" && isVec2(val)) {
+			const selected = opts.selection === el.id;
+			if (opts.draggablePoints && !!opts.onPointMove && "free" in el && !!el.free.draggable && "free" in el) {
+				const constrain = el.free.constrain === "horizontal" || el.free.constrain === "vertical" ? el.free.constrain : void 0;
+				overlays.push(/* @__PURE__ */ jsx(MovableDot, {
+					value: val,
+					onMove: (p, ph) => opts.onPointMove?.(el.id, p, ph),
+					constrain,
+					color: el.style?.color ?? "var(--stage-accent)",
+					ariaLabel: el.a11y?.label ?? el.label ?? "point"
+				}, el.id));
+			} else overlays.push(/* @__PURE__ */ jsx(Point, {
+				x: val.x,
+				y: val.y,
+				r: selected ? 7 : 6,
+				color: selected ? "var(--stage-warn)" : el.style?.color ?? "var(--stage-accent)"
+			}, el.id));
+			if (el.label) overlays.push(/* @__PURE__ */ jsx(Label, {
+				x: val.x,
+				y: val.y,
+				dy: -12,
+				text: el.label,
+				size: 13
+			}, `${el.id}-lbl`));
+		}
+	}
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shapes, overlays] });
+}
+
+//#endregion
+export { renderElements };

package/dist/scene/resolve.d.mts

@@ -0,0 +1,12 @@
+import { Vec2 } from "../core/vec.mjs";
+import { Id, SceneDoc, Val } from "./types.mjs";
+
+//#region src/scene/resolve.d.ts
+interface Resolved {
+  values: Map<Id, Val>;
+  order: Id[];
+  errors: Record<Id, string>;
+}
+declare function resolve(doc: SceneDoc, overlay?: ReadonlyMap<Id, Vec2 | number>, prev?: Resolved, simStates?: ReadonlyMap<Id, Record<string, unknown>>): Resolved;
+//#endregion
+export { Resolved, resolve };