@classytic/labs 0.6.0 → 0.7.0

package/dist/algorithms/TraceTransport.d.mts

@@ -1,11 +0,0 @@
-import { Dispatch, SetStateAction } from "react";
-//#region src/algorithms/TraceTransport.d.ts
-export interface TraceTransportProps {
-  step: number;
-  count: number;
-  message: string;
-  setStep: Dispatch<SetStateAction<number>>;
-  canAdvance?: boolean;
-}
-export declare function TraceTransport({ step, count, message, setStep, canAdvance }: TraceTransportProps): import("react").JSX.Element;
-//#endregion

package/dist/algorithms/TraceTransport.mjs

@@ -1,165 +0,0 @@
-'use client';
-
-import { ActionButton, IconButton, Slider } from "../kit/controls.mjs";
-import { Field } from "../kit/frame.mjs";
-import { useReducedMotion } from "../kit/anim.mjs";
-import { useEffect, useRef, useState } from "react";
-import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-import { ChevronLeft, ChevronRight, Gauge, Pause, Play } from "lucide-react";
-
-//#region src/algorithms/TraceTransport.tsx
-const SPEEDS = [
-	1,
-	1.5,
-	2
-];
-function TraceTransport({ step, count, message, setStep, canAdvance = true }) {
-	const [playing, setPlaying] = useState(false);
-	const [speedIndex, setSpeedIndex] = useState(0);
-	const reduceMotion = useReducedMotion();
-	const speed = SPEEDS[speedIndex];
-	useEffect(() => {
-		if (!playing || !canAdvance || reduceMotion) return;
-		if (step >= count - 1) {
-			setPlaying(false);
-			return;
-		}
-		const timer = window.setTimeout(() => setStep((value) => Math.min(count - 1, value + 1)), 900 / speed);
-		return () => window.clearTimeout(timer);
-	}, [
-		canAdvance,
-		count,
-		playing,
-		reduceMotion,
-		setStep,
-		speed,
-		step
-	]);
-	const togglePlayback = () => {
-		if (step >= count - 1) setStep(0);
-		setPlaying((value) => !value);
-	};
-	const anchor = useRef(null);
-	const latest = useRef({
-		step,
-		count,
-		canAdvance,
-		reduceMotion
-	});
-	latest.current = {
-		step,
-		count,
-		canAdvance,
-		reduceMotion
-	};
-	useEffect(() => {
-		const onKey = (event) => {
-			const activity = anchor.current?.closest(".lab-activity");
-			if (!activity || !activity.contains(document.activeElement)) return;
-			const target = event.target;
-			if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable)) return;
-			const state = latest.current;
-			switch (event.key) {
-				case "ArrowRight":
-					if (!state.canAdvance || state.step >= state.count - 1) return;
-					event.preventDefault();
-					setPlaying(false);
-					setStep((value) => Math.min(state.count - 1, value + 1));
-					break;
-				case "ArrowLeft":
-					if (state.step <= 0) return;
-					event.preventDefault();
-					setPlaying(false);
-					setStep((value) => Math.max(0, value - 1));
-					break;
-				case " ":
-				case "k":
-					if (!state.canAdvance || state.reduceMotion) return;
-					event.preventDefault();
-					if (state.step >= state.count - 1) setStep(0);
-					setPlaying((value) => !value);
-					break;
-				case "ArrowUp":
-				case "+":
-				case "=":
-					event.preventDefault();
-					setSpeedIndex((value) => Math.min(SPEEDS.length - 1, value + 1));
-					break;
-				case "ArrowDown":
-				case "-":
-				case "_":
-					event.preventDefault();
-					setSpeedIndex((value) => Math.max(0, value - 1));
-					break;
-			}
-		};
-		window.addEventListener("keydown", onKey);
-		return () => window.removeEventListener("keydown", onKey);
-	}, [setStep]);
-	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
-		/* @__PURE__ */ jsx("span", {
-			ref: anchor,
-			hidden: true
-		}),
-		/* @__PURE__ */ jsx(IconButton, {
-			label: "Previous step",
-			title: "Previous step (←)",
-			onClick: () => {
-				setPlaying(false);
-				setStep((value) => Math.max(0, value - 1));
-			},
-			disabled: step === 0,
-			children: /* @__PURE__ */ jsx(ChevronLeft, { "aria-hidden": "true" })
-		}),
-		/* @__PURE__ */ jsx(Field, {
-			label: "step",
-			value: `${step + 1}/${count}`,
-			children: canAdvance ? /* @__PURE__ */ jsx(Slider, {
-				min: 1,
-				max: count,
-				step: 1,
-				value: step + 1,
-				onChange: (value) => {
-					setPlaying(false);
-					setStep(value - 1);
-				},
-				ariaLabel: `Choose step, currently ${step + 1} of ${count}`
-			}) : /* @__PURE__ */ jsx("progress", {
-				value: step + 1,
-				max: count,
-				"aria-label": `Step ${step + 1} of ${count}`
-			})
-		}),
-		/* @__PURE__ */ jsx(IconButton, {
-			label: playing ? "Pause trace" : step >= count - 1 ? "Replay trace" : "Play trace",
-			title: playing ? "Pause (space)" : step >= count - 1 ? "Replay (space)" : "Play (space)",
-			onClick: togglePlayback,
-			disabled: !canAdvance || reduceMotion,
-			children: playing ? /* @__PURE__ */ jsx(Pause, { "aria-hidden": "true" }) : /* @__PURE__ */ jsx(Play, { "aria-hidden": "true" })
-		}),
-		/* @__PURE__ */ jsxs(ActionButton, {
-			"aria-label": `Playback speed ${speed} times; activate to change`,
-			title: `Playback speed ${speed}× (↑ / ↓)`,
-			onClick: () => setSpeedIndex((value) => (value + 1) % SPEEDS.length),
-			children: [/* @__PURE__ */ jsx(Gauge, { "aria-hidden": "true" }), /* @__PURE__ */ jsxs("span", { children: [speed, "×"] })]
-		}),
-		/* @__PURE__ */ jsxs(ActionButton, {
-			"aria-label": "Next step",
-			title: "Next step (→)",
-			onClick: () => {
-				setPlaying(false);
-				setStep((value) => Math.min(count - 1, value + 1));
-			},
-			disabled: step === count - 1 || !canAdvance,
-			children: [/* @__PURE__ */ jsx("span", { children: "Next step" }), /* @__PURE__ */ jsx(ChevronRight, { "aria-hidden": "true" })]
-		}),
-		/* @__PURE__ */ jsx("span", {
-			className: "lab-sr-only",
-			"aria-live": "polite",
-			children: `Step ${step + 1} of ${count}: ${message}`
-		})
-	] });
-}
-
-//#endregion
-export { TraceTransport };

package/dist/blocks/lab-block.mjs

@@ -1,87 +0,0 @@
-'use client';
-
-import { LabConfig } from "./lab-config.mjs";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { z } from "zod";
-import { defineBlock } from "@classytic/cms-ui/contract";
-
-//#region src/blocks/lab-block.tsx
-/**
-* labBlock, wrap a plain lab component into a CMS block "on call", with ZERO
-* per-lab boilerplate. The host passes the lab component + its zod prop-schema; this
-* returns a `defineBlock` spec whose Component:
-*   • in render mode  → spreads the block attributes straight into the lab, and
-*   • in editing mode → shows the generic, zod-driven `LabConfig` panel above it
-*     (one field per prop, derived from the schema, no hand-written ConfigPanel).
-* The MDX tag is auto-derived (PascalCase of the key) by `defineBlock`.
-*
-* This is the ONE shared factory for every domain (`./physics`, `./chem`, …), a
-* domain file just declares `labBlock({ key, label, description, schema, Component })`
-* per lab instead of re-implementing the defineBlock + attribute-spread + editor
-* wiring each time. `commonLabProps` are the title/prompt/objectives/hints/controlId
-* fields every lab accepts; spread them into a lab's schema with `...commonLabProps`.
-*/
-/** The authoring props every lab accepts. Spread into a lab schema: `{ ...commonLabProps }`. */
-const commonLabProps = {
-	title: z.string().optional(),
-	prompt: z.string().optional(),
-	mission: z.string().optional().describe("the learner-facing mission; overrides prompt when set"),
-	objectives: z.array(z.string()).optional(),
-	hints: z.array(z.string()).optional(),
-	controlId: z.string().optional(),
-	/**
-	* Narrow a multi-mode lab to the one setup this lesson is about: hide or lock named controls.
-	* A teacher covering Boyle's law locks temperature so the class varies pressure and volume and
-	* nothing else, out of the same lab that elsewhere teaches all three.
-	*
-	* Applied by LabRuntime around every lab, so it works whether or not the component declares the
-	* prop. Before it lived here, 18 of 296 labs could be focused this way.
-	*/
-	controlConfig: z.object({
-		hide: z.array(z.string()).optional(),
-		lock: z.array(z.string()).optional()
-	}).optional().describe("hide or lock named controls to focus the lab on one idea")
-};
-/** PascalCase MDX tag from a kebab key, mirrors `defineBlock`'s default, for building a components map. */
-const pascalTag = (key) => key.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-function labBlock({ key, label, description, schema, Component, tag, omit }) {
-	const block = defineBlock({
-		key,
-		void: true,
-		...tag ? { tag } : {},
-		label,
-		description,
-		category: "interactive",
-		schema,
-		Component: ({ attributes, mode, updateAttributes }) => {
-			const widget = Component(attributes);
-			if (mode !== "editing" || !updateAttributes) return widget;
-			return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(LabConfig, {
-				schema,
-				value: attributes,
-				onChange: updateAttributes,
-				omit
-			}), widget] });
-		}
-	});
-	return Object.assign(block, {
-		tag: tag ?? pascalTag(key),
-		lab: Component
-	});
-}
-/**
-* Derive the tag→component MDX render map from a domain's blocks, ONE source of truth.
-* Only `labBlock`-created blocks carry `.lab`; bespoke `defineBlock` blocks (custom editor
-* UI) are merged into the map by hand alongside this.
-*/
-function buildComponents(blocks) {
-	const map = {};
-	for (const b of blocks) {
-		const lb = b;
-		if (typeof lb.tag === "string" && typeof lb.lab === "function") map[lb.tag] = lb.lab;
-	}
-	return map;
-}
-
-//#endregion
-export { commonLabProps, pascalTag };

package/dist/commerce/accounting/books/index.mjs

@@ -1,8 +0,0 @@
-import { STANDARD_CHART, accountMap, bookAccountSchema, describeKind, kindOf, normalSide, opposite, resolveChart } from "./chart.mjs";
-import { explainLine, fmt, gradeEntry, isBalanced, lineDirection, normalizeLines, sideTotal } from "./entry.mjs";
-import { balanceOff, postBooks, runningBalance } from "./ledger.mjs";
-import { entriesBefore, entriesThrough, findEpisode, getBooksWorld, registerBooksWorld, viewBooks } from "./world.mjs";
-import { KALAM_WORLD } from "./worlds/kalam.mjs";
-import { ERROR_INFO, SUSPENSE_ACCOUNT, applyError, correctingEntry, transpose } from "../../../domains/accounting/ledger-detective/books/errors.mjs";
-
-export { ERROR_INFO, KALAM_WORLD, STANDARD_CHART, SUSPENSE_ACCOUNT, accountMap, applyError, balanceOff, bookAccountSchema, correctingEntry, describeKind, entriesBefore, entriesThrough, explainLine, findEpisode, fmt, getBooksWorld, gradeEntry, isBalanced, kindOf, lineDirection, normalSide, normalizeLines, opposite, postBooks, registerBooksWorld, resolveChart, runningBalance, sideTotal, transpose, viewBooks };

package/dist/core/numeric.d.mts

@@ -1,19 +0,0 @@
-//#region src/core/numeric.d.ts
-/**
- * numeric, small numerical-calculus helpers, used when an exact symbolic result
- * isn't available (e.g. a function the differentiator doesn't handle) or when a
- * widget just needs a number. Pure, dependency-free.
- */
-export type RealFn = (x: number) => number;
-/** Numerical derivative via the symmetric difference quotient. */
-export declare function derivativeAt(fn: RealFn, x: number, h?: number): number;
-/** Slope of the secant line through (a, f(a)) and (b, f(b)). */
-export declare function secantSlope(fn: RealFn, a: number, b: number): number;
-/** Sample a function across a range into `{x, y}` points (skips non-finite y is the caller's job). */
-export declare function sampleFunction(fn: RealFn, range: [number, number], samples?: number): {
-  x: number;
-  y: number;
-}[];
-/** Riemann sum of `fn` over `[a, b]` with `n` subintervals. A teaching estimate. */
-export declare function riemannSum(fn: RealFn, range: [number, number], n: number, mode?: 'left' | 'right' | 'mid'): number;
-//#endregion

package/dist/core/numeric.mjs

@@ -1,36 +0,0 @@
-//#region src/core/numeric.ts
-/** Numerical derivative via the symmetric difference quotient. */
-function derivativeAt(fn, x, h = 1e-5) {
-	return (fn(x + h) - fn(x - h)) / (2 * h);
-}
-/** Slope of the secant line through (a, f(a)) and (b, f(b)). */
-function secantSlope(fn, a, b) {
-	return (fn(b) - fn(a)) / (b - a);
-}
-/** Sample a function across a range into `{x, y}` points (skips non-finite y is the caller's job). */
-function sampleFunction(fn, range, samples = 200) {
-	const [min, max] = range;
-	const out = [];
-	for (let i = 0; i <= samples; i++) {
-		const x = min + (max - min) * i / samples;
-		out.push({
-			x,
-			y: fn(x)
-		});
-	}
-	return out;
-}
-/** Riemann sum of `fn` over `[a, b]` with `n` subintervals. A teaching estimate. */
-function riemannSum(fn, range, n, mode = "mid") {
-	const [a, b] = range;
-	const dx = (b - a) / n;
-	let sum = 0;
-	for (let i = 0; i < n; i++) {
-		const x = mode === "left" ? a + i * dx : mode === "right" ? a + (i + 1) * dx : a + (i + .5) * dx;
-		sum += fn(x);
-	}
-	return sum * dx;
-}
-
-//#endregion
-export { derivativeAt, riemannSum, sampleFunction, secantSlope };

package/dist/core/rng.d.mts

@@ -1,2 +0,0 @@
-import { Rng, gaussian as gaussian$1, mulberry32 as mulberry32$1, randInt, sampleWithout as sample, shuffle as shuffle$1 } from "@classytic/stage/rng";
-export { type Rng, gaussian$1 as gaussian, mulberry32$1 as mulberry32, randInt, sample, shuffle$1 as shuffle };

package/dist/core/rng.mjs

@@ -1,3 +0,0 @@
-import { gaussian as gaussian$1, mulberry32 as mulberry32$1, randInt, sampleWithout as sample, shuffle as shuffle$1 } from "@classytic/stage/rng";
-
-export { gaussian$1 as gaussian, mulberry32$1 as mulberry32, randInt, sample, shuffle$1 as shuffle };

package/dist/core/timeline.d.mts

@@ -1,32 +0,0 @@
-import { Easing } from "./easing.mjs";
-//#region src/core/timeline.d.ts
-export interface TweenOptions {
-  from?: number;
-  to: number;
-  durationMs?: number;
-  ease?: Easing;
-  autoplay?: boolean;
-  loop?: boolean | 'pingpong';
-}
-export interface TweenState {
-  value: number;
-  progress: number;
-  playing: boolean;
-  play: () => void;
-  pause: () => void;
-  reset: () => void;
-}
-export declare function useTween(opts: TweenOptions): TweenState;
-export interface Keyframe {
-  /** Normalized time 0..1. */
-  at: number;
-  value: number;
-  ease?: Easing;
-}
-/**
- * Pure multi-stage interpolation: build a `(t in [0,1]) => number` from
- * keyframes. The manim-style way to express richer programmatic animation
- * without a scheduler, drive `t` from `useTween`/`useFrameLoop`.
- */
-export declare function keyframes(frames: Keyframe[]): (t: number) => number;
-//#endregion

package/dist/core/timeline.mjs

@@ -1,80 +0,0 @@
-'use client';
-
-import { clamp, lerp } from "./util.mjs";
-import { smooth } from "./easing.mjs";
-import { useRef, useState } from "react";
-import { useFrameLoop } from "@classytic/stage";
-
-//#region src/core/timeline.ts
-/**
-* Declarative animation over the injectable clock. `useTween` animates one
-* number from `from`→`to` with an easing; it derives progress from the clock's
-* `timeMs` (not an accumulated counter), so under a fixed driver (e.g. Remotion)
-* it's deterministic and scrubbable. Widgets that prefer to drive frames
-* imperatively use `useFrameLoop` (from `@classytic/stage`) directly.
-*/
-function useTween(opts) {
-	const { from = 0, to, durationMs = 800, ease = smooth, autoplay = false, loop = false } = opts;
-	const [playing, setPlaying] = useState(autoplay);
-	const [progress, setProgress] = useState(autoplay ? 0 : 0);
-	const startRef = useRef(null);
-	useFrameLoop((f) => {
-		if (startRef.current === null) startRef.current = f.timeMs;
-		let p = (f.timeMs - startRef.current) / durationMs;
-		if (p >= 1) {
-			if (loop === true) {
-				startRef.current = f.timeMs;
-				p = 0;
-			} else if (loop === "pingpong") {
-				const cycle = (f.timeMs - startRef.current) / durationMs % 2;
-				p = cycle <= 1 ? cycle : 2 - cycle;
-			} else {
-				p = 1;
-				setPlaying(false);
-			}
-		}
-		setProgress(p);
-	}, { running: playing });
-	const eased = ease(clamp(progress, 0, 1));
-	return {
-		value: lerp(from, to, eased),
-		progress,
-		playing,
-		play: () => {
-			startRef.current = null;
-			setPlaying(true);
-		},
-		pause: () => setPlaying(false),
-		reset: () => {
-			startRef.current = null;
-			setProgress(0);
-			setPlaying(false);
-		}
-	};
-}
-/**
-* Pure multi-stage interpolation: build a `(t in [0,1]) => number` from
-* keyframes. The manim-style way to express richer programmatic animation
-* without a scheduler, drive `t` from `useTween`/`useFrameLoop`.
-*/
-function keyframes(frames) {
-	const ks = [...frames].sort((a, b) => a.at - b.at);
-	return (t) => {
-		if (ks.length === 0) return 0;
-		if (t <= ks[0].at) return ks[0].value;
-		if (t >= ks[ks.length - 1].at) return ks[ks.length - 1].value;
-		for (let i = 0; i < ks.length - 1; i++) {
-			const a = ks[i];
-			const b = ks[i + 1];
-			if (t >= a.at && t <= b.at) {
-				const local = (t - a.at) / (b.at - a.at || 1);
-				const e = (b.ease ?? smooth)(local);
-				return lerp(a.value, b.value, e);
-			}
-		}
-		return ks[ks.length - 1].value;
-	};
-}
-
-//#endregion
-export { keyframes, useTween };

package/dist/discrete/core/combinatorics.d.mts

@@ -1,45 +0,0 @@
-//#region src/discrete/core/combinatorics.d.ts
-/**
- * Combinatorics kernel, the counting source-of-truth every discrete-math lab
- * trusts (so an agent narrates these, never computes its own). Pure, integer,
- * dependency-free. The headline identity the Counting lab is built on:
- *   nCr(n,k) = nPr(n,k) / k!   ("overcount by order, then divide it out").
- */
-export declare function factorial(n: number): number;
-/** Ordered selections: n·(n−1)···(n−r+1). */
-export declare function nPr(n: number, r: number): number;
-/** Unordered selections: nPr/k!, via the exact step-wise multiplicative form. */
-export declare function nCr(n: number, r: number): number;
-/** Binomial coefficient, alias of nCr (the "n choose k"). */
-export declare const binomial: typeof nCr;
-/** Arrangements of a multiset: n! / (k1! k2! …), where Σki = n. */
-export declare function multinomial(...counts: number[]): number;
-/** Stars and bars: ways to place n identical items into k distinct bins =
- *  C(n+k−1, k−1). */
-export declare function starsAndBars(n: number, k: number): number;
-/** Rule of PRODUCT (multiplication principle): a task done as a SEQUENCE of
- *  independent stages — do stage 1 AND stage 2 AND … — multiplies the choice
- *  counts. ruleOfProduct(4, 3, 2) = 24. The spine under nPr / nʳ / factorial. */
-export declare function ruleOfProduct(...stages: number[]): number;
-/** Rule of SUM (addition principle): MUTUALLY EXCLUSIVE cases, do this OR that,
- *  with no overlap — add their counts. ruleOfSum(3, 5) = 8. If the cases can
- *  overlap, use {@link inclusionExclusion} (sum, then subtract the double-count). */
-export declare function ruleOfSum(...cases: number[]): number;
-/** Cartesian product: one choice from every authored option set. Shared by
- * sample-space and combination builders so enumeration order stays stable. */
-export declare function cartesianProduct<T>(sets: readonly (readonly T[])[]): T[][];
-/** Permutations WITH repetition: r positions, each independently filled from n
- *  options = nʳ. PIN codes, license plates, binary strings, functions A→B. */
-export declare function permutationsWithRepetition(n: number, r: number): number;
-/** Circular permutations: distinct arrangements of n around a round table where
- *  only RELATIVE order matters = (n−1)!. (1 for n ≤ 1.) */
-export declare function circularPermutations(n: number): number;
-/** Combinations WITH repetition ("n multichoose k"): choose k from n types,
- *  repetition allowed, order irrelevant = C(n+k−1, k). Same stars-and-bars
- *  family as {@link starsAndBars}, re-parameterized for selection (e.g. k scoops
- *  from n ice-cream flavours). */
-export declare function multichoose(n: number, k: number): number;
-export declare const combinationsWithRepetition: typeof multichoose;
-export declare function gcd(a: number, b: number): number;
-export declare function lcm(a: number, b: number): number;
-//#endregion

package/dist/discrete/core/combinatorics.mjs

@@ -1,100 +0,0 @@
-//#region src/discrete/core/combinatorics.ts
-/**
-* Combinatorics kernel, the counting source-of-truth every discrete-math lab
-* trusts (so an agent narrates these, never computes its own). Pure, integer,
-* dependency-free. The headline identity the Counting lab is built on:
-*   nCr(n,k) = nPr(n,k) / k!   ("overcount by order, then divide it out").
-*/
-const isCount = (n) => Number.isInteger(n) && n >= 0;
-function factorial(n) {
-	if (!isCount(n)) return NaN;
-	let r = 1;
-	for (let i = 2; i <= n; i++) r *= i;
-	return r;
-}
-/** Ordered selections: n·(n−1)···(n−r+1). */
-function nPr(n, r) {
-	if (!isCount(n) || !isCount(r) || r > n) return r > n ? 0 : NaN;
-	let r0 = 1;
-	for (let i = 0; i < r; i++) r0 *= n - i;
-	return r0;
-}
-/** Unordered selections: nPr/k!, via the exact step-wise multiplicative form. */
-function nCr(n, r) {
-	if (!isCount(n) || !isCount(r)) return NaN;
-	if (r > n) return 0;
-	const k = Math.min(r, n - r);
-	let res = 1;
-	for (let i = 1; i <= k; i++) res = res * (n - k + i) / i;
-	return Math.round(res);
-}
-/** Binomial coefficient, alias of nCr (the "n choose k"). */
-const binomial = nCr;
-/** Arrangements of a multiset: n! / (k1! k2! …), where Σki = n. */
-function multinomial(...counts) {
-	const n = counts.reduce((s, c) => s + c, 0);
-	let res = factorial(n);
-	for (const c of counts) res /= factorial(c);
-	return Math.round(res);
-}
-/** Stars and bars: ways to place n identical items into k distinct bins =
-*  C(n+k−1, k−1). */
-function starsAndBars(n, k) {
-	if (!isCount(n) || !isCount(k) || k < 1) return NaN;
-	return nCr(n + k - 1, k - 1);
-}
-/** Rule of PRODUCT (multiplication principle): a task done as a SEQUENCE of
-*  independent stages — do stage 1 AND stage 2 AND … — multiplies the choice
-*  counts. ruleOfProduct(4, 3, 2) = 24. The spine under nPr / nʳ / factorial. */
-function ruleOfProduct(...stages) {
-	if (!stages.length || stages.some((c) => !Number.isFinite(c))) return NaN;
-	return stages.reduce((p, c) => p * c, 1);
-}
-/** Rule of SUM (addition principle): MUTUALLY EXCLUSIVE cases, do this OR that,
-*  with no overlap — add their counts. ruleOfSum(3, 5) = 8. If the cases can
-*  overlap, use {@link inclusionExclusion} (sum, then subtract the double-count). */
-function ruleOfSum(...cases) {
-	if (!cases.length || cases.some((c) => !Number.isFinite(c))) return NaN;
-	return cases.reduce((s, c) => s + c, 0);
-}
-/** Cartesian product: one choice from every authored option set. Shared by
-* sample-space and combination builders so enumeration order stays stable. */
-function cartesianProduct(sets) {
-	return sets.reduce((rows, options) => rows.flatMap((row) => options.map((option) => [...row, option])), [[]]);
-}
-/** Permutations WITH repetition: r positions, each independently filled from n
-*  options = nʳ. PIN codes, license plates, binary strings, functions A→B. */
-function permutationsWithRepetition(n, r) {
-	if (!isCount(n) || !isCount(r)) return NaN;
-	return n ** r;
-}
-/** Circular permutations: distinct arrangements of n around a round table where
-*  only RELATIVE order matters = (n−1)!. (1 for n ≤ 1.) */
-function circularPermutations(n) {
-	if (!isCount(n)) return NaN;
-	return n <= 1 ? 1 : factorial(n - 1);
-}
-/** Combinations WITH repetition ("n multichoose k"): choose k from n types,
-*  repetition allowed, order irrelevant = C(n+k−1, k). Same stars-and-bars
-*  family as {@link starsAndBars}, re-parameterized for selection (e.g. k scoops
-*  from n ice-cream flavours). */
-function multichoose(n, k) {
-	if (!isCount(n) || !isCount(k)) return NaN;
-	return nCr(n + k - 1, k);
-}
-const combinationsWithRepetition = multichoose;
-function gcd(a, b) {
-	a = Math.abs(a);
-	b = Math.abs(b);
-	while (b) {
-		[a, b] = [b, a % b];
-	}
-	return a;
-}
-function lcm(a, b) {
-	if (a === 0 || b === 0) return 0;
-	return Math.abs(a / gcd(a, b) * b);
-}
-
-//#endregion
-export { binomial, cartesianProduct, circularPermutations, combinationsWithRepetition, factorial, gcd, lcm, multichoose, multinomial, nCr, nPr, permutationsWithRepetition, ruleOfProduct, ruleOfSum, starsAndBars };

package/dist/discrete/core/probability.d.mts

@@ -1,28 +0,0 @@
-//#region src/discrete/core/probability.d.ts
-/**
- * Probability kernel, equally-likely sample spaces, conditioning, Bayes,
- * independence, expectation. This is the "truth" the base-rate / Monty labs read
- * (the agent narrates these numbers; it never invents them). Conditioning =
- * shrink the sample space: P(A|B) = |A∩B| / |B|.
- */
-/** Favourable / total over an equally-likely space. */
-export declare function probability(favorable: number, total: number): number;
-export declare function complement(p: number): number;
-/** P(A|B) = P(A∩B) / P(B), restrict the world to B, then re-count. */
-export declare function conditional(pAandB: number, pB: number): number;
-/**
- * P(A|B) from the natural inputs: the true-positive rate P(B|A), the prior P(A),
- * and the false-positive rate P(B|¬A). The base-rate-neglect engine.
- */
-export declare function bayes(pBgivenA: number, pA: number, pBgivenNotA: number): number;
-/** A and B are independent iff P(A∩B) = P(A)·P(B) (within eps). NOT the same as
- *  disjoint, disjoint events are maximally DEPENDENT. */
-export declare function independent(pA: number, pB: number, pAandB: number, eps?: number): boolean;
-/** Expected value Σ p·value (probabilities should sum to 1). */
-export declare function expectedValue(outcomes: ReadonlyArray<{
-  p: number;
-  value: number;
-}>): number;
-/** "At least one" via the complement: 1 − (1−p)^n. */
-export declare function atLeastOne(pEach: number, n: number): number;
-//#endregion

package/dist/discrete/core/probability.mjs

@@ -1,43 +0,0 @@
-//#region src/discrete/core/probability.ts
-/**
-* Probability kernel, equally-likely sample spaces, conditioning, Bayes,
-* independence, expectation. This is the "truth" the base-rate / Monty labs read
-* (the agent narrates these numbers; it never invents them). Conditioning =
-* shrink the sample space: P(A|B) = |A∩B| / |B|.
-*/
-/** Favourable / total over an equally-likely space. */
-function probability(favorable, total) {
-	return total > 0 ? favorable / total : NaN;
-}
-function complement(p) {
-	return 1 - p;
-}
-/** P(A|B) = P(A∩B) / P(B), restrict the world to B, then re-count. */
-function conditional(pAandB, pB) {
-	return pB > 0 ? pAandB / pB : NaN;
-}
-/**
-* P(A|B) from the natural inputs: the true-positive rate P(B|A), the prior P(A),
-* and the false-positive rate P(B|¬A). The base-rate-neglect engine.
-*/
-function bayes(pBgivenA, pA, pBgivenNotA) {
-	const num = pBgivenA * pA;
-	const den = num + pBgivenNotA * (1 - pA);
-	return den > 0 ? num / den : NaN;
-}
-/** A and B are independent iff P(A∩B) = P(A)·P(B) (within eps). NOT the same as
-*  disjoint, disjoint events are maximally DEPENDENT. */
-function independent(pA, pB, pAandB, eps = 1e-9) {
-	return Math.abs(pAandB - pA * pB) <= eps;
-}
-/** Expected value Σ p·value (probabilities should sum to 1). */
-function expectedValue(outcomes) {
-	return outcomes.reduce((s, o) => s + o.p * o.value, 0);
-}
-/** "At least one" via the complement: 1 − (1−p)^n. */
-function atLeastOne(pEach, n) {
-	return 1 - Math.pow(1 - pEach, n);
-}
-
-//#endregion
-export { atLeastOne, bayes, complement, conditional, expectedValue, independent, probability };