@classytic/stage 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+import { StageAssetDefs } from "./assets/kit/svg-defs.mjs";
+import { BucketGlyph, GlyphBox, HangerHook, HangerHookProps, WeightGlyph, XBlockGlyph } from "./assets/kit/glyphs.mjs";
+import { Matrix, Vec2, mat, vec } from "./core/vec.mjs";
+import { CoordinateSystem, CoordsOptions, ViewBox, createCoords, fmt } from "./core/coords.mjs";
+import { AssetGeometry, Binding, CircleVal, DerivedDef, DerivedElement, DerivedKind, ElementBase, ElementStyle, FreeElement, FreeNote, FreePoint, FreeScalar, Id, LabMeta, NumOrRef, Op, Ref, SceneDoc, SceneElement, SceneMeta, ShapeLineVal, Val, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isVec2, numOf } from "./scene/types.mjs";
+import { Command, CommandResult, MutatePatch, applyCommand, collectRemoved, inverse } from "./scene/commands.mjs";
+import { Resolved, resolve } from "./scene/resolve.mjs";
+import { DispatchOpts, Editor, useEditor } from "./builder/editor.mjs";
+import { ControlMap, ControlSpec, ControlSurface, getControlSurface, listControlSurfaces, onControlChange, useControlSurface } from "./core/control.mjs";
+import { ControlPick, controlsFromScene } from "./builder/controls.mjs";
+import { IconName, ToolIcon } from "./builder/icons.mjs";
+import { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT, Tool, ToolCtx } from "./builder/tools.mjs";
+import { SceneBuilder, SceneBuilderProps } from "./builder/SceneBuilder.mjs";
+import { Palette, PaletteProps } from "./builder/Palette.mjs";
+import { CoordsContext, DragOverlayContext, StageRefContext, useCoords, useDragOverlay, useStageRef } from "./core/context.mjs";
+import { ClockProvider, ClockProviderProps, FrameDriver, FrameInfo, useFrameLoop } from "./core/clock.mjs";
+import { Learner, LearnerProvider, LearnerResult, PriorAttempts, useLearner } from "./core/learner.mjs";
+import { RichSpan, Script, parseRichText } from "./core/richText.mjs";
+import { StepProgress, StepProgressProvider, StepScope, StepSpec, StepState, useStepProgress } from "./steps/index.mjs";
+import { Stage, StageProps } from "./view/Stage.mjs";
+import { Size, useElementSize } from "./view/useElementSize.mjs";
+import { useInView } from "./view/useInView.mjs";
+import { A11yProps, StyleProps } from "./primitives/props.mjs";
+import { Dot, DotProps, Point } from "./primitives/Dot.mjs";
+import { Line, LineProps, Ray, Segment, SegmentProps, Vector, VectorProps } from "./primitives/Lines.mjs";
+import { Circle, CircleProps, Ellipse, EllipseProps, Path, PathProps, Polygon, PolygonProps, Polyline, PolylineProps } from "./primitives/Shapes.mjs";
+import { Label, LabelProps } from "./primitives/Label.mjs";
+import { Tex, TexProps } from "./primitives/Tex.mjs";
+import { Axes, AxesProps, Grid, GridProps, niceStep } from "./primitives/Grid.mjs";
+import { OfXProps, OfYProps, ParametricProps, Plot } from "./primitives/Plot.mjs";
+import { CanvasLayer, CanvasLayerProps } from "./primitives/CanvasLayer.mjs";
+import { useScreenToMath } from "./interaction/useScreenToMath.mjs";
+import { AriaSliderProps, Constrain, DraggableHandlers, UseDraggable, UseDraggableArgs, useDraggable } from "./interaction/useDraggable.mjs";
+import { MovableDot, MovableDotProps } from "./interaction/MovableDot.mjs";
+import { HitCandidate, hitTest } from "./interaction/hitTest.mjs";
+import { OP_REFS, isRef, parentIds } from "./scene/schema.mjs";
+import { EVALUATORS, EvalCtx } from "./scene/evaluators.mjs";
+import { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize } from "./scene/migrate.mjs";
+import { InstanceState, SceneStore } from "./scene/store.mjs";
+import { Scene, SceneProps } from "./scene/Scene.mjs";
+import { RenderOpts, renderElements } from "./scene/render.mjs";
+import { BinOp, Node, compileNode, evaluate, freeVars } from "./math/ast.mjs";
+import { parse as parse$1 } from "./math/parse.mjs";
+import { differentiate, simplify } from "./math/calculus.mjs";
+import { toLatex as toLatex$1 } from "./math/latex.mjs";
+import { CompiledExpr, ExprError, ExprResult, compileExpr } from "./math/index.mjs";
+import { BinOp as BinOp$1, LNode, evalBool, freeVars as freeVars$1 } from "./logic/ast.mjs";
+import { parseLogic } from "./logic/parse.mjs";
+import { Classification, TruthRow, TruthTable, classify, equivalent, toCNF, toDNF, truthTable } from "./logic/table.mjs";
+import { toLatex } from "./logic/latex.mjs";
+import { Cube, Minimization, cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImplicants } from "./logic/minimize.mjs";
+import { CompiledLogic, LogicResult, compileLogic } from "./logic/index.mjs";
+import { AssetResolveArgs, AssetSpec, assetMeta, getAsset, listAssets, registerAsset } from "./scene/assets.mjs";
+export { type A11yProps, AUTHORING_TOOLS, type AriaSliderProps, type AssetGeometry, type AssetResolveArgs, type AssetSpec, Axes, type AxesProps, type BinOp, type Binding, BucketGlyph, CIRCLE, CURRENT_SCHEMA_VERSION, CanvasLayer, type CanvasLayerProps, Circle, type CircleProps, type CircleVal, type Classification, ClockProvider, type ClockProviderProps, type Command, type CommandResult, type CompiledExpr, type CompiledLogic, type Constrain, type ControlMap, type ControlPick, type ControlSpec, type ControlSurface, type CoordinateSystem, CoordsContext, type CoordsOptions, type Cube, DELETE, type DerivedDef, type DerivedElement, type DerivedKind, type DispatchOpts, Dot, type DotProps, DragOverlayContext, type DraggableHandlers, EVALUATORS, Editor, type ElementBase, type ElementStyle, Ellipse, type EllipseProps, type EvalCtx, type ExprError, type ExprResult, type FrameDriver, type FrameInfo, type FreeElement, type FreeNote, type FreePoint, type FreeScalar, GEOMETRY_TOOLS, type GlyphBox, Grid, type GridProps, HangerHook, type HangerHookProps, type HitCandidate, INTERSECT, type IconName, type Id, type InstanceState, LINE, type LNode, type LabMeta, Label, type LabelProps, type Learner, LearnerProvider, type LearnerResult, Line, type LineProps, type BinOp$1 as LogicBinOp, type LogicResult, MEASURE, MIDPOINT, type Matrix, type Minimization, MovableDot, type MovableDotProps, type MutatePatch, NOTE, type Node, type NumOrRef, OP_REFS, type OfXProps, type OfYProps, type Op, POINT, Palette, type PaletteProps, type ParametricProps, Path, type PathProps, Plot, Point, Polygon, type PolygonProps, Polyline, type PolylineProps, type PriorAttempts, Ray, type Ref, type RenderOpts, type Resolved, type RichSpan, SCALAR, SEGMENT, SELECT, Scene, SceneBuilder, type SceneBuilderProps, type SceneDoc, type SceneElement, type SceneMeta, type SceneProps, SceneStore, type Vec2 as SceneVec2, type Script, Segment, type SegmentProps, type ShapeLineVal, type Size, Stage, StageAssetDefs, type StageProps, StageRefContext, type StepProgress, StepProgressProvider, StepScope, type StepSpec, type StepState, type StyleProps, Tex, type TexProps, type Tool, type ToolCtx, ToolIcon, type TruthRow, type TruthTable, type UseDraggable, type UseDraggableArgs, type Val, type Vec2, Vector, type VectorProps, type ViewBox, WeightGlyph, XBlockGlyph, applyCommand, assetMeta, classify, collectRemoved, compileExpr, compileLogic, compileNode, controlsFromScene, createCoords, cubeCovers, cubeOfSelection, cubeTerm, differentiate, emptyDoc, equivalent, evalBool, evaluate, fmt, freeVars, getAsset, getControlSurface, hitTest, inverse, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isRef, isVec2, listAssets, listControlSurfaces, freeVars$1 as logicFreeVars, toLatex as logicToLatex, mat, migrate, minimalCover, minimize, niceStep, numOf, onControlChange, parentIds, parse, parse$1 as parseExpr, parseLogic, parseRichText, primeImplicants, registerAsset, renderElements, resolve, serialize, simplify, toCNF, toDNF, toLatex$1 as toLatex, truthTable, useControlSurface, useCoords, useDragOverlay, useDraggable, useEditor, useElementSize, useFrameLoop, useInView, useLearner, useScreenToMath, useStageRef, useStepProgress, vec };

package/dist/index.mjs

@@ -0,0 +1,55 @@
+import { createCoords, fmt } from "./core/coords.mjs";
+import { parseRichText } from "./core/richText.mjs";
+import { mat, vec } from "./core/vec.mjs";
+import { CoordsContext, DragOverlayContext, StageRefContext, useCoords, useDragOverlay, useStageRef } from "./core/context.mjs";
+import { ClockProvider, useFrameLoop } from "./core/clock.mjs";
+import { getControlSurface, listControlSurfaces, onControlChange, useControlSurface } from "./core/control.mjs";
+import { LearnerProvider, useLearner } from "./core/learner.mjs";
+import { StepProgressProvider, StepScope, useStepProgress } from "./steps/index.mjs";
+import { useElementSize } from "./view/useElementSize.mjs";
+import { Stage } from "./view/Stage.mjs";
+import { useInView } from "./view/useInView.mjs";
+import { Dot, Point } from "./primitives/Dot.mjs";
+import { Line, Ray, Segment, Vector } from "./primitives/Lines.mjs";
+import { Circle, Ellipse, Path, Polygon, Polyline } from "./primitives/Shapes.mjs";
+import { Label } from "./primitives/Label.mjs";
+import { Tex } from "./primitives/Tex.mjs";
+import { Axes, Grid, niceStep } from "./primitives/Grid.mjs";
+import { Plot } from "./primitives/Plot.mjs";
+import { CanvasLayer } from "./primitives/CanvasLayer.mjs";
+import { useScreenToMath } from "./interaction/useScreenToMath.mjs";
+import { useDraggable } from "./interaction/useDraggable.mjs";
+import { MovableDot } from "./interaction/MovableDot.mjs";
+import { hitTest } from "./interaction/hitTest.mjs";
+import { isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isVec2, numOf } from "./scene/types.mjs";
+import { OP_REFS, isRef, parentIds } from "./scene/schema.mjs";
+import { assetMeta, getAsset, listAssets, registerAsset } from "./scene/assets.mjs";
+import { compileNode, evaluate, freeVars } from "./math/ast.mjs";
+import { parse as parse$1 } from "./math/parse.mjs";
+import { differentiate, simplify } from "./math/calculus.mjs";
+import { toLatex as toLatex$1 } from "./math/latex.mjs";
+import { compileExpr } from "./math/index.mjs";
+import { EVALUATORS } from "./scene/evaluators.mjs";
+import { resolve } from "./scene/resolve.mjs";
+import { applyCommand, collectRemoved, inverse } from "./scene/commands.mjs";
+import { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize } from "./scene/migrate.mjs";
+import { SceneStore } from "./scene/store.mjs";
+import { renderElements } from "./scene/render.mjs";
+import { Scene } from "./scene/Scene.mjs";
+import { Editor, useEditor } from "./builder/editor.mjs";
+import { controlsFromScene } from "./builder/controls.mjs";
+import { ToolIcon } from "./builder/icons.mjs";
+import { Palette } from "./builder/Palette.mjs";
+import { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT } from "./builder/tools.mjs";
+import { SceneBuilder } from "./builder/SceneBuilder.mjs";
+import { StageAssetDefs } from "./assets/kit/svg-defs.mjs";
+import { BucketGlyph, HangerHook, WeightGlyph, XBlockGlyph } from "./assets/kit/glyphs.mjs";
+import "./assets/kit/index.mjs";
+import { evalBool, freeVars as freeVars$1 } from "./logic/ast.mjs";
+import { parseLogic } from "./logic/parse.mjs";
+import { classify, equivalent, toCNF, toDNF, truthTable } from "./logic/table.mjs";
+import { toLatex } from "./logic/latex.mjs";
+import { cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImplicants } from "./logic/minimize.mjs";
+import { compileLogic } from "./logic/index.mjs";
+
+export { AUTHORING_TOOLS, Axes, BucketGlyph, CIRCLE, CURRENT_SCHEMA_VERSION, CanvasLayer, Circle, ClockProvider, CoordsContext, DELETE, Dot, DragOverlayContext, EVALUATORS, Editor, Ellipse, GEOMETRY_TOOLS, Grid, HangerHook, INTERSECT, LINE, Label, LearnerProvider, Line, MEASURE, MIDPOINT, MovableDot, NOTE, OP_REFS, POINT, Palette, Path, Plot, Point, Polygon, Polyline, Ray, SCALAR, SEGMENT, SELECT, Scene, SceneBuilder, SceneStore, Segment, Stage, StageAssetDefs, StageRefContext, StepProgressProvider, StepScope, Tex, ToolIcon, Vector, WeightGlyph, XBlockGlyph, applyCommand, assetMeta, classify, collectRemoved, compileExpr, compileLogic, compileNode, controlsFromScene, createCoords, cubeCovers, cubeOfSelection, cubeTerm, differentiate, emptyDoc, equivalent, evalBool, evaluate, fmt, freeVars, getAsset, getControlSurface, hitTest, inverse, isAssetGeom, isCircleVal, isDerived, isFree, isLineVal, isRef, isVec2, listAssets, listControlSurfaces, freeVars$1 as logicFreeVars, toLatex as logicToLatex, mat, migrate, minimalCover, minimize, niceStep, numOf, onControlChange, parentIds, parse, parse$1 as parseExpr, parseLogic, parseRichText, primeImplicants, registerAsset, renderElements, resolve, serialize, simplify, toCNF, toDNF, toLatex$1 as toLatex, truthTable, useControlSurface, useCoords, useDragOverlay, useDraggable, useEditor, useElementSize, useFrameLoop, useInView, useLearner, useScreenToMath, useStageRef, useStepProgress, vec };

package/dist/interaction/MovableDot.d.mts

@@ -0,0 +1,33 @@
+import { Vec2 } from "../core/vec.mjs";
+import { Constrain } from "./useDraggable.mjs";
+import { ReactNode } from "react";
+
+//#region src/interaction/MovableDot.d.ts
+interface MovableDotProps {
+  value: Vec2;
+  onMove: (p: Vec2, phase: 'move' | 'commit') => void;
+  constrain?: Constrain;
+  color?: string;
+  r?: number;
+  ariaLabel?: string;
+  /** Active-axis bounds → aria-valuemin/max for a proper slider. */
+  range?: {
+    min: number;
+    max: number;
+  };
+  /** Keyboard arrow-key nudge in math units. Match the lab's snap grid so a
+   *  single arrow press actually moves (e.g. 1 for an integer number line). */
+  step?: number;
+}
+declare function MovableDot({
+  value,
+  onMove,
+  constrain,
+  color,
+  r,
+  ariaLabel,
+  range,
+  step
+}: MovableDotProps): ReactNode;
+//#endregion
+export { MovableDot, MovableDotProps };

package/dist/interaction/MovableDot.mjs

@@ -0,0 +1,66 @@
+'use client';
+
+import { useCoords } from "../core/context.mjs";
+import { useDraggable } from "./useDraggable.mjs";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/interaction/MovableDot.tsx
+function MovableDot({ value, onMove, constrain, color = "var(--stage-accent)", r = 7, ariaLabel = "draggable point", range, step }) {
+	const [px, py] = useCoords().toPx(value.x, value.y);
+	const { dragging, handlers, ariaProps } = useDraggable({
+		value,
+		onMove,
+		constrain,
+		range,
+		...step !== void 0 ? { step } : {}
+	});
+	const [hovered, setHovered] = useState(false);
+	const lift = hovered && !dragging;
+	const dotR = lift ? r + 1.5 : r;
+	return /* @__PURE__ */ jsxs("g", {
+		...handlers,
+		...ariaProps,
+		"aria-label": ariaLabel,
+		onPointerEnter: () => setHovered(true),
+		onPointerLeave: () => setHovered(false),
+		style: {
+			cursor: dragging ? "grabbing" : "grab",
+			outline: "none"
+		},
+		children: [
+			/* @__PURE__ */ jsx("circle", {
+				cx: px,
+				cy: py,
+				r: Math.max(r + 14, 12),
+				fill: "transparent"
+			}),
+			dragging ? /* @__PURE__ */ jsx("circle", {
+				cx: px,
+				cy: py,
+				r: r + 6,
+				fill: color,
+				opacity: .2
+			}) : /* @__PURE__ */ jsx("circle", {
+				cx: px,
+				cy: py,
+				r: r + 5,
+				fill: "none",
+				stroke: color,
+				strokeWidth: 1.5,
+				opacity: lift ? .55 : .28
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				cx: px,
+				cy: py,
+				r: dotR,
+				fill: color,
+				stroke: "var(--stage-bg)",
+				strokeWidth: 2
+			})
+		]
+	});
+}
+
+//#endregion
+export { MovableDot };

package/dist/interaction/hitTest.d.mts

@@ -0,0 +1,16 @@
+import { Vec2 } from "../core/vec.mjs";
+import { CoordinateSystem } from "../core/coords.mjs";
+
+//#region src/interaction/hitTest.d.ts
+interface HitCandidate {
+  id: string;
+  kind: 'point' | 'circle' | 'line' | 'segment';
+  point?: Vec2;
+  center?: Vec2;
+  r?: number;
+  a?: Vec2;
+  b?: Vec2;
+}
+declare function hitTest(c: CoordinateSystem, math: Vec2, candidates: HitCandidate[], pxTol?: number): string | null;
+//#endregion
+export { HitCandidate, hitTest };

package/dist/interaction/hitTest.mjs

@@ -0,0 +1,39 @@
+//#region src/interaction/hitTest.ts
+function distToSeg(p, a, b, infinite) {
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	const l2 = dx * dx + dy * dy || 1;
+	let t = ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l2;
+	if (!infinite) t = Math.max(0, Math.min(1, t));
+	return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
+}
+function hitTest(c, math, candidates, pxTol = 12) {
+	const m = c.toPx(math.x, math.y);
+	let best = null;
+	let bestD = pxTol;
+	for (const cand of candidates) {
+		if (cand.kind !== "point" || !cand.point) continue;
+		const p = c.toPx(cand.point.x, cand.point.y);
+		const d = Math.hypot(m[0] - p[0], m[1] - p[1]);
+		if (d < bestD) {
+			bestD = d;
+			best = cand.id;
+		}
+	}
+	if (best) return best;
+	for (const cand of candidates) {
+		let d = Infinity;
+		if (cand.kind === "circle" && cand.center && cand.r != null) {
+			const ctr = c.toPx(cand.center.x, cand.center.y);
+			d = Math.abs(Math.hypot(m[0] - ctr[0], m[1] - ctr[1]) - c.sx(cand.r));
+		} else if ((cand.kind === "line" || cand.kind === "segment") && cand.a && cand.b) d = distToSeg(m, c.toPx(cand.a.x, cand.a.y), c.toPx(cand.b.x, cand.b.y), cand.kind === "line");
+		if (d < bestD) {
+			bestD = d;
+			best = cand.id;
+		}
+	}
+	return best;
+}
+
+//#endregion
+export { hitTest };

package/dist/interaction/index.d.mts

@@ -0,0 +1,5 @@
+import { useScreenToMath } from "./useScreenToMath.mjs";
+import { AriaSliderProps, Constrain, DraggableHandlers, UseDraggable, UseDraggableArgs, useDraggable } from "./useDraggable.mjs";
+import { MovableDot, MovableDotProps } from "./MovableDot.mjs";
+import { HitCandidate, hitTest } from "./hitTest.mjs";
+export { type AriaSliderProps, type Constrain, type DraggableHandlers, type HitCandidate, MovableDot, type MovableDotProps, type UseDraggable, type UseDraggableArgs, hitTest, useDraggable, useScreenToMath };

package/dist/interaction/index.mjs

@@ -0,0 +1,6 @@
+import { useScreenToMath } from "./useScreenToMath.mjs";
+import { useDraggable } from "./useDraggable.mjs";
+import { MovableDot } from "./MovableDot.mjs";
+import { hitTest } from "./hitTest.mjs";
+
+export { MovableDot, hitTest, useDraggable, useScreenToMath };

package/dist/interaction/useDraggable.d.mts

@@ -0,0 +1,51 @@
+import { Vec2 } from "../core/vec.mjs";
+import { KeyboardEvent, PointerEvent } from "react";
+
+//#region src/interaction/useDraggable.d.ts
+type Constrain = 'horizontal' | 'vertical' | ((p: Vec2) => Vec2);
+interface UseDraggableArgs {
+  value: Vec2;
+  /** 'move' fires per pointer frame (ephemeral); 'commit' fires on pointer-up / key. */
+  onMove: (p: Vec2, phase: 'move' | 'commit') => void;
+  constrain?: Constrain;
+  /** Keyboard nudge step in math units. */
+  step?: number;
+  /** Bounds on the active axis — drives aria-valuemin/max for a proper slider
+   *  (WAI-ARIA APG). Omit for an unbounded 2D point (valuetext still describes it). */
+  range?: {
+    min: number;
+    max: number;
+  };
+}
+/** WAI-ARIA slider semantics for the handle. For a constrained (1D) drag this is
+ *  a real slider (valuenow/min/max on the active axis); for a free 2D point the
+ *  valuetext conveys the "x, y" position a screen reader announces. */
+interface AriaSliderProps {
+  role: 'slider';
+  tabIndex: 0;
+  'aria-orientation': 'horizontal' | 'vertical';
+  'aria-valuenow': number;
+  'aria-valuetext': string;
+  'aria-valuemin'?: number;
+  'aria-valuemax'?: number;
+}
+interface DraggableHandlers {
+  onPointerDown: (e: PointerEvent) => void;
+  onPointerMove: (e: PointerEvent) => void;
+  onPointerUp: (e: PointerEvent) => void;
+  onKeyDown: (e: KeyboardEvent) => void;
+}
+interface UseDraggable {
+  dragging: boolean;
+  handlers: DraggableHandlers;
+  ariaProps: AriaSliderProps;
+}
+declare function useDraggable({
+  value,
+  onMove,
+  constrain,
+  step,
+  range
+}: UseDraggableArgs): UseDraggable;
+//#endregion
+export { AriaSliderProps, Constrain, DraggableHandlers, UseDraggable, UseDraggableArgs, useDraggable };

package/dist/interaction/useDraggable.mjs

@@ -0,0 +1,116 @@
+'use client';
+
+import { useScreenToMath } from "./useScreenToMath.mjs";
+import { useCallback, useRef, useState } from "react";
+
+//#region src/interaction/useDraggable.ts
+function constrained(p, start, constrain) {
+	if (!constrain) return p;
+	if (constrain === "horizontal") return {
+		x: p.x,
+		y: start.y
+	};
+	if (constrain === "vertical") return {
+		x: start.x,
+		y: p.y
+	};
+	return constrain(p);
+}
+function useDraggable({ value, onMove, constrain, step = .5, range }) {
+	const toMath = useScreenToMath();
+	const [dragging, setDragging] = useState(false);
+	const startRef = useRef(value);
+	const onPointerDown = useCallback((e) => {
+		e.currentTarget.setPointerCapture(e.pointerId);
+		startRef.current = value;
+		setDragging(true);
+		e.stopPropagation();
+	}, [value]);
+	const onPointerMove = useCallback((e) => {
+		if (!dragging) return;
+		const m = toMath(e);
+		if (!m) return;
+		onMove(constrained({
+			x: m[0],
+			y: m[1]
+		}, startRef.current, constrain), "move");
+	}, [
+		dragging,
+		toMath,
+		constrain,
+		onMove
+	]);
+	const onPointerUp = useCallback((e) => {
+		if (!dragging) return;
+		setDragging(false);
+		const m = toMath(e);
+		onMove(m ? constrained({
+			x: m[0],
+			y: m[1]
+		}, startRef.current, constrain) : value, "commit");
+	}, [
+		dragging,
+		toMath,
+		constrain,
+		onMove,
+		value
+	]);
+	const onKeyDown = useCallback((e) => {
+		const d = step * (e.shiftKey ? 5 : 1) * (e.altKey ? .25 : 1);
+		let np = null;
+		if (e.key === "ArrowLeft") np = {
+			x: value.x - d,
+			y: value.y
+		};
+		else if (e.key === "ArrowRight") np = {
+			x: value.x + d,
+			y: value.y
+		};
+		else if (e.key === "ArrowUp") np = {
+			x: value.x,
+			y: value.y + d
+		};
+		else if (e.key === "ArrowDown") np = {
+			x: value.x,
+			y: value.y - d
+		};
+		if (np) {
+			e.preventDefault();
+			const p = constrained(np, value, constrain);
+			onMove(p, "move");
+			onMove(p, "commit");
+		}
+	}, [
+		value,
+		step,
+		constrain,
+		onMove
+	]);
+	const oneD = constrain === "horizontal" || constrain === "vertical";
+	const vertical = constrain === "vertical";
+	const now = vertical ? value.y : value.x;
+	const ariaProps = {
+		role: "slider",
+		tabIndex: 0,
+		"aria-orientation": vertical ? "vertical" : "horizontal",
+		"aria-valuenow": Number(now.toFixed(4)),
+		"aria-valuetext": oneD ? now.toFixed(2) : `x ${value.x.toFixed(2)}, y ${value.y.toFixed(2)}`,
+		...range ? {
+			"aria-valuemin": range.min,
+			"aria-valuemax": range.max
+		} : {}
+	};
+	return {
+		dragging,
+		handlers: {
+			onPointerDown,
+			onPointerMove,
+			onPointerUp,
+			onKeyDown
+		},
+		ariaProps
+	};
+}
+
+//#endregion
+export { useDraggable };

package/dist/interaction/useScreenToMath.d.mts

@@ -0,0 +1,12 @@
+//#region src/interaction/useScreenToMath.d.ts
+/**
+ * Returns a fn mapping a pointer/client position to math coordinates via the
+ * SVG's getScreenCTM() (handles scroll, CSS scaling, zoom). Null-guarded for
+ * SSR / pre-layout. Render and pick always agree because both use one space.
+ */
+declare function useScreenToMath(): (e: {
+  clientX: number;
+  clientY: number;
+}) => [number, number] | null;
+//#endregion
+export { useScreenToMath };

package/dist/interaction/useScreenToMath.mjs

@@ -0,0 +1,25 @@
+'use client';
+
+import { useCoords, useStageRef } from "../core/context.mjs";
+import { useCallback } from "react";
+
+//#region src/interaction/useScreenToMath.ts
+/**
+* Returns a fn mapping a pointer/client position to math coordinates via the
+* SVG's getScreenCTM() (handles scroll, CSS scaling, zoom). Null-guarded for
+* SSR / pre-layout. Render and pick always agree because both use one space.
+*/
+function useScreenToMath() {
+	const coords = useCoords();
+	const ref = useStageRef();
+	return useCallback((e) => {
+		const svg = ref?.current;
+		const ctm = svg?.getScreenCTM();
+		if (!svg || !ctm) return null;
+		const pt = new DOMPoint(e.clientX, e.clientY).matrixTransform(ctm.inverse());
+		return coords.toMath(pt.x, pt.y);
+	}, [coords, ref]);
+}
+
+//#endregion
+export { useScreenToMath };

package/dist/logic/ast.d.mts

@@ -0,0 +1,29 @@
+//#region src/logic/ast.d.ts
+/**
+ * Propositional-logic AST — the boolean-domain sibling of the `expr` engine's
+ * numeric AST. A formula is variables joined by ¬ ∧ ∨ ⊕ → ↔. Pure + zero-dep;
+ * `evalBool` is the single evaluator every consumer (truth tables, equivalence,
+ * boolean circuits) runs.
+ */
+type BinOp = 'and' | 'or' | 'xor' | 'implies' | 'iff';
+type LNode = {
+  kind: 'var';
+  name: string;
+} | {
+  kind: 'const';
+  value: boolean;
+} | {
+  kind: 'not';
+  a: LNode;
+} | {
+  kind: 'bin';
+  op: BinOp;
+  a: LNode;
+  b: LNode;
+};
+/** Evaluate a formula under a truth assignment. Unknown vars → false. */
+declare function evalBool(n: LNode, env: Record<string, boolean>): boolean;
+/** Distinct variable names in a formula, sorted (stable column order). */
+declare function freeVars(n: LNode): string[];
+//#endregion
+export { BinOp, LNode, evalBool, freeVars };

package/dist/logic/ast.mjs

@@ -0,0 +1,37 @@
+//#region src/logic/ast.ts
+/** Evaluate a formula under a truth assignment. Unknown vars → false. */
+function evalBool(n, env) {
+	switch (n.kind) {
+		case "var": return env[n.name] === true;
+		case "const": return n.value;
+		case "not": return !evalBool(n.a, env);
+		case "bin": {
+			const a = evalBool(n.a, env);
+			const b = () => evalBool(n.b, env);
+			switch (n.op) {
+				case "and": return a && b();
+				case "or": return a || b();
+				case "xor": return a !== b();
+				case "implies": return !a || b();
+				case "iff": return a === b();
+			}
+		}
+	}
+}
+/** Distinct variable names in a formula, sorted (stable column order). */
+function freeVars(n) {
+	const out = /* @__PURE__ */ new Set();
+	const walk = (x) => {
+		if (x.kind === "var") out.add(x.name);
+		else if (x.kind === "not") walk(x.a);
+		else if (x.kind === "bin") {
+			walk(x.a);
+			walk(x.b);
+		}
+	};
+	walk(n);
+	return [...out].sort();
+}
+
+//#endregion
+export { evalBool, freeVars };

package/dist/logic/index.d.mts

@@ -0,0 +1,25 @@
+import { BinOp, LNode, evalBool, freeVars } from "./ast.mjs";
+import { parseLogic } from "./parse.mjs";
+import { Classification, TruthRow, TruthTable, classify, equivalent, toCNF, toDNF, truthTable } from "./table.mjs";
+import { toLatex } from "./latex.mjs";
+import { Cube, Minimization, cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImplicants } from "./minimize.mjs";
+
+//#region src/logic/index.d.ts
+interface CompiledLogic {
+  ast: LNode;
+  /** Variables in stable (sorted) order. */
+  vars: string[];
+  /** Evaluate under a truth assignment. */
+  eval: (env: Record<string, boolean>) => boolean;
+}
+type LogicResult = (CompiledLogic & {
+  ok: true;
+}) | {
+  ok: false;
+  error: string;
+};
+/** Parse + ready a formula, returning a typed error instead of throwing (so a
+ *  lab/agent can surface bad input without a broken scene). */
+declare function compileLogic(src: string): LogicResult;
+//#endregion
+export { type BinOp, type Classification, CompiledLogic, type Cube, type LNode, LogicResult, type Minimization, type TruthRow, type TruthTable, classify, compileLogic, cubeCovers, cubeOfSelection, cubeTerm, equivalent, evalBool, freeVars, minimalCover, minimize, parseLogic, primeImplicants, toCNF, toDNF, toLatex, truthTable };

package/dist/logic/index.mjs

@@ -0,0 +1,36 @@
+import { evalBool, freeVars } from "./ast.mjs";
+import { parseLogic } from "./parse.mjs";
+import { classify, equivalent, toCNF, toDNF, truthTable } from "./table.mjs";
+import { toLatex } from "./latex.mjs";
+import { cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImplicants } from "./minimize.mjs";
+
+//#region src/logic/index.ts
+/**
+* @classytic/stage logic kernel — a pure, dependency-free propositional-logic
+* engine, the boolean-domain sibling of the `expr` (numeric) engine. Parses
+* ¬ ∧ ∨ ⊕ → ↔ (unicode or ASCII), evaluates, builds truth tables, classifies
+* tautology/contradiction/contingency, checks equivalence, and emits DNF/CNF +
+* LaTeX. Reused by the discrete-math labs (truth tables, boolean circuits,
+* Karnaugh maps) AND ICT boolean lessons. Mirrors `compileExpr`'s shape.
+*/
+/** Parse + ready a formula, returning a typed error instead of throwing (so a
+*  lab/agent can surface bad input without a broken scene). */
+function compileLogic(src) {
+	try {
+		const ast = parseLogic(src);
+		return {
+			ok: true,
+			ast,
+			vars: freeVars(ast),
+			eval: (env) => evalBool(ast, env)
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+
+//#endregion
+export { classify, compileLogic, cubeCovers, cubeOfSelection, cubeTerm, equivalent, evalBool, freeVars, minimalCover, minimize, parseLogic, primeImplicants, toCNF, toDNF, toLatex, truthTable };

package/dist/logic/latex.d.mts

@@ -0,0 +1,6 @@
+import { LNode } from "./ast.mjs";
+
+//#region src/logic/latex.d.ts
+declare function toLatex(n: LNode): string;
+//#endregion
+export { toLatex };