@classytic/stage 0.1.0 → 0.3.0

package/dist/core/motion.mjs

@@ -1,14 +1,14 @@
 //#region src/core/motion.ts
 /**
-* Motion core — the "physics of feel" layer. Pure, dependency-free functions that
+* Motion core, the "physics of feel" layer. Pure, dependency-free functions that
 * turn time into eased / springy / oscillating values. They consume the `dtMs`
 * (or `timeMs`) you already receive from `useFrameLoop`; they do NOT own a loop,
-* schedule frames, or touch React — so they stay deterministic (same time → same
+* schedule frames, or touch React, so they stay deterministic (same time → same
 * value) and work identically under a Remotion fixed-frame driver.
 *
 * Discipline (mirrors clock.ts): for video-determinism prefer the time-driven
 * helpers (`oscillate`, `timeline`) that are a pure function of `timeMs`. `spring`
-* is stateful (it integrates a velocity) — fine for interactive feel, but it will
+* is stateful (it integrates a velocity), fine for interactive feel, but it will
 * not reproduce frame-for-frame across drivers, so don't use it for rendered video.
 */
 /** Snap-to-end gate: honor the user's reduced-motion preference (SSR-safe). */
@@ -30,14 +30,14 @@ const ease = {
 	},
 	quintOut: (t) => 1 - (1 - clamp01(t)) ** 5,
 	sineInOut: (t) => -(Math.cos(Math.PI * clamp01(t)) - 1) / 2,
-	/** Overshoots then settles — good for "pop" on appear. */
+	/** Overshoots then settles, good for "pop" on appear. */
 	backOut: (t) => {
 		const c1 = 1.70158;
 		const c3 = 2.70158;
 		t = clamp01(t);
 		return 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2;
 	},
-	/** Springy overshoot with decaying wobble — for playful reveals. */
+	/** Springy overshoot with decaying wobble, for playful reveals. */
 	elasticOut: (t) => {
 		t = clamp01(t);
 		if (t === 0 || t === 1) return t;
@@ -63,7 +63,7 @@ function spring(current, target, vel, dtSec, opts = {}) {
 	vel.current += accel * dt;
 	return current + vel.current * dt;
 }
-/** A pure periodic signal of `timeSec` — the engine under AC sources, pendulums, waves. */
+/** A pure periodic signal of `timeSec`, the engine under AC sources, pendulums, waves. */
 function oscillate(timeSec, opts = {}) {
 	const { amp = 1, freq = 1, phase = 0, shape = "sine" } = opts;
 	const turns = freq * timeSec + phase;

package/dist/core/richText.d.mts

@@ -1,6 +1,6 @@
 //#region src/core/richText.d.ts
 /**
- * richText — the ONE grammar for inline subscript/superscript markup, shared by
+ * richText, the ONE grammar for inline subscript/superscript markup, shared by
  * every renderer so the parsing lives in a single place and can't drift:
  *   • stage's SVG `<Label>` turns spans into <tspan> (baseline-shifted), and
  *   • labs' HTML `<RichText>` turns them into <sub>/<sup>.
@@ -9,7 +9,7 @@
  *   `_x` / `^x`        → a run of the SAME character class as the char right
  *                        after the marker (all-letters OR all-digits). So
  *                        `V_RC` → subscript "RC", `H_2O` → subscript "2" then
- *                        base "O", `v_max` → subscript "max" — no braces needed.
+ *                        base "O", `v_max` → subscript "max", no braces needed.
  *   `_{abc}` / `^{ab}` → an explicit group, taken verbatim (use for mixed runs
  *                        or symbols, e.g. `10^{-3}`, `x^{n+1}`)
  *   a lone `_` or `^`  → stays literal

package/dist/core/vec.d.mts

@@ -3,7 +3,7 @@
  * 2D vector + affine-matrix algebra. Points are {x,y} objects (serialize cleanly
  * in the scene JSON). Matrices are SVG-order tuples [a,b,c,d,e,f] mapping
  * (x,y) → (a·x + c·y + e, b·x + d·y + f), so `mat.toSvg` is a direct
- * `matrix(a b c d e f)` attribute string — never a CSS variable (a CSS transform
+ * `matrix(a b c d e f)` attribute string, never a CSS variable (a CSS transform
  * is not reliably composed into getScreenCTM()).
  */
 interface Vec2 {

package/dist/field/index.d.mts

@@ -23,6 +23,14 @@ interface Bounds {
 /** Net field vector at point `p` from all sources (superposition). */
 declare function fieldAt(sources: readonly FieldSource[], p: Vec2): Vec2;
 declare function fieldMag(sources: readonly FieldSource[], p: Vec2): number;
+/**
+ * Scalar electric potential at `p`: V = Σ k·q / r (superposition). This is the
+ * companion to `fieldAt` for potential / equipotential / work labs, where the work
+ * to move a charge Q from A to B is W = Q·(V_A − V_B), path-independent. `wire`
+ * sources have no scalar potential and are skipped. Same softening as `fieldAt`,
+ * so V stays finite at a source.
+ */
+declare function potentialAt(sources: readonly FieldSource[], p: Vec2, k?: number): number;
 interface TraceOpts {
   /** Follow the field (+1) or run against it (−1). Default +1. */
   dir?: number;
@@ -41,13 +49,13 @@ interface FieldLinesOpts extends TraceOpts {
   /** Seed radius around a source. Default 0.2. */
   seed?: number;
 }
-/** Convenience: a full set of field lines — radial from each charge/pole, circular
+/** Convenience: a full set of field lines, radial from each charge/pole, circular
  *  loops around each wire. Each line carries the sign of its originating source. */
 declare function fieldLines(sources: readonly FieldSource[], opts?: FieldLinesOpts): {
   points: Vec2[];
   sign: number;
 }[];
-/** Sample the field on a regular grid — for a quiver / arrow plot. */
+/** Sample the field on a regular grid, for a quiver / arrow plot. */
 declare function fieldGrid(sources: readonly FieldSource[], bounds: Bounds, nx: number, ny: number): {
   at: Vec2;
   v: Vec2;
@@ -55,4 +63,4 @@ declare function fieldGrid(sources: readonly FieldSource[], bounds: Bounds, nx:
 /** Build a bar magnet as an N(+)/S(−) pole pair, centred at `center` along `dir`. */
 declare function barMagnet(center: Vec2, dir: Vec2, strength?: number, length?: number): [PointCharge, PointCharge];
 //#endregion
-export { Bounds, FieldLinesOpts, FieldSource, LineCurrent, PointCharge, TraceOpts, barMagnet, fieldAt, fieldGrid, fieldLines, fieldMag, traceLine };
+export { Bounds, FieldLinesOpts, FieldSource, LineCurrent, PointCharge, TraceOpts, barMagnet, fieldAt, fieldGrid, fieldLines, fieldMag, potentialAt, traceLine };

package/dist/field/index.mjs

@@ -26,6 +26,23 @@ function fieldMag(sources, p) {
 	const v = fieldAt(sources, p);
 	return Math.hypot(v.x, v.y);
 }
+/**
+* Scalar electric potential at `p`: V = Σ k·q / r (superposition). This is the
+* companion to `fieldAt` for potential / equipotential / work labs, where the work
+* to move a charge Q from A to B is W = Q·(V_A − V_B), path-independent. `wire`
+* sources have no scalar potential and are skipped. Same softening as `fieldAt`,
+* so V stays finite at a source.
+*/
+function potentialAt(sources, p, k = 1) {
+	let v = 0;
+	for (const s of sources) {
+		if (s.kind !== "point") continue;
+		const dx = p.x - s.at.x, dy = p.y - s.at.y;
+		const r = Math.sqrt(dx * dx + dy * dy + SOFT);
+		v += k * s.q / r;
+	}
+	return v;
+}
 function unit(v, dir) {
 	const m = Math.hypot(v.x, v.y);
 	if (m < 1e-9) return null;
@@ -64,7 +81,7 @@ function traceLine(sources, start, opts = {}) {
 	}
 	return pts;
 }
-/** Convenience: a full set of field lines — radial from each charge/pole, circular
+/** Convenience: a full set of field lines, radial from each charge/pole, circular
 *  loops around each wire. Each line carries the sign of its originating source. */
 function fieldLines(sources, opts = {}) {
 	const { perSource = 12, seed = .2, ...trace } = opts;
@@ -114,7 +131,7 @@ function fieldLines(sources, opts = {}) {
 	}
 	return out;
 }
-/** Sample the field on a regular grid — for a quiver / arrow plot. */
+/** Sample the field on a regular grid, for a quiver / arrow plot. */
 function fieldGrid(sources, bounds, nx, ny) {
 	const out = [];
 	const dx = (bounds.xMax - bounds.xMin) / (nx + 1);
@@ -153,4 +170,4 @@ function barMagnet(center, dir, strength = 1, length = 1.6) {
 }
 
 //#endregion
-export { barMagnet, fieldAt, fieldGrid, fieldLines, fieldMag, traceLine };
+export { barMagnet, fieldAt, fieldGrid, fieldLines, fieldMag, potentialAt, traceLine };

package/dist/finance/bizsim.d.mts

@@ -0,0 +1,93 @@
+//#region src/finance/bizsim.d.ts
+/**
+ * bizsim — a tiny, always-balanced business-simulation engine (part of `finance`).
+ *
+ * This is the PRIMITIVE a "run a business" story lesson is built on: a teacher/creator
+ * authors a scenario as a sequence of business ACTIONS (invest capital, take a loan,
+ * buy equipment, buy stock, sell, pay an expense, depreciate, close the period). Each
+ * action is a pure, DOUBLE-ENTRY-BALANCED transform of the business state, so the
+ * derived income statement and balance sheet are always correct and the balance sheet
+ * always balances — no accounting knowledge required to author, and it scales all the
+ * way to financial analysis (ratios) at the end.
+ *
+ * The engine is content-neutral: it knows nothing about samosas, apps or coffee — the
+ * creator supplies the story and the numbers.
+ */
+interface BizState {
+  cash: number;
+  /** Stock on hand: quantity and its value at cost. */
+  inventoryQty: number;
+  inventoryValue: number;
+  /** Fixed assets at book value. */
+  equipment: number;
+  /** Liabilities (loans). */
+  loan: number;
+  /** Owner capital contributed. */
+  capital: number;
+  /** Accumulated profit from closed periods. */
+  retained: number;
+  /** Current open-period tallies (become net profit at closePeriod). */
+  revenue: number;
+  cogs: number;
+  expenses: number;
+}
+declare const initialBiz: (over?: Partial<BizState>) => BizState;
+type BizAction = {
+  type: 'invest';
+  amount: number;
+} | {
+  type: 'loan';
+  amount: number;
+} | {
+  type: 'repay';
+  amount: number;
+} | {
+  type: 'buyEquipment';
+  amount: number;
+} | {
+  type: 'depreciate';
+  amount: number;
+} | {
+  type: 'buyStock';
+  qty: number;
+  unitCost: number;
+} | {
+  type: 'sell';
+  qty: number;
+  price: number;
+} | {
+  type: 'expense';
+  amount: number;
+} | {
+  type: 'closePeriod';
+};
+/** Apply one action; pure and balance-preserving (assets = liabilities + equity). */
+declare function applyBiz(s: BizState, a: BizAction): BizState;
+/** Run a whole authored scenario from an (optional) starting state. */
+declare function runBiz(actions: BizAction[], init?: Partial<BizState>): BizState;
+interface IncomeStatement {
+  revenue: number;
+  cogs: number;
+  grossProfit: number;
+  expenses: number;
+  netProfit: number;
+}
+/** Income statement for the current open period. */
+declare function incomeStatement(s: BizState): IncomeStatement;
+interface BalanceSheet {
+  cash: number;
+  inventory: number;
+  equipment: number;
+  totalAssets: number;
+  loan: number;
+  capital: number;
+  retained: number;
+  openProfit: number;
+  totalEquity: number;
+  totalLiabilitiesEquity: number;
+  balances: boolean;
+}
+/** Balance sheet; `balances` is always true by construction (a self-check). */
+declare function balanceSheet(s: BizState): BalanceSheet;
+//#endregion
+export { BalanceSheet, BizAction, BizState, IncomeStatement, applyBiz, balanceSheet, incomeStatement, initialBiz, runBiz };

package/dist/finance/bizsim.mjs

@@ -0,0 +1,117 @@
+//#region src/finance/bizsim.ts
+const initialBiz = (over = {}) => ({
+	cash: 0,
+	inventoryQty: 0,
+	inventoryValue: 0,
+	equipment: 0,
+	loan: 0,
+	capital: 0,
+	retained: 0,
+	revenue: 0,
+	cogs: 0,
+	expenses: 0,
+	...over
+});
+/** Apply one action; pure and balance-preserving (assets = liabilities + equity). */
+function applyBiz(s, a) {
+	switch (a.type) {
+		case "invest": return {
+			...s,
+			cash: s.cash + a.amount,
+			capital: s.capital + a.amount
+		};
+		case "loan": return {
+			...s,
+			cash: s.cash + a.amount,
+			loan: s.loan + a.amount
+		};
+		case "repay": return {
+			...s,
+			cash: s.cash - a.amount,
+			loan: s.loan - a.amount
+		};
+		case "buyEquipment": return {
+			...s,
+			cash: s.cash - a.amount,
+			equipment: s.equipment + a.amount
+		};
+		case "depreciate": return {
+			...s,
+			equipment: s.equipment - a.amount,
+			expenses: s.expenses + a.amount
+		};
+		case "buyStock": return {
+			...s,
+			cash: s.cash - a.qty * a.unitCost,
+			inventoryQty: s.inventoryQty + a.qty,
+			inventoryValue: s.inventoryValue + a.qty * a.unitCost
+		};
+		case "sell": {
+			const avg = s.inventoryQty > 0 ? s.inventoryValue / s.inventoryQty : 0;
+			const qty = Math.min(a.qty, s.inventoryQty);
+			const cost = qty * avg, sales = qty * a.price;
+			return {
+				...s,
+				cash: s.cash + sales,
+				revenue: s.revenue + sales,
+				cogs: s.cogs + cost,
+				inventoryQty: s.inventoryQty - qty,
+				inventoryValue: s.inventoryValue - cost
+			};
+		}
+		case "expense": return {
+			...s,
+			cash: s.cash - a.amount,
+			expenses: s.expenses + a.amount
+		};
+		case "closePeriod": {
+			const net = s.revenue - s.cogs - s.expenses;
+			return {
+				...s,
+				retained: s.retained + net,
+				revenue: 0,
+				cogs: 0,
+				expenses: 0
+			};
+		}
+		default: return s;
+	}
+}
+/** Run a whole authored scenario from an (optional) starting state. */
+function runBiz(actions, init = {}) {
+	return actions.reduce(applyBiz, initialBiz(init));
+}
+/** Income statement for the current open period. */
+function incomeStatement(s) {
+	const grossProfit = s.revenue - s.cogs;
+	return {
+		revenue: s.revenue,
+		cogs: s.cogs,
+		grossProfit,
+		expenses: s.expenses,
+		netProfit: grossProfit - s.expenses
+	};
+}
+/** Balance sheet; `balances` is always true by construction (a self-check). */
+function balanceSheet(s) {
+	const totalAssets = s.cash + s.inventoryValue + s.equipment;
+	const openProfit = s.revenue - s.cogs - s.expenses;
+	const totalEquity = s.capital + s.retained + openProfit;
+	const totalLiabilitiesEquity = s.loan + totalEquity;
+	return {
+		cash: s.cash,
+		inventory: s.inventoryValue,
+		equipment: s.equipment,
+		totalAssets,
+		loan: s.loan,
+		capital: s.capital,
+		retained: s.retained,
+		openProfit,
+		totalEquity,
+		totalLiabilitiesEquity,
+		balances: Math.abs(totalAssets - totalLiabilitiesEquity) < 1e-6
+	};
+}
+
+//#endregion
+export { applyBiz, balanceSheet, incomeStatement, initialBiz, runBiz };

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 };