@classytic/stage 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -32,6 +32,7 @@ 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 { PressSpringOpts, useImpulse, usePressSpring } from "./interaction/usePressSpring.mjs";
 import { HitCandidate, hitTest } from "./interaction/hitTest.mjs";
 import { OP_REFS, isRef, parentIds } from "./scene/schema.mjs";
 import { EVALUATORS, EvalCtx } from "./scene/evaluators.mjs";
@@ -42,6 +43,7 @@ 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 { CompiledFn, compile } from "./math/compile.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";
@@ -51,4 +53,4 @@ 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 };
+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 CompiledFn, 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 PressSpringOpts, 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, compile, 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, useImpulse, useInView, useLearner, usePressSpring, useScreenToMath, useStageRef, useStepProgress, vec };

package/dist/index.mjs

@@ -19,6 +19,7 @@ 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 { useImpulse, usePressSpring } from "./interaction/usePressSpring.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";
@@ -27,6 +28,7 @@ import { assetMeta, getAsset, listAssets, registerAsset } from "./scene/assets.m
 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 { compile } from "./math/compile.mjs";
 import { toLatex as toLatex$1 } from "./math/latex.mjs";
 import { compileExpr } from "./math/index.mjs";
 import { EVALUATORS } from "./scene/evaluators.mjs";
@@ -52,4 +54,4 @@ 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 };
+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, compile, 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, useImpulse, useInView, useLearner, usePressSpring, useScreenToMath, useStageRef, useStepProgress, vec };

package/dist/interaction/MovableDot.d.mts

@@ -18,6 +18,18 @@ interface MovableDotProps {
   /** 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;
+  /** Math-unit snap grid. Tells the handle the lattice so it can preview the
+   *  candidate landing spots (ghosts) and a snap-tick — purely visual; the lab
+   *  still owns the actual snapping in its onMove. 0/undefined = no preview. */
+  snap?: number;
+  /** Faint candidate snap-stops shown while dragging (default: on when `snap`
+   *  is set). Pass explicit points to drive non-grid lattices (e.g. stops along
+   *  a ray); otherwise they're derived from `snap` + the view + `constrain`. */
+  ghosts?: boolean;
+  ghostPoints?: Vec2[];
+  /** Live value pill near the handle while dragging. true = default formatter,
+   *  a fn for custom text, false to hide. Default true. */
+  readout?: boolean | ((v: Vec2) => string);
 }
 declare function MovableDot({
   value,
@@ -27,7 +39,11 @@ declare function MovableDot({
   r,
   ariaLabel,
   range,
-  step
+  step,
+  snap,
+  ghosts,
+  ghostPoints,
+  readout
 }: MovableDotProps): ReactNode;
 //#endregion
 export { MovableDot, MovableDotProps };

package/dist/interaction/MovableDot.mjs

@@ -2,12 +2,52 @@
 
 import { useCoords } from "../core/context.mjs";
 import { useDraggable } from "./useDraggable.mjs";
+import { useImpulse, usePressSpring } from "./usePressSpring.mjs";
 import { useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, 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 ACCENT = "var(--stage-accent)";
+function fnum(n) {
+	const r = Math.round(n * 100) / 100;
+	return Object.is(r, -0) ? "0" : String(r);
+}
+/** Candidate snap-stops within a small window around `value`, derived from the
+*  grid + which axes are free. Kept LOCAL (±3 steps) so the guide reads as
+*  "here are your nearby choices", not a wall of dots. */
+function autoGhosts(value, snap, constrain, view, range) {
+	if (!(snap > 0)) return [];
+	const W = 3;
+	const stops = [];
+	const along = (axis) => {
+		const base = axis === "x" ? value.x : value.y;
+		const lo = axis === "x" ? range?.min ?? view.xMin : range?.min ?? view.yMin;
+		const hi = axis === "x" ? range?.max ?? view.xMax : range?.max ?? view.yMax;
+		for (let k = -3; k <= W; k++) {
+			if (k === 0) continue;
+			const v = Math.round(base / snap) * snap + k * snap;
+			if (v < lo - 1e-9 || v > hi + 1e-9) continue;
+			stops.push(axis === "x" ? {
+				x: v,
+				y: value.y
+			} : {
+				x: value.x,
+				y: v
+			});
+		}
+	};
+	const oneD = constrain === "horizontal" || constrain === "vertical";
+	if (constrain === "horizontal") along("x");
+	else if (constrain === "vertical") along("y");
+	else if (!oneD && typeof constrain !== "function") {
+		along("x");
+		along("y");
+	}
+	return stops;
+}
+function MovableDot({ value, onMove, constrain, color = ACCENT, r = 7, ariaLabel = "draggable point", range, step, snap, ghosts, ghostPoints, readout = true }) {
+	const c = useCoords();
+	const [px, py] = c.toPx(value.x, value.y);
 	const { dragging, handlers, ariaProps } = useDraggable({
 		value,
 		onMove,
@@ -16,50 +56,108 @@ function MovableDot({ value, onMove, constrain, color = "var(--stage-accent)", r
 		...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", {
+	const press = usePressSpring(dragging, {
+		to: 1,
+		stiffness: 360,
+		damping: 24
+	});
+	const dotR = r + (hovered && !dragging ? 1.5 : 0) + press * 3;
+	const tickRaw = useImpulse(`${Math.round(value.x * 1e4)}:${Math.round(value.y * 1e4)}`, 280);
+	const tick = dragging ? tickRaw : 0;
+	const stops = !(dragging && (ghosts ?? (snap != null && snap > 0))) ? [] : ghostPoints ?? autoGhosts(value, snap ?? 0, constrain, c.view, range);
+	const label = readout === false ? null : typeof readout === "function" ? readout(value) : constrain === "horizontal" || constrain === "vertical" ? fnum(constrain === "vertical" ? value.y : value.x) : `(${fnum(value.x)}, ${fnum(value.y)})`;
+	const pillW = label ? Math.max(30, label.length * 7.5 + 14) : 0;
+	const pillY = py - dotR - 30;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		stops.length > 0 && /* @__PURE__ */ jsx("g", {
+			style: { pointerEvents: "none" },
+			children: stops.map((s, i) => {
+				const [gx, gy] = c.toPx(s.x, s.y);
+				const d = Math.hypot(gx - px, gy - py);
+				return /* @__PURE__ */ jsx("circle", {
+					cx: gx,
+					cy: gy,
+					r: 3,
+					fill: color,
+					opacity: Math.max(.12, .5 - d / 360)
+				}, i);
+			})
+		}),
+		/* @__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 + press * 4,
+					fill: color,
+					opacity: .18
+				}) : /* @__PURE__ */ jsx("circle", {
+					cx: px,
+					cy: py,
+					r: r + 5,
+					fill: "none",
+					stroke: color,
+					strokeWidth: 1.5,
+					opacity: hovered ? .55 : .28
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: px,
+					cy: py,
+					r: dotR,
+					fill: color,
+					stroke: "var(--stage-bg)",
+					strokeWidth: 2
+				})
+			]
+		}),
+		/* @__PURE__ */ jsxs("g", {
+			style: { pointerEvents: "none" },
+			children: [tick > 0 && /* @__PURE__ */ jsx("circle", {
 				cx: px,
 				cy: py,
-				r: r + 5,
+				r: dotR + (1 - tick) * 12,
 				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
-			})
-		]
-	});
+				strokeWidth: 2,
+				opacity: tick * .6
+			}), dragging && label && /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("rect", {
+				x: px - pillW / 2,
+				y: pillY,
+				width: pillW,
+				height: 22,
+				rx: 7,
+				fill: "var(--stage-bg)",
+				stroke: "var(--stage-grid)",
+				strokeWidth: 1,
+				opacity: .96
+			}), /* @__PURE__ */ jsx("text", {
+				x: px,
+				y: pillY + 11,
+				textAnchor: "middle",
+				dominantBaseline: "central",
+				fontSize: 12,
+				fontWeight: 700,
+				fill: "var(--stage-fg)",
+				style: { fontVariantNumeric: "tabular-nums" },
+				children: label
+			})] })]
+		})
+	] });
 }
 
 //#endregion

package/dist/interaction/index.d.mts

@@ -1,5 +1,6 @@
 import { useScreenToMath } from "./useScreenToMath.mjs";
 import { AriaSliderProps, Constrain, DraggableHandlers, UseDraggable, UseDraggableArgs, useDraggable } from "./useDraggable.mjs";
 import { MovableDot, MovableDotProps } from "./MovableDot.mjs";
+import { PressSpringOpts, useImpulse, usePressSpring } from "./usePressSpring.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 };
+export { type AriaSliderProps, type Constrain, type DraggableHandlers, type HitCandidate, MovableDot, type MovableDotProps, type PressSpringOpts, type UseDraggable, type UseDraggableArgs, hitTest, useDraggable, useImpulse, usePressSpring, useScreenToMath };

package/dist/interaction/index.mjs

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

package/dist/interaction/useDraggable.d.mts

@@ -10,7 +10,7 @@ interface UseDraggableArgs {
   constrain?: Constrain;
   /** Keyboard nudge step in math units. */
   step?: number;
-  /** Bounds on the active axis — drives aria-valuemin/max for a proper slider
+  /** 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;

package/dist/interaction/useDraggable.mjs

@@ -57,6 +57,7 @@ function useDraggable({ value, onMove, constrain, step = .5, range }) {
 	]);
 	const onKeyDown = useCallback((e) => {
 		const d = step * (e.shiftKey ? 5 : 1) * (e.altKey ? .25 : 1);
+		const vertical = constrain === "vertical";
 		let np = null;
 		if (e.key === "ArrowLeft") np = {
 			x: value.x - d,
@@ -74,6 +75,34 @@ function useDraggable({ value, onMove, constrain, step = .5, range }) {
 			x: value.x,
 			y: value.y - d
 		};
+		else if (e.key === "PageUp") np = vertical ? {
+			x: value.x,
+			y: value.y + 5 * step
+		} : {
+			x: value.x + 5 * step,
+			y: value.y
+		};
+		else if (e.key === "PageDown") np = vertical ? {
+			x: value.x,
+			y: value.y - 5 * step
+		} : {
+			x: value.x - 5 * step,
+			y: value.y
+		};
+		else if (e.key === "Home" && range) np = vertical ? {
+			x: value.x,
+			y: range.min
+		} : {
+			x: range.min,
+			y: value.y
+		};
+		else if (e.key === "End" && range) np = vertical ? {
+			x: value.x,
+			y: range.max
+		} : {
+			x: range.max,
+			y: value.y
+		};
 		if (np) {
 			e.preventDefault();
 			const p = constrained(np, value, constrain);
@@ -84,7 +113,8 @@ function useDraggable({ value, onMove, constrain, step = .5, range }) {
 		value,
 		step,
 		constrain,
-		onMove
+		onMove,
+		range
 	]);
 	const oneD = constrain === "horizontal" || constrain === "vertical";
 	const vertical = constrain === "vertical";

package/dist/interaction/usePressSpring.d.mts

@@ -0,0 +1,24 @@
+//#region src/interaction/usePressSpring.d.ts
+interface PressSpringOpts {
+  /** Resting value when inactive. Default 0. */
+  from?: number;
+  /** Target value when active. Default 1. */
+  to?: number;
+  stiffness?: number;
+  damping?: number;
+}
+/**
+ * A scalar that springs toward `to` while `active`, back to `from` on release,
+ * e.g. a 0→1 "press" amount you map to a radius bump or halo grow. The RAF loop
+ * is gated on "still moving" so a page full of idle handles costs nothing.
+ * Under reduced-motion it returns the target immediately (no animation).
+ */
+declare function usePressSpring(active: boolean, opts?: PressSpringOpts): number;
+/**
+ * A one-shot impulse: jumps to 1 whenever `key` changes, then decays to 0 over
+ * `ms`. Map it to an expanding ring / flash to make a discrete event (a snap, a
+ * correct landing) FEEL like it clicked. Returns 0 under reduced-motion.
+ */
+declare function useImpulse(key: number | string, ms?: number): number;
+//#endregion
+export { PressSpringOpts, useImpulse, usePressSpring };

package/dist/interaction/usePressSpring.mjs

@@ -0,0 +1,67 @@
+'use client';
+
+import { useFrameLoop } from "../core/clock.mjs";
+import { prefersReducedMotion, spring } from "../core/motion.mjs";
+import { useRef, useState } from "react";
+
+//#region src/interaction/usePressSpring.ts
+/**
+* Interaction "feel" hooks, the juice layer for draggable handles. Both are thin
+* wrappers over the pure `spring` / decay maths in core/motion.ts; they own a
+* frame loop that runs ONLY while the value is unsettled (no idle RAF), and they
+* honor prefers-reduced-motion by snapping to the end state. SSR-safe.
+*/
+const EPS = 8e-4;
+/**
+* A scalar that springs toward `to` while `active`, back to `from` on release,
+* e.g. a 0→1 "press" amount you map to a radius bump or halo grow. The RAF loop
+* is gated on "still moving" so a page full of idle handles costs nothing.
+* Under reduced-motion it returns the target immediately (no animation).
+*/
+function usePressSpring(active, opts = {}) {
+	const { from = 0, to = 1, stiffness = 320, damping = 26 } = opts;
+	const target = active ? to : from;
+	const reduce = prefersReducedMotion();
+	const [val, setVal] = useState(from);
+	const valRef = useRef(from);
+	const vel = useRef(0);
+	const settled = Math.abs(valRef.current - target) < EPS && Math.abs(vel.current) < EPS;
+	useFrameLoop((f) => {
+		const next = spring(valRef.current, target, vel, f.dtMs / 1e3, {
+			stiffness,
+			damping
+		});
+		if (Math.abs(next - target) < EPS && Math.abs(vel.current) < EPS) {
+			valRef.current = target;
+			vel.current = 0;
+			setVal(target);
+		} else {
+			valRef.current = next;
+			setVal(next);
+		}
+	}, { running: !reduce && !settled });
+	return reduce ? target : val;
+}
+/**
+* A one-shot impulse: jumps to 1 whenever `key` changes, then decays to 0 over
+* `ms`. Map it to an expanding ring / flash to make a discrete event (a snap, a
+* correct landing) FEEL like it clicked. Returns 0 under reduced-motion.
+*/
+function useImpulse(key, ms = 260) {
+	const [v, setV] = useState(0);
+	const amp = useRef(0);
+	const prevKey = useRef(key);
+	const reduce = prefersReducedMotion();
+	if (prevKey.current !== key) {
+		prevKey.current = key;
+		if (!reduce) amp.current = 1;
+	}
+	useFrameLoop((f) => {
+		amp.current = Math.max(0, amp.current - f.dtMs / ms);
+		setV(amp.current);
+	}, { running: !reduce && amp.current > 0 });
+	return reduce ? 0 : v;
+}
+
+//#endregion
+export { useImpulse, usePressSpring };

package/dist/logic/ast.d.mts

@@ -1,6 +1,6 @@
 //#region src/logic/ast.d.ts
 /**
- * Propositional-logic AST — the boolean-domain sibling of the `expr` engine's
+ * 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.

package/dist/logic/index.mjs

@@ -6,7 +6,7 @@ import { cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImp
 
 //#region src/logic/index.ts
 /**
-* @classytic/stage logic kernel — a pure, dependency-free propositional-logic
+* @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 +
@@ -18,11 +18,16 @@ import { cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImp
 function compileLogic(src) {
 	try {
 		const ast = parseLogic(src);
+		const vars = freeVars(ast);
 		return {
 			ok: true,
 			ast,
-			vars: freeVars(ast),
-			eval: (env) => evalBool(ast, env)
+			vars,
+			eval: (env) => {
+				const missing = vars.filter((v) => !(v in env));
+				if (missing.length) throw new Error(`logic: assignment is missing variable${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`);
+				return evalBool(ast, env);
+			}
 		};
 	} catch (e) {
 		return {

package/dist/logic/minimize.d.mts

@@ -17,11 +17,11 @@ interface Minimization {
 }
 /** All minterms a cube covers, within an n-variable space. */
 declare function cubeCovers(c: Cube, n: number): number[];
-/** The product term for a cube — a literal per FIXED bit (MSB = first var). */
+/** The product term for a cube, a literal per FIXED bit (MSB = first var). */
 declare function cubeTerm(c: Cube, vars: string[], neg?: string, join?: string): string;
 /** Quine–McCluskey prime implicants of a set of minterms (+ optional don't-cares). */
 declare function primeImplicants(minterms: number[], n: number, dontCares?: number[]): Cube[];
-/** A minimal SOP cover: essential prime implicants + a greedy fill of the rest. */
+/** A minimum SOP cover: essential prime implicants + Petrick's exact cover of the rest. */
 declare function minimalCover(minterms: number[], n: number, dontCares?: number[]): Cube[];
 /** Full minimisation of a formula (or explicit minterms) → cover + SOP string. */
 declare function minimize(input: LNode | {

package/dist/logic/minimize.mjs

@@ -3,9 +3,9 @@ import { truthTable } from "./table.mjs";
 
 //#region src/logic/minimize.ts
 /**
-* Boolean minimisation — Quine–McCluskey: the algorithm a Karnaugh map performs
+* Boolean minimisation, Quine–McCluskey: the algorithm a Karnaugh map performs
 * by eye. Given a function's minterms (the rows where it is 1) over n variables,
-* it finds the PRIME IMPLICANTS (maximal "don't-care cubes" — groups on the
+* it finds the PRIME IMPLICANTS (maximal "don't-care cubes", groups on the
 * K-map) and a minimal SUM-OF-PRODUCTS cover (essential PIs + a greedy fill).
 * Pure + dependency-free, the boolean sibling of `simplify` in the expr engine;
 * the K-map lab renders these cubes as the coloured groups, and the same routine
@@ -31,7 +31,7 @@ function cubeCovers(c, n) {
 	for (let m = 0; m < total; m++) if ((m & c.mask) === c.value) out.push(m);
 	return out;
 }
-/** The product term for a cube — a literal per FIXED bit (MSB = first var). */
+/** The product term for a cube, a literal per FIXED bit (MSB = first var). */
 function cubeTerm(c, vars, neg = "¬", join = " ∧ ") {
 	const n = vars.length;
 	const lits = [];
@@ -86,7 +86,56 @@ function coverageOf(pis, required) {
 	});
 	return map;
 }
-/** A minimal SOP cover: essential prime implicants + a greedy fill of the rest. */
+/** Keep only the minimal PI-sets (drop any that is a strict superset of another). */
+function absorb(products) {
+	const uniq = /* @__PURE__ */ new Map();
+	for (const p of products) {
+		const s = new Set(p);
+		uniq.set([...s].sort((a, b) => a - b).join(","), s);
+	}
+	const sets = [...uniq.values()];
+	return sets.filter((s) => !sets.some((o) => o !== s && o.size < s.size && [...o].every((x) => s.has(x)))).map((s) => [...s]);
+}
+/** Greedy fallback: take the PI covering the most still-uncovered minterms, repeat. */
+function greedyCover(uncovered, cov, candidates) {
+	const left = new Set(uncovered);
+	const picked = [];
+	while (left.size) {
+		let best = -1, bestCount = 0;
+		for (const i of candidates) {
+			if (picked.includes(i)) continue;
+			const c = cov.get(i).filter((m) => left.has(m)).length;
+			if (c > bestCount) {
+				bestCount = c;
+				best = i;
+			}
+		}
+		if (best < 0) break;
+		picked.push(best);
+		for (const m of cov.get(best)) left.delete(m);
+	}
+	return picked;
+}
+/**
+* Petrick's method: the EXACT minimum-size cover of the remaining minterms. Each minterm
+* contributes a clause (the PIs covering it); multiplying the clauses out (with absorption)
+* enumerates every irredundant cover, and we keep the one with the fewest PIs. Falls back to
+* greedy if the residual is large enough that the expansion could blow up (K-map labs are small).
+*/
+function petrickCover(uncovered, cov, candidates) {
+	if (candidates.length > 18) return greedyCover(uncovered, cov, candidates);
+	let products = [[]];
+	for (const m of uncovered) {
+		const clause = candidates.filter((i) => cov.get(i).includes(m));
+		if (clause.length === 0) return greedyCover(uncovered, cov, candidates);
+		const next = [];
+		for (const p of products) for (const pi of clause) next.push(p.includes(pi) ? p : [...p, pi]);
+		products = absorb(next);
+		if (products.length > 4e3) return greedyCover(uncovered, cov, candidates);
+	}
+	return products.reduce((best, p) => p.length < best.length ? p : best, products[0] ?? []);
+}
+/** A minimum SOP cover: essential prime implicants + Petrick's exact cover of the rest. */
 function minimalCover(minterms, n, dontCares = []) {
 	const required = new Set(minterms);
 	if (required.size === 0) return [];
@@ -100,20 +149,9 @@ function minimalCover(minterms, n, dontCares = []) {
 		if (owners.length === 1) chosen.add(owners[0]);
 	}
 	for (const i of chosen) for (const m of cov.get(i)) uncovered.delete(m);
-	while (uncovered.size) {
-		let best = -1, bestCount = -1;
-		pis.forEach((_, i) => {
-			if (chosen.has(i)) return;
-			const c = cov.get(i).filter((m) => uncovered.has(m)).length;
-			if (c > bestCount) {
-				bestCount = c;
-				best = i;
-			}
-		});
-		if (best < 0 || bestCount <= 0) break;
-		chosen.add(best);
-		for (const m of cov.get(best)) uncovered.delete(m);
-	}
+	if (uncovered.size === 0) return [...chosen].map((i) => pis[i]);
+	const candidates = pis.map((_, i) => i).filter((i) => !chosen.has(i));
+	for (const i of petrickCover([...uncovered], cov, candidates)) chosen.add(i);
 	return [...chosen].map((i) => pis[i]);
 }
 /** Full minimisation of a formula (or explicit minterms) → cover + SOP string. */

package/dist/logic/table.mjs

@@ -4,7 +4,7 @@ import { evalBool, freeVars } from "./ast.mjs";
 /**
 * Truth tables + the things derived from them: classification (tautology /
 * contradiction / contingency), logical equivalence, and DNF/CNF. Everything is
-* a fold over the 2ⁿ assignments — the truth table is the source of truth, so
+* a fold over the 2ⁿ assignments, the truth table is the source of truth, so
 * equivalence is just "same output column" (no algebraic law engine needed).
 */
 /** Enumerate all 2^vars assignments (MSB = first var), evaluating `n` on each. */

package/dist/math/ast.d.mts

@@ -1,6 +1,6 @@
 //#region src/math/ast.d.ts
 /**
- * expr/ast — the Abstract Syntax Tree: node types, evaluation, free-variable
+ * expr/ast, the Abstract Syntax Tree: node types, evaluation, free-variable
  * collection, and small builder helpers. The AST is the shared representation
  * that evaluation, differentiation, simplification, and LaTeX printing all
  * operate on.