@classytic/stage 0.2.0 → 0.4.0

package/dist/finance/management-accounting/variances.mjs

@@ -0,0 +1,150 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/variances.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function analyzeCostVariances(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	if ([
+		facts.actualOutputUnits,
+		facts.material.standardQuantityPerUnit,
+		facts.material.standardPricePerUnit,
+		facts.material.actualQuantity,
+		facts.material.actualPricePerUnit,
+		facts.labour.standardHoursPerUnit,
+		facts.labour.standardRatePerHour,
+		facts.labour.actualHours,
+		facts.labour.actualRatePerHour,
+		facts.variableOverhead.standardRatePerHour,
+		facts.variableOverhead.actualRatePerHour,
+		facts.fixedOverhead.budgeted,
+		facts.fixedOverhead.actual
+	].some((value) => !Number.isFinite(value) || value < 0)) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: "Variance inputs must be finite and non-negative."
+	});
+	if (!Number.isFinite(facts.fixedOverhead.normalCapacityHours) || facts.fixedOverhead.normalCapacityHours <= 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: "Normal capacity hours must be finite and positive."
+	});
+	if (diagnostics.length > 0) return emptyResult(diagnostics);
+	const standardQuantity = facts.actualOutputUnits * facts.material.standardQuantityPerUnit;
+	const standardHours = facts.actualOutputUnits * facts.labour.standardHoursPerUnit;
+	const variance = (amount) => {
+		const rounded = money(amount, policy);
+		return {
+			amount: Math.abs(rounded),
+			outcome: rounded > 0 ? "favorable" : rounded < 0 ? "adverse" : "none"
+		};
+	};
+	const signed = (item) => item.outcome === "favorable" ? item.amount : item.outcome === "adverse" ? -item.amount : 0;
+	const combine = (...items) => variance(items.reduce((sum, item) => sum + signed(item), 0));
+	const materialPrice = variance(facts.material.actualQuantity * (facts.material.standardPricePerUnit - facts.material.actualPricePerUnit));
+	const materialUsage = variance(facts.material.standardPricePerUnit * (standardQuantity - facts.material.actualQuantity));
+	const labourRate = variance(facts.labour.actualHours * (facts.labour.standardRatePerHour - facts.labour.actualRatePerHour));
+	const labourEfficiency = variance(facts.labour.standardRatePerHour * (standardHours - facts.labour.actualHours));
+	const variableExpenditure = variance(facts.labour.actualHours * (facts.variableOverhead.standardRatePerHour - facts.variableOverhead.actualRatePerHour));
+	const variableEfficiency = variance(facts.variableOverhead.standardRatePerHour * (standardHours - facts.labour.actualHours));
+	const fixedExpenditure = variance(facts.fixedOverhead.budgeted - facts.fixedOverhead.actual);
+	const fixedVolume = variance(standardHours * (facts.fixedOverhead.budgeted / facts.fixedOverhead.normalCapacityHours) - facts.fixedOverhead.budgeted);
+	const materialTotal = combine(materialPrice, materialUsage);
+	const labourTotal = combine(labourRate, labourEfficiency);
+	const variableTotal = combine(variableExpenditure, variableEfficiency);
+	const fixedTotal = combine(fixedExpenditure, fixedVolume);
+	const totalCostVariance = combine(materialTotal, labourTotal, variableTotal, fixedTotal);
+	const trace = [
+		{
+			id: "variance:material-price",
+			kind: "derive",
+			rule: "Material price variance = actual quantity × (standard price − actual price). Positive is favorable.",
+			working: `${facts.material.actualQuantity} × (${facts.material.standardPricePerUnit} − ${facts.material.actualPricePerUnit})`,
+			result: signed(materialPrice)
+		},
+		{
+			id: "variance:material-usage",
+			kind: "derive",
+			rule: "Material usage variance = standard price × (standard quantity for output − actual quantity). Positive is favorable.",
+			working: `${facts.material.standardPricePerUnit} × (${standardQuantity} − ${facts.material.actualQuantity})`,
+			result: signed(materialUsage)
+		},
+		{
+			id: "variance:labour-rate",
+			kind: "derive",
+			rule: "Labour rate variance = actual hours × (standard rate − actual rate). Positive is favorable.",
+			working: `${facts.labour.actualHours} × (${facts.labour.standardRatePerHour} − ${facts.labour.actualRatePerHour})`,
+			result: signed(labourRate)
+		},
+		{
+			id: "variance:labour-efficiency",
+			kind: "derive",
+			rule: "Labour efficiency variance = standard rate × (standard hours for output − actual hours). Positive is favorable.",
+			working: `${facts.labour.standardRatePerHour} × (${standardHours} − ${facts.labour.actualHours})`,
+			result: signed(labourEfficiency)
+		}
+	];
+	return {
+		completed: true,
+		standardQuantity,
+		standardHours,
+		material: {
+			price: materialPrice,
+			usage: materialUsage,
+			total: materialTotal
+		},
+		labour: {
+			rate: labourRate,
+			efficiency: labourEfficiency,
+			total: labourTotal
+		},
+		variableOverhead: {
+			expenditure: variableExpenditure,
+			efficiency: variableEfficiency,
+			total: variableTotal
+		},
+		fixedOverhead: {
+			expenditure: fixedExpenditure,
+			volume: fixedVolume,
+			total: fixedTotal
+		},
+		totalCostVariance,
+		diagnostics,
+		trace
+	};
+}
+const money = (value, policy) => fromMinor(toMinor(value, policy), policy);
+const zero = {
+	amount: 0,
+	outcome: "none"
+};
+const emptyResult = (diagnostics) => ({
+	completed: false,
+	standardQuantity: 0,
+	standardHours: 0,
+	material: {
+		price: zero,
+		usage: zero,
+		total: zero
+	},
+	labour: {
+		rate: zero,
+		efficiency: zero,
+		total: zero
+	},
+	variableOverhead: {
+		expenditure: zero,
+		efficiency: zero,
+		total: zero
+	},
+	fixedOverhead: {
+		expenditure: zero,
+		volume: zero,
+		total: zero
+	},
+	totalCostVariance: zero,
+	diagnostics,
+	trace: []
+});
+
+//#endregion
+export { analyzeCostVariances };

package/dist/index.d.mts

@@ -12,9 +12,16 @@ 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 { BinOp, Node, compileNode, evaluate, freeVars } from "./math/ast.mjs";
+import { parse as parse$1 } from "./math/parse.mjs";
+import { definiteIntegral, differentiate, integrate, 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/expr.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 { approxEq, clamp, clamp01, gcd, remap, round, snapTo, toDeg, toRad } from "./core/math.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";
@@ -26,7 +33,7 @@ import { Line, LineProps, Ray, Segment, SegmentProps, Vector, VectorProps } from
 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 { Axes, AxesProps, ClearZone, Grid, GridProps, clearOfLabel, 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";
@@ -40,12 +47,6 @@ import { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize } from "./s
 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 { 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";
 import { parseLogic } from "./logic/parse.mjs";
 import { Classification, TruthRow, TruthTable, classify, equivalent, toCNF, toDNF, truthTable } from "./logic/table.mjs";
@@ -53,4 +54,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 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 };
+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, type ClearZone, 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, approxEq, assetMeta, clamp, clamp01, classify, clearOfLabel, collectRemoved, compile, compileExpr, compileLogic, compileNode, controlsFromScene, createCoords, cubeCovers, cubeOfSelection, cubeTerm, definiteIntegral, differentiate, emptyDoc, equivalent, evalBool, evaluate, fmt, freeVars, gcd, getAsset, getControlSurface, hitTest, integrate, 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, remap, renderElements, resolve, round, serialize, simplify, snapTo, toCNF, toDNF, toDeg, toLatex$1 as toLatex, toRad, truthTable, useControlSurface, useCoords, useDragOverlay, useDraggable, useEditor, useElementSize, useFrameLoop, useImpulse, useInView, useLearner, usePressSpring, useScreenToMath, useStageRef, useStepProgress, vec };

package/dist/index.mjs

@@ -5,6 +5,7 @@ import { CoordsContext, DragOverlayContext, StageRefContext, useCoords, useDragO
 import { ClockProvider, useFrameLoop } from "./core/clock.mjs";
 import { getControlSurface, listControlSurfaces, onControlChange, useControlSurface } from "./core/control.mjs";
 import { LearnerProvider, useLearner } from "./core/learner.mjs";
+import { approxEq, clamp, clamp01, gcd, remap, round, snapTo, toDeg, toRad } from "./core/math.mjs";
 import { StepProgressProvider, StepScope, useStepProgress } from "./steps/index.mjs";
 import { useElementSize } from "./view/useElementSize.mjs";
 import { Stage } from "./view/Stage.mjs";
@@ -14,7 +15,7 @@ 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 { Axes, Grid, clearOfLabel, niceStep } from "./primitives/Grid.mjs";
 import { Plot } from "./primitives/Plot.mjs";
 import { CanvasLayer } from "./primitives/CanvasLayer.mjs";
 import { useScreenToMath } from "./interaction/useScreenToMath.mjs";
@@ -27,10 +28,10 @@ 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 { definiteIntegral, differentiate, integrate, 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 { compileExpr } from "./math/expr.mjs";
 import { EVALUATORS } from "./scene/evaluators.mjs";
 import { resolve } from "./scene/resolve.mjs";
 import { applyCommand, collectRemoved, inverse } from "./scene/commands.mjs";
@@ -46,7 +47,6 @@ import { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASU
 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";
@@ -54,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, 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 };
+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, approxEq, assetMeta, clamp, clamp01, classify, clearOfLabel, collectRemoved, compile, compileExpr, compileLogic, compileNode, controlsFromScene, createCoords, cubeCovers, cubeOfSelection, cubeTerm, definiteIntegral, differentiate, emptyDoc, equivalent, evalBool, evaluate, fmt, freeVars, gcd, getAsset, getControlSurface, hitTest, integrate, 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, remap, renderElements, resolve, round, serialize, simplify, snapTo, toCNF, toDNF, toDeg, toLatex$1 as toLatex, toRad, truthTable, useControlSurface, useCoords, useDragOverlay, useDraggable, useEditor, useElementSize, useFrameLoop, useImpulse, useInView, useLearner, usePressSpring, useScreenToMath, useStageRef, useStepProgress, vec };

package/dist/interaction/MovableDot.mjs

@@ -56,6 +56,7 @@ function MovableDot({ value, onMove, constrain, color = ACCENT, r = 7, ariaLabel
 		...step !== void 0 ? { step } : {}
 	});
 	const [hovered, setHovered] = useState(false);
+	const [interacted, setInteracted] = useState(false);
 	const press = usePressSpring(dragging, {
 		to: 1,
 		stiffness: 360,
@@ -87,6 +88,14 @@ function MovableDot({ value, onMove, constrain, color = ACCENT, r = 7, ariaLabel
 			...handlers,
 			...ariaProps,
 			"aria-label": ariaLabel,
+			onPointerDown: (e) => {
+				setInteracted(true);
+				handlers.onPointerDown(e);
+			},
+			onKeyDown: (e) => {
+				setInteracted(true);
+				handlers.onKeyDown(e);
+			},
 			onPointerEnter: () => setHovered(true),
 			onPointerLeave: () => setHovered(false),
 			style: {
@@ -100,6 +109,16 @@ function MovableDot({ value, onMove, constrain, color = ACCENT, r = 7, ariaLabel
 					r: Math.max(r + 14, 12),
 					fill: "transparent"
 				}),
+				!interacted && !dragging && /* @__PURE__ */ jsx("circle", {
+					className: "stage-nudge",
+					cx: px,
+					cy: py,
+					r: r + 5,
+					fill: "none",
+					stroke: color,
+					strokeWidth: 1.5,
+					style: { pointerEvents: "none" }
+				}),
 				dragging ? /* @__PURE__ */ jsx("circle", {
 					cx: px,
 					cy: py,

package/dist/interaction/useDraggable.mjs

@@ -1,7 +1,7 @@
 'use client';
 
 import { useScreenToMath } from "./useScreenToMath.mjs";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 //#region src/interaction/useDraggable.ts
 function constrained(p, start, constrain) {
@@ -20,6 +20,20 @@ function useDraggable({ value, onMove, constrain, step = .5, range }) {
 	const toMath = useScreenToMath();
 	const [dragging, setDragging] = useState(false);
 	const startRef = useRef(value);
+	const onMoveRef = useRef(onMove);
+	onMoveRef.current = onMove;
+	const pendingRef = useRef(null);
+	const rafRef = useRef(0);
+	const flushMove = useCallback(() => {
+		rafRef.current = 0;
+		const p = pendingRef.current;
+		if (!p) return;
+		pendingRef.current = null;
+		onMoveRef.current(p, "move");
+	}, []);
+	useEffect(() => () => {
+		if (rafRef.current) cancelAnimationFrame(rafRef.current);
+	}, []);
 	const onPointerDown = useCallback((e) => {
 		e.currentTarget.setPointerCapture(e.pointerId);
 		startRef.current = value;
@@ -30,19 +44,25 @@ function useDraggable({ value, onMove, constrain, step = .5, range }) {
 		if (!dragging) return;
 		const m = toMath(e);
 		if (!m) return;
-		onMove(constrained({
+		pendingRef.current = constrained({
 			x: m[0],
 			y: m[1]
-		}, startRef.current, constrain), "move");
+		}, startRef.current, constrain);
+		if (!rafRef.current) rafRef.current = requestAnimationFrame(flushMove);
 	}, [
 		dragging,
 		toMath,
 		constrain,
-		onMove
+		flushMove
 	]);
 	const onPointerUp = useCallback((e) => {
 		if (!dragging) return;
 		setDragging(false);
+		if (rafRef.current) {
+			cancelAnimationFrame(rafRef.current);
+			rafRef.current = 0;
+		}
+		pendingRef.current = null;
 		const m = toMath(e);
 		onMove(m ? constrained({
 			x: m[0],

package/dist/math/analysis.d.mts

@@ -0,0 +1,61 @@
+import { Node } from "./ast.mjs";
+
+//#region src/math/analysis.d.ts
+type Fn1 = (x: number) => number;
+/** A straight line y = m·x + c, with the point it was taken at and an evaluator. */
+interface Line {
+  m: number;
+  c: number;
+  at: {
+    x: number;
+    y: number;
+  };
+  f: Fn1;
+}
+/**
+ * Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
+ *   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
+ *   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
+ *      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
+ *      change sign. False minima (a parabola that never reaches 0) are rejected
+ *      by the accept tolerance, so no phantom roots.
+ */
+declare function roots(f: Fn1, a: number, b: number, opts?: {
+  steps?: number;
+  tol?: number;
+}): number[];
+/** Points where f and g meet on [a,b]. */
+declare function intersections(f: Fn1, g: Fn1, a: number, b: number, opts?: {
+  steps?: number;
+  tol?: number;
+}): {
+  x: number;
+  y: number;
+}[];
+/** Exact tangent line to `ast` at x = x0 (params baked in via `scope`). */
+declare function tangentAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line | null;
+/** Normal line to `ast` at x = x0 (⟂ the tangent). Null if the tangent is horizontal. */
+declare function normalAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line | null;
+/**
+ * Composite-Simpson definite integral ∫_a^b f dx, on a NUMERIC function.
+ *
+ * Error O(h⁴) against O(h) for a Riemann sum, so at n≈1000 it is accurate to near machine
+ * precision for a smooth integrand and serves as the reference value a Riemann sum converges
+ * toward. `n` is forced even, as the rule requires. Not adaptive: a singularity inside [a, b] is
+ * not detected, which is why the callers in this file (`areaBetween`) split at the crossings first.
+ *
+ * Named `quadrature` because `calculus.ts` beside it exports `integrate`, which integrates an AST
+ * SYMBOLICALLY: different argument type, different return type, different meaning. (`simpson`
+ * would become a lie the moment the rule changed.) The single implementation, after two copies of
+ * it were found in labs; see `KERNEL-CONTRACT.md` §7.
+ */
+declare function quadrature(f: Fn1, a: number, b: number, n?: number): number;
+/**
+ * Geometric area between f and g over [a,b]. SPLITS at every crossing so the
+ * pieces where g > f don't cancel the pieces where f > g (which a single
+ * |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
+ * wants.
+ */
+declare function areaBetween(f: Fn1, g: Fn1, a: number, b: number, n?: number): number;
+//#endregion
+export { Fn1, Line, areaBetween, intersections, normalAt, quadrature, roots, tangentAt };

package/dist/math/analysis.mjs

@@ -0,0 +1,187 @@
+import { evaluate } from "./ast.mjs";
+import { differentiate } from "./calculus.mjs";
+
+//#region src/math/analysis.ts
+/**
+* analysis, the NUMERIC layer over this package's symbolic engine: the half of calculus that needs
+* a number rather than an expression. `calculus.ts` differentiates and integrates an AST exactly;
+* this file finds roots, intersections, tangents, normals and areas, which in general have no
+* closed form at all.
+*
+* Everything works on a compiled scalar `Fn1 = (x) => number` (params already baked into the
+* closure) plus, for exact tangents, the parsed `Node` AST. Pure: no React, no pixels.
+*
+* Methods, and why each is safe:
+*   • roots, bisection on sign changes PLUS Newton at local minima of |f|, so tangent (even
+*     multiplicity) roots are found and poles are rejected. See the docblock on `roots`.
+*   • tangents/normals, EXACT: the AST is differentiated symbolically, then evaluated. No
+*     finite-difference error in the gradient a lesson shows.
+*   • quadrature, composite Simpson, error O(h⁴).
+*
+* Units: none. These are pure numbers on a pure function.
+*/
+function pushUnique(out, x, tol) {
+	if (!out.some((p) => Math.abs(p - x) <= tol)) out.push(x);
+}
+/** Newton's method from x0 using a central-difference derivative (we only hold
+*  the numeric f, not its AST). Returns the polished root, or null on a flat
+*  derivative / divergence. Used to recover tangent (even-multiplicity) roots a
+*  sign-change scan can't see. */
+function newton(f, x0, tol) {
+	let x = x0;
+	for (let k = 0; k < 40; k++) {
+		const fx = f(x);
+		if (!Number.isFinite(fx)) return null;
+		if (Math.abs(fx) <= tol) return x;
+		const h = Math.max(1e-7, Math.abs(x) * 1e-7);
+		const d = (f(x + h) - f(x - h)) / (2 * h);
+		if (!Number.isFinite(d) || Math.abs(d) < 1e-13) return null;
+		const nx = x - fx / d;
+		if (!Number.isFinite(nx)) return null;
+		if (Math.abs(nx - x) <= tol) return nx;
+		x = nx;
+	}
+	return Math.abs(f(x)) <= tol ? x : null;
+}
+/**
+* Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
+*   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
+*   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
+*      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
+*      change sign. False minima (a parabola that never reaches 0) are rejected
+*      by the accept tolerance, so no phantom roots.
+*/
+function roots(f, a, b, opts = {}) {
+	const steps = opts.steps ?? 1e3;
+	const tol = opts.tol ?? 1e-9;
+	const grid = (b - a) / steps;
+	const out = [];
+	const xs = [], fs = [];
+	for (let i = 0; i <= steps; i++) {
+		const x = a + grid * i;
+		xs.push(x);
+		fs.push(f(x));
+	}
+	let maxAbs = 0;
+	for (const v of fs) if (Number.isFinite(v)) maxAbs = Math.max(maxAbs, Math.abs(v));
+	const acceptTol = 1e-7 * (1 + maxAbs);
+	for (let i = 1; i <= steps; i++) {
+		const fPrev = fs[i - 1], fx = fs[i];
+		if (!Number.isFinite(fPrev) || !Number.isFinite(fx)) continue;
+		if (fPrev === 0) {
+			pushUnique(out, xs[i - 1], grid);
+			continue;
+		}
+		if (fPrev * fx < 0) {
+			let lo = xs[i - 1], hi = xs[i], flo = fPrev;
+			for (let k = 0; k < 80 && hi - lo > tol; k++) {
+				const mid = (lo + hi) / 2;
+				const fm = f(mid);
+				if (!Number.isFinite(fm)) break;
+				if (flo * fm <= 0) hi = mid;
+				else {
+					lo = mid;
+					flo = fm;
+				}
+			}
+			const mid = (lo + hi) / 2;
+			if (Math.abs(f(mid)) <= acceptTol) pushUnique(out, mid, grid);
+		}
+	}
+	for (let i = 1; i < steps; i++) {
+		const p = fs[i - 1], c = fs[i], q = fs[i + 1];
+		if (!Number.isFinite(p) || !Number.isFinite(c) || !Number.isFinite(q)) continue;
+		if (Math.abs(c) <= Math.abs(p) && Math.abs(c) <= Math.abs(q) && Math.abs(c) < .05 * (1 + maxAbs)) {
+			const r = newton(f, xs[i], tol);
+			if (r != null && r >= a - grid && r <= b + grid && Math.abs(f(r)) <= acceptTol) pushUnique(out, r, grid);
+		}
+	}
+	out.sort((u, v) => u - v);
+	return out;
+}
+/** Points where f and g meet on [a,b]. */
+function intersections(f, g, a, b, opts) {
+	return roots((x) => f(x) - g(x), a, b, opts).map((x) => ({
+		x,
+		y: f(x)
+	}));
+}
+/** Exact tangent line to `ast` at x = x0 (params baked in via `scope`). */
+function tangentAt(ast, x0, varName = "x", params = {}) {
+	const d = differentiate(ast, varName);
+	if (!d) return null;
+	const m = evaluate(d, {
+		...params,
+		[varName]: x0
+	});
+	const y0 = evaluate(ast, {
+		...params,
+		[varName]: x0
+	});
+	if (!Number.isFinite(m) || !Number.isFinite(y0)) return null;
+	const c = y0 - m * x0;
+	return {
+		m,
+		c,
+		at: {
+			x: x0,
+			y: y0
+		},
+		f: (x) => m * x + c
+	};
+}
+/** Normal line to `ast` at x = x0 (⟂ the tangent). Null if the tangent is horizontal. */
+function normalAt(ast, x0, varName = "x", params = {}) {
+	const t = tangentAt(ast, x0, varName, params);
+	if (!t || t.m === 0) return null;
+	const m = -1 / t.m;
+	const c = t.at.y - m * t.at.x;
+	return {
+		m,
+		c,
+		at: t.at,
+		f: (x) => m * x + c
+	};
+}
+/**
+* Composite-Simpson definite integral ∫_a^b f dx, on a NUMERIC function.
+*
+* Error O(h⁴) against O(h) for a Riemann sum, so at n≈1000 it is accurate to near machine
+* precision for a smooth integrand and serves as the reference value a Riemann sum converges
+* toward. `n` is forced even, as the rule requires. Not adaptive: a singularity inside [a, b] is
+* not detected, which is why the callers in this file (`areaBetween`) split at the crossings first.
+*
+* Named `quadrature` because `calculus.ts` beside it exports `integrate`, which integrates an AST
+* SYMBOLICALLY: different argument type, different return type, different meaning. (`simpson`
+* would become a lie the moment the rule changed.) The single implementation, after two copies of
+* it were found in labs; see `KERNEL-CONTRACT.md` §7.
+*/
+function quadrature(f, a, b, n = 1e3) {
+	if (a === b) return 0;
+	const m = Math.max(2, Math.ceil(n / 2) * 2);
+	const h = (b - a) / m;
+	let sum = f(a) + f(b);
+	for (let i = 1; i < m; i++) sum += (i % 2 === 1 ? 4 : 2) * f(a + i * h);
+	return sum * h / 3;
+}
+/**
+* Geometric area between f and g over [a,b]. SPLITS at every crossing so the
+* pieces where g > f don't cancel the pieces where f > g (which a single
+* |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
+* wants.
+*/
+function areaBetween(f, g, a, b, n = 1e3) {
+	const d = (x) => f(x) - g(x);
+	const cuts = [
+		a,
+		...roots(d, a, b).filter((x) => x > a + 1e-9 && x < b - 1e-9).sort((u, v) => u - v),
+		b
+	];
+	const per = Math.max(20, Math.round(n / Math.max(1, cuts.length - 1)));
+	let area = 0;
+	for (let i = 0; i < cuts.length - 1; i++) area += Math.abs(quadrature(d, cuts[i], cuts[i + 1], per));
+	return area;
+}
+
+//#endregion
+export { areaBetween, intersections, normalAt, quadrature, roots, tangentAt };

package/dist/math/answer-check.d.mts

@@ -0,0 +1,50 @@
+//#region src/math/answer-check.d.ts
+/**
+ * answer-check, the "is the student right?" layer, built on the expr engine beside it. Two modes,
+ * the ones exams need:
+ *
+ *   • NUMBER     — value within tolerance, parsed so `pi/2` and `2*sqrt(5)` count.
+ *   • EXPRESSION — any algebraically EQUIVALENT form accepted, checked BOTH symbolically
+ *                  (simplify(student − answer) → 0) AND numerically by sampling, so
+ *                  `(x+1)(x+2)` ≡ `x^2+3x+2`.
+ *
+ * Both passes run because neither is sufficient alone: the simplifier cannot collapse every
+ * equivalent pair, and sampling alone would accept two expressions that happen to agree on the
+ * sample points. Symbolic first, numeric as the fallback, and a minimum count of agreeing FINITE
+ * samples so a pair that is undefined everywhere in the window cannot pass by default.
+ *
+ * Tolerances are relative, not absolute: a 1% window on a quantity of order 10⁵ is not the same
+ * marking scheme as a 1% window on 0.3, and only one of those is what an exam means.
+ *
+ * Pure: no React, no pixels.
+ */
+/** Evaluate a numeric answer string (`3.14`, `pi/2`, `2*sqrt(5)`) → number (NaN if invalid). */
+declare function parseValue(raw: string): number;
+declare function normalizeMathInput(raw: string): string;
+/** Numeric match with a relative-ish tolerance (default ~1% of scale). */
+declare function checkNumber(student: number, value: number, tol?: number): boolean;
+interface ExprCheckOpts {
+  /** Variables to sample (defaults to the union of both sides' free vars). */
+  vars?: string[];
+  /** Sampling domain for the numeric pass. */
+  domain?: [number, number];
+  tol?: number;
+  samples?: number;
+}
+/** True if `student` is algebraically equivalent to `answer` (symbolic OR numeric). */
+declare function checkExpression(student: string, answer: string, opts?: ExprCheckOpts): boolean;
+type AnswerSpec = {
+  kind: 'number';
+  value: number;
+  tol?: number;
+} | {
+  kind: 'expression';
+  value: string;
+  vars?: string[];
+  domain?: [number, number];
+  tol?: number;
+};
+/** Check a raw student string against an authored answer spec. */
+declare function checkAnswer(spec: AnswerSpec, raw: string): boolean;
+//#endregion
+export { AnswerSpec, ExprCheckOpts, checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue };