@classytic/stage 0.2.0 → 0.3.0

package/dist/finance/index.d.mts

@@ -0,0 +1,118 @@
+import { BalanceSheet, BizAction, BizState, IncomeStatement, applyBiz, balanceSheet, incomeStatement, initialBiz, runBiz } from "./bizsim.mjs";
+
+//#region src/finance/index.d.ts
+/** Simple interest I = P·r·t (interest only, not the total). */
+declare function simpleInterest(principal: number, rate: number, years: number): number;
+/** Amount after compound interest, A = P(1 + r/m)^(m·t). */
+declare function compoundAmount(principal: number, rate: number, years: number, m?: number): number;
+/** Compound interest earned (total − principal). */
+declare function compoundInterest(principal: number, rate: number, years: number, m?: number): number;
+/** Future value of a lump sum, FV = P(1+r)^n. */
+declare function futureValue(principal: number, rate: number, n: number): number;
+/** Present value of a future lump sum, PV = FV/(1+r)^n. */
+declare function presentValue(fv: number, rate: number, n: number): number;
+/** Effective annual rate from a nominal rate compounded m times/year. */
+declare function effectiveRate(nominal: number, m: number): number;
+/** Rule of 72: approximate years for money to double at a given annual rate. */
+declare function rule72(rate: number): number;
+/** Yearly simple-vs-compound growth series, for the "money snowball" curve. */
+declare function growthSeries(principal: number, rate: number, years: number): {
+  year: number;
+  simple: number;
+  compound: number;
+}[];
+interface AmortRow {
+  period: number;
+  interest: number;
+  principal: number;
+  balance: number;
+}
+interface AmortResult {
+  payment: number;
+  totalInterest: number;
+  schedule: AmortRow[];
+}
+/** Amortize a loan into equal payments; returns the payment, total interest, and per-period schedule. */
+declare function amortize(principal: number, annualRate: number, years: number, m?: number): AmortResult;
+interface DepRow {
+  year: number;
+  depreciation: number;
+  bookValue: number;
+}
+/** Straight-line depreciation: equal charge (cost − residual)/life each year. */
+declare function straightLine(cost: number, residual: number, life: number): {
+  perYear: number;
+  schedule: DepRow[];
+};
+/** Reducing-balance depreciation: a fixed % of the falling book value each year. */
+declare function reducingBalance(cost: number, rate: number, life: number): DepRow[];
+interface CostModel {
+  fixedCost: number;
+  price: number;
+  variableCost: number;
+}
+interface BreakEven {
+  contributionPerUnit: number;
+  units: number;
+  revenue: number;
+  contributionMargin: number;
+}
+/** Break-even: units where contribution covers fixed cost; plus revenue and margin. */
+declare function breakEven({
+  fixedCost,
+  price,
+  variableCost
+}: CostModel): BreakEven;
+/** Profit at a given output: units·(price − variable) − fixed. */
+declare function profitAt(units: number, m: CostModel): number;
+/** Margin of safety = actual output − break-even output (units). */
+declare function marginOfSafety(currentUnits: number, breakEvenUnits: number): number;
+type InvMethod = 'fifo' | 'lifo' | 'avco';
+interface InvMove {
+  type: 'buy' | 'sell';
+  qty: number;
+  unitCost?: number;
+}
+interface InvResult {
+  cogs: number;
+  closingValue: number;
+  closingQty: number;
+}
+/** Value stock and cost of goods sold under FIFO, LIFO or weighted-average (AVCO). */
+declare function inventoryValue(method: InvMethod, moves: InvMove[]): InvResult;
+/** Economic order quantity: √(2·D·S / H) — demand D, order cost S, holding cost/unit H. */
+declare function eoq(annualDemand: number, orderCost: number, holdingCostPerUnit: number): number;
+/** Reorder level = usage during the lead time, plus any buffer (safety) stock. */
+declare function reorderLevel(usagePerDay: number, leadTimeDays: number, bufferStock?: number): number;
+/** Split a total cost across cost-centres in proportion to a basis (floor area sq ft, headcount, machine hours…). */
+declare function apportion(total: number, weights: number[]): number[];
+interface FinInputs {
+  currentAssets: number;
+  inventory: number;
+  currentLiabilities: number;
+  nonCurrentLiabilities: number;
+  equity: number;
+  revenue: number;
+  costOfSales: number;
+  expenses?: number;
+  grossProfit?: number;
+  netProfit?: number;
+  capitalEmployed?: number;
+}
+interface Ratios {
+  current: number;
+  quick: number;
+  gearing: number;
+  grossMargin: number;
+  netMargin: number;
+  roce: number;
+  inventoryTurnover: number;
+}
+/** Standard analysis ratios from summary figures (liquidity, gearing, profitability, efficiency). */
+declare function ratios(f: FinInputs): Ratios;
+/** Net present value; `cashflows[0]` is the initial outlay (usually negative). */
+declare function npv(rate: number, cashflows: number[]): number;
+/** Payback period in years (fractional), from year-0 outlay + yearly inflows. */
+declare function payback(cashflows: number[]): number;
+//#endregion
+export { AmortResult, AmortRow, BalanceSheet, BizAction, BizState, BreakEven, CostModel, DepRow, FinInputs, IncomeStatement, InvMethod, InvMove, InvResult, Ratios, amortize, applyBiz, apportion, balanceSheet, breakEven, compoundAmount, compoundInterest, effectiveRate, eoq, futureValue, growthSeries, incomeStatement, initialBiz, inventoryValue, marginOfSafety, npv, payback, presentValue, profitAt, ratios, reducingBalance, reorderLevel, rule72, runBiz, simpleInterest, straightLine };

package/dist/finance/index.mjs

@@ -0,0 +1,203 @@
+import { applyBiz, balanceSheet, incomeStatement, initialBiz, runBiz } from "./bizsim.mjs";
+
+//#region src/finance/index.ts
+/** Simple interest I = P·r·t (interest only, not the total). */
+function simpleInterest(principal, rate, years) {
+	return principal * rate * years;
+}
+/** Amount after compound interest, A = P(1 + r/m)^(m·t). */
+function compoundAmount(principal, rate, years, m = 1) {
+	return principal * Math.pow(1 + rate / m, m * years);
+}
+/** Compound interest earned (total − principal). */
+function compoundInterest(principal, rate, years, m = 1) {
+	return compoundAmount(principal, rate, years, m) - principal;
+}
+/** Future value of a lump sum, FV = P(1+r)^n. */
+function futureValue(principal, rate, n) {
+	return principal * Math.pow(1 + rate, n);
+}
+/** Present value of a future lump sum, PV = FV/(1+r)^n. */
+function presentValue(fv, rate, n) {
+	return fv / Math.pow(1 + rate, n);
+}
+/** Effective annual rate from a nominal rate compounded m times/year. */
+function effectiveRate(nominal, m) {
+	return Math.pow(1 + nominal / m, m) - 1;
+}
+/** Rule of 72: approximate years for money to double at a given annual rate. */
+function rule72(rate) {
+	return 72 / (rate * 100);
+}
+/** Yearly simple-vs-compound growth series, for the "money snowball" curve. */
+function growthSeries(principal, rate, years) {
+	const out = [];
+	for (let y = 0; y <= years; y++) out.push({
+		year: y,
+		simple: principal * (1 + rate * y),
+		compound: principal * Math.pow(1 + rate, y)
+	});
+	return out;
+}
+/** Amortize a loan into equal payments; returns the payment, total interest, and per-period schedule. */
+function amortize(principal, annualRate, years, m = 12) {
+	const n = Math.round(years * m), i = annualRate / m;
+	const payment = i === 0 ? principal / n : principal * i / (1 - Math.pow(1 + i, -n));
+	const schedule = [];
+	let bal = principal;
+	for (let k = 1; k <= n; k++) {
+		const interest = bal * i;
+		const princ = payment - interest;
+		bal = Math.max(0, bal - princ);
+		schedule.push({
+			period: k,
+			interest,
+			principal: princ,
+			balance: bal
+		});
+	}
+	return {
+		payment,
+		totalInterest: payment * n - principal,
+		schedule
+	};
+}
+/** Straight-line depreciation: equal charge (cost − residual)/life each year. */
+function straightLine(cost, residual, life) {
+	const perYear = (cost - residual) / life;
+	const schedule = [];
+	for (let y = 1; y <= life; y++) schedule.push({
+		year: y,
+		depreciation: perYear,
+		bookValue: cost - perYear * y
+	});
+	return {
+		perYear,
+		schedule
+	};
+}
+/** Reducing-balance depreciation: a fixed % of the falling book value each year. */
+function reducingBalance(cost, rate, life) {
+	const schedule = [];
+	let bv = cost;
+	for (let y = 1; y <= life; y++) {
+		const dep = bv * rate;
+		bv -= dep;
+		schedule.push({
+			year: y,
+			depreciation: dep,
+			bookValue: bv
+		});
+	}
+	return schedule;
+}
+/** Break-even: units where contribution covers fixed cost; plus revenue and margin. */
+function breakEven({ fixedCost, price, variableCost }) {
+	const contributionPerUnit = price - variableCost;
+	const units = contributionPerUnit > 0 ? fixedCost / contributionPerUnit : Infinity;
+	return {
+		contributionPerUnit,
+		units,
+		revenue: units * price,
+		contributionMargin: price > 0 ? contributionPerUnit / price : 0
+	};
+}
+/** Profit at a given output: units·(price − variable) − fixed. */
+function profitAt(units, m) {
+	return units * (m.price - m.variableCost) - m.fixedCost;
+}
+/** Margin of safety = actual output − break-even output (units). */
+function marginOfSafety(currentUnits, breakEvenUnits) {
+	return currentUnits - breakEvenUnits;
+}
+/** Value stock and cost of goods sold under FIFO, LIFO or weighted-average (AVCO). */
+function inventoryValue(method, moves) {
+	let cogs = 0;
+	if (method === "avco") {
+		let qty = 0, val = 0;
+		for (const m of moves) if (m.type === "buy") {
+			qty += m.qty;
+			val += m.qty * (m.unitCost ?? 0);
+		} else {
+			const avg = qty > 0 ? val / qty : 0;
+			cogs += m.qty * avg;
+			val -= m.qty * avg;
+			qty -= m.qty;
+		}
+		return {
+			cogs,
+			closingValue: val,
+			closingQty: qty
+		};
+	}
+	const lots = [];
+	for (const m of moves) {
+		if (m.type === "buy") {
+			lots.push({
+				qty: m.qty,
+				cost: m.unitCost ?? 0
+			});
+			continue;
+		}
+		let need = m.qty;
+		while (need > 0 && lots.length) {
+			const idx = method === "fifo" ? 0 : lots.length - 1;
+			const lot = lots[idx];
+			const take = Math.min(need, lot.qty);
+			cogs += take * lot.cost;
+			lot.qty -= take;
+			need -= take;
+			if (lot.qty === 0) lots.splice(idx, 1);
+		}
+	}
+	return {
+		cogs,
+		closingValue: lots.reduce((a, l) => a + l.qty * l.cost, 0),
+		closingQty: lots.reduce((a, l) => a + l.qty, 0)
+	};
+}
+/** Economic order quantity: √(2·D·S / H) — demand D, order cost S, holding cost/unit H. */
+function eoq(annualDemand, orderCost, holdingCostPerUnit) {
+	return holdingCostPerUnit > 0 ? Math.sqrt(2 * annualDemand * orderCost / holdingCostPerUnit) : Infinity;
+}
+/** Reorder level = usage during the lead time, plus any buffer (safety) stock. */
+function reorderLevel(usagePerDay, leadTimeDays, bufferStock = 0) {
+	return usagePerDay * leadTimeDays + bufferStock;
+}
+/** Split a total cost across cost-centres in proportion to a basis (floor area sq ft, headcount, machine hours…). */
+function apportion(total, weights) {
+	const sum = weights.reduce((a, b) => a + b, 0) || 1;
+	return weights.map((w) => total * w / sum);
+}
+/** Standard analysis ratios from summary figures (liquidity, gearing, profitability, efficiency). */
+function ratios(f) {
+	const grossProfit = f.grossProfit ?? f.revenue - f.costOfSales;
+	const netProfit = f.netProfit ?? grossProfit - (f.expenses ?? 0);
+	const capEmp = f.capitalEmployed ?? f.equity + f.nonCurrentLiabilities;
+	return {
+		current: f.currentAssets / f.currentLiabilities,
+		quick: (f.currentAssets - f.inventory) / f.currentLiabilities,
+		gearing: f.nonCurrentLiabilities / (f.equity + f.nonCurrentLiabilities),
+		grossMargin: grossProfit / f.revenue,
+		netMargin: netProfit / f.revenue,
+		roce: netProfit / capEmp,
+		inventoryTurnover: f.costOfSales / f.inventory
+	};
+}
+/** Net present value; `cashflows[0]` is the initial outlay (usually negative). */
+function npv(rate, cashflows) {
+	return cashflows.reduce((a, cf, t) => a + cf / Math.pow(1 + rate, t), 0);
+}
+/** Payback period in years (fractional), from year-0 outlay + yearly inflows. */
+function payback(cashflows) {
+	let cum = 0;
+	for (let t = 0; t < cashflows.length; t++) {
+		const prev = cum;
+		cum += cashflows[t];
+		if (cum >= 0 && t > 0) return t - 1 + -prev / cashflows[t];
+	}
+	return Infinity;
+}
+
+//#endregion
+export { amortize, applyBiz, apportion, balanceSheet, breakEven, compoundAmount, compoundInterest, effectiveRate, eoq, futureValue, growthSeries, incomeStatement, initialBiz, inventoryValue, marginOfSafety, npv, payback, presentValue, profitAt, ratios, reducingBalance, reorderLevel, rule72, runBiz, simpleInterest, straightLine };

package/dist/index.d.mts

@@ -15,6 +15,7 @@ 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 { 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 +27,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";
@@ -42,7 +43,7 @@ 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 { 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/index.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,7 +28,7 @@ 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";
@@ -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/calculus.d.mts

@@ -3,7 +3,28 @@ import { Node } from "./ast.mjs";
 //#region src/math/calculus.d.ts
 /** Exact symbolic derivative, or `null` if a non-differentiable node is present. */
 declare function differentiate(node: Node, x: string): Node | null;
+/**
+ * Exact symbolic antiderivative with respect to `x`, or `null` when this engine cannot do it.
+ *
+ * The constant of integration is NOT included. That is deliberate: `+ c` is the single most
+ * commonly dropped mark in the topic, so it belongs in the lesson's own working where a learner
+ * has to write it, not silently bolted on by the engine.
+ *
+ * Covers the Cambridge P1/P3 toolkit: linearity, the power rule including the `1/x → ln|x|`
+ * exception, and any of the above composed with a LINEAR inner function. Returns null for
+ * integration by parts, by non-linear substitution, and partial fractions, so a caller can fall
+ * back to the numerical `integrate` in `core/numeric` and show area rather than a wrong formula.
+ */
+declare function integrate(node: Node, x: string): Node | null;
+/**
+ * A definite integral evaluated exactly: `F(b) - F(a)`.
+ *
+ * Returned as a NUMBER rather than a node, because that is what a lesson compares a learner's
+ * answer against. Null when the antiderivative is not elementary, or when either limit lands
+ * somewhere the expression is not defined.
+ */
+declare function definiteIntegral(node: Node, x: string, lower: number, upper: number): number | null;
 /** Fold constants and trivial identities so derivative output is readable. */
 declare function simplify(node: Node): Node;
 //#endregion
-export { differentiate, simplify };
+export { definiteIntegral, differentiate, integrate, simplify };