@classytic/labs 0.1.0 → 0.3.0

package/dist/discrete/combination-studio/preset.mjs

@@ -0,0 +1,381 @@
+'use client';
+
+import { ActionButton, IconButton } from "../../kit/controls.mjs";
+import { Activity } from "../../kit/activity.mjs";
+import { ChallengeCard, HintLadder, useChallenge, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
+import { cartesianProduct, ruleOfProduct } from "../core/combinatorics.mjs";
+import { CharacterFigure, ComboCard, OptionSwatch } from "./figure.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { RotateCcw } from "lucide-react";
+
+//#region src/discrete/combination-studio/preset.tsx
+/**
+* CombinationStudioLab, the rule of product you can FEEL. Instead of reading
+* "3 × 2 = 6", the learner:
+*   1. picks one option from each rack (a shirt, some trousers) and watches a
+*      little character assemble live, so every outcome is a thing, not a label;
+*   2. PREDICTS how many different ones exist before exploring (predict-first);
+*   3. fills a discovery wall by making each combination, the wall is literally a
+*      rows × columns grid, so the product IS an area they complete;
+*   4. adds a third variable (a hat) and watches 3 × 2 = 6 become 3 × 2 × 2 = 12,
+*      feeling why a new choice MULTIPLIES.
+*
+* Fully authorable: a creator supplies any scenario (outfits, sundaes, number
+* plates, routes) as categories of options. Pure cartesian-product enumeration;
+* the count uses ruleOfProduct from the discrete kernel.
+*/
+const DEFAULT_CATS = [
+	{
+		id: "shirt",
+		label: "Shirt",
+		slot: "top",
+		options: [
+			{
+				id: "r",
+				label: "red",
+				color: "#e5484d"
+			},
+			{
+				id: "b",
+				label: "blue",
+				color: "#3e63dd"
+			},
+			{
+				id: "g",
+				label: "green",
+				color: "#30a46c"
+			}
+		]
+	},
+	{
+		id: "trousers",
+		label: "Trousers",
+		slot: "bottom",
+		options: [{
+			id: "d",
+			label: "denim",
+			color: "#2b4a8b"
+		}, {
+			id: "k",
+			label: "khaki",
+			color: "#a18249"
+		}]
+	},
+	{
+		id: "hat",
+		label: "Hat",
+		slot: "hat",
+		options: [{
+			id: "o",
+			label: "orange",
+			color: "#f76808"
+		}, {
+			id: "p",
+			label: "purple",
+			color: "#8e4ec6"
+		}]
+	}
+];
+/** cartesian product of the active categories' option lists. */
+function enumerate(cats) {
+	return cartesianProduct(cats.map((category) => category.options)).map((picks) => ({
+		key: picks.map((option) => option.id).join("|"),
+		picks
+	}));
+}
+function partsOf(cats, picks) {
+	const p = {};
+	cats.forEach((c, i) => {
+		const o = picks[i];
+		if (!o) return;
+		if (c.slot === "top") p.top = o.color;
+		else if (c.slot === "bottom") p.bottom = o.color;
+		else if (c.slot === "hat") p.hat = o.color;
+		else if (c.slot === "hold") p.hold = o.emoji;
+	});
+	return p;
+}
+function CombinationStudioLab({ scenario = "outfit", categories = DEFAULT_CATS, figure = "character", startActive, maxWall = 60, title = `How many ${scenario}s can you make?`, prompt = "Pick one from each rack, make it, and fill the wall. Each new choice multiplies the total.", objectives, hints: hintList } = {}) {
+	const minActive = Math.min(2, categories.length);
+	const [active, setActive] = useState(Math.max(1, Math.min(startActive ?? minActive, categories.length)));
+	const cats = categories.slice(0, active);
+	const [picks, setPicks] = useState(() => Object.fromEntries(categories.map((c) => [c.id, c.options[0].id])));
+	const [found, setFound] = useState(/* @__PURE__ */ new Set());
+	const hints = useHints(hintList);
+	const combos = useMemo(() => enumerate(cats), [cats]);
+	const sizes = cats.map((c) => c.options.length);
+	const total = ruleOfProduct(...sizes);
+	const tooMany = total > maxWall;
+	const currentPicks = cats.map((c) => c.options.find((o) => o.id === picks[c.id]) ?? c.options[0]);
+	const currentKey = currentPicks.map((o) => o.id).join("|");
+	const madeCurrent = found.has(currentKey);
+	const choices = [total, ...[
+		total + sizes[active - 1],
+		sizes.reduce((a, b) => a + b, 0),
+		Math.max(1, total - 2)
+	].filter((d) => d !== total).slice(0, 2)].sort((a, b) => a - b).map((n) => ({
+		value: String(n),
+		label: String(n)
+	}));
+	const questions = useMemo(() => [{
+		id: `q-${active}-${total}`,
+		prompt: `With ${cats.map((c, i) => `${sizes[i]} ${c.label.toLowerCase()}${sizes[i] > 1 ? "s" : ""}`).join(" and ")}, how many different ${scenario}s?`,
+		choices,
+		answer: String(total),
+		explain: `Yes: ${sizes.join(" × ")} = ${total}. Each independent choice multiplies.`
+	}], [active, total]);
+	const challenge = useChallenge(questions);
+	const allFound = found.size >= total && total > 0;
+	useCheckpoint({
+		solved: allFound && challenge.allCorrect,
+		activity: `combination-studio:${scenario}`,
+		hintsUsed: hints.count
+	});
+	const make = () => setFound((f) => new Set(f).add(currentKey));
+	const pickOpt = (catId, optId) => setPicks((p) => ({
+		...p,
+		[catId]: optId
+	}));
+	const addVar = () => {
+		setActive((a) => Math.min(categories.length, a + 1));
+		setFound(/* @__PURE__ */ new Set());
+	};
+	const dropVar = () => {
+		setActive((a) => Math.max(1, a - 1));
+		setFound(/* @__PURE__ */ new Set());
+	};
+	const reset = () => setFound(/* @__PURE__ */ new Set());
+	const FoundFig = ({ combo, size }) => figure === "character" ? /* @__PURE__ */ jsx(CharacterFigure, {
+		parts: partsOf(cats, combo.picks),
+		size,
+		dim: !found.has(combo.key)
+	}) : /* @__PURE__ */ jsx(ComboCard, {
+		cells: cats.map((c, i) => ({
+			emoji: combo.picks[i].emoji,
+			color: combo.picks[i].color
+		})),
+		size,
+		dim: !found.has(combo.key)
+	});
+	const grid2d = active === 2 && !tooMany;
+	const rows = grid2d ? cats[0].options : [];
+	const cols = grid2d ? cats[1].options : [];
+	const figureEl = /* @__PURE__ */ jsxs("div", {
+		className: "discrete-combination-scene",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "discrete-product-banner",
+				children: [
+					cats.map((c, i) => /* @__PURE__ */ jsxs("span", {
+						className: "discrete-product-factor",
+						children: [
+							i > 0 && /* @__PURE__ */ jsx("span", {
+								className: "discrete-muted",
+								children: "×"
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "discrete-factor-count",
+								children: sizes[i]
+							}),
+							/* @__PURE__ */ jsxs("span", {
+								className: "discrete-factor-label",
+								children: [c.label.toLowerCase(), sizes[i] > 1 ? "s" : ""]
+							})
+						]
+					}, c.id)),
+					/* @__PURE__ */ jsx("span", {
+						className: "discrete-muted",
+						children: "="
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "discrete-answer",
+						children: total
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						className: "discrete-product-progress",
+						children: [
+							found.size,
+							"/",
+							total,
+							" found"
+						]
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "discrete-combination-workbench",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "discrete-option-racks",
+					children: cats.map((c) => /* @__PURE__ */ jsxs("div", {
+						className: "discrete-option-row",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "discrete-option-label",
+							children: c.label
+						}), c.options.map((o) => /* @__PURE__ */ jsx(OptionSwatch, {
+							emoji: o.emoji,
+							color: o.color,
+							label: o.label,
+							selected: picks[c.id] === o.id,
+							onClick: () => pickOpt(c.id, o.id)
+						}, o.id))]
+					}, c.id))
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "discrete-current-combination",
+					children: [figure === "character" ? /* @__PURE__ */ jsx(CharacterFigure, {
+						parts: partsOf(cats, currentPicks),
+						size: 96
+					}) : /* @__PURE__ */ jsx(ComboCard, {
+						cells: cats.map((c, i) => ({
+							emoji: currentPicks[i].emoji,
+							color: currentPicks[i].color
+						})),
+						size: 84
+					}), /* @__PURE__ */ jsx(ActionButton, {
+						onClick: make,
+						disabled: madeCurrent,
+						children: madeCurrent ? "✓ already made" : "+ make this one"
+					})]
+				})]
+			}),
+			tooMany ? /* @__PURE__ */ jsxs("p", {
+				className: "discrete-wall-guidance",
+				children: [
+					"That is ",
+					/* @__PURE__ */ jsx("b", { children: total }),
+					" combinations, too many to draw, but the rule of product still gives the count without listing them. Drop a variable to see them all."
+				]
+			}) : grid2d ? /* @__PURE__ */ jsxs("div", {
+				className: "discrete-combination-grid",
+				style: { "--combination-columns": cols.length },
+				children: [
+					/* @__PURE__ */ jsx("span", {}),
+					cols.map((o) => /* @__PURE__ */ jsx("span", {
+						className: "discrete-grid-label",
+						children: o.label
+					}, o.id)),
+					rows.map((r, ri) => /* @__PURE__ */ jsx(FragmentRow, {
+						label: r.label,
+						children: cols.map((cOpt, ci) => {
+							const combo = combos[ri * cols.length + ci];
+							return /* @__PURE__ */ jsx("div", {
+								className: "discrete-combination-cell",
+								"data-found": found.has(combo.key),
+								children: /* @__PURE__ */ jsx(FoundFig, {
+									combo,
+									size: 48
+								})
+							}, cOpt.id);
+						})
+					}, r.id))
+				]
+			}) : /* @__PURE__ */ jsx("div", {
+				className: "discrete-combination-wall",
+				children: combos.map((combo) => {
+					return /* @__PURE__ */ jsx("div", {
+						className: "discrete-combination-cell",
+						"data-found": found.has(combo.key),
+						children: /* @__PURE__ */ jsx(FoundFig, {
+							combo,
+							size: 46
+						})
+					}, combo.key);
+				})
+			})
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs("div", {
+		className: "lab-activity-fields",
+		children: [
+			/* @__PURE__ */ jsx(ActionButton, {
+				onClick: addVar,
+				disabled: active >= categories.length,
+				children: "Add a variable"
+			}),
+			/* @__PURE__ */ jsx(ActionButton, {
+				onClick: dropVar,
+				disabled: active <= 1,
+				children: "Drop a variable"
+			}),
+			/* @__PURE__ */ jsx(ActionButton, {
+				onClick: reset,
+				disabled: found.size === 0,
+				children: "Clear wall"
+			})
+		]
+	});
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		className: "discrete-combination-studio-activity",
+		children: [
+			/* @__PURE__ */ jsxs(Activity.Header, { children: [/* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Rule of product",
+				title,
+				description: prompt
+			}), /* @__PURE__ */ jsx(Activity.FocusButton, {})] }),
+			/* @__PURE__ */ jsxs(Activity.Status, { children: [
+				/* @__PURE__ */ jsxs("strong", { children: [
+					sizes.join(" × "),
+					" = ",
+					total
+				] }),
+				/* @__PURE__ */ jsxs("span", { children: [active, " variables"] }),
+				/* @__PURE__ */ jsxs("span", { children: [
+					found.size,
+					"/",
+					total,
+					" discovered"
+				] })
+			] }),
+			/* @__PURE__ */ jsxs(Activity.Workspace, { children: [/* @__PURE__ */ jsx(Activity.Canvas, {
+				label: `${scenario} combination workspace`,
+				children: figureEl
+			}), /* @__PURE__ */ jsx(Activity.Inspector, {
+				label: "Variables and discovery controls",
+				children: controls
+			})] }),
+			/* @__PURE__ */ jsxs(Activity.Feedback, { children: [/* @__PURE__ */ jsx("span", { children: allFound ? "Complete" : "Observe" }), /* @__PURE__ */ jsx("div", { children: allFound ? `You made all ${total}. Every independent choice contributes one factor: ${sizes.join(" × ")} = ${total}.` : `Make each ${scenario} to reveal the full product, then add a variable and compare how the count changes.` })] }),
+			/* @__PURE__ */ jsxs("section", {
+				className: "lab-authored-task",
+				"aria-label": "Combination prediction and hints",
+				children: [/* @__PURE__ */ jsx(ChallengeCard, {
+					questions,
+					state: challenge,
+					title: "Predict first"
+				}), /* @__PURE__ */ jsx(HintLadder, { hints })]
+			}),
+			/* @__PURE__ */ jsxs(Activity.LiveRegion, { children: [
+				found.size,
+				" of ",
+				total,
+				" combinations discovered. Current combination is",
+				" ",
+				currentPicks.map((pick) => pick.label).join(", "),
+				"."
+			] }),
+			/* @__PURE__ */ jsxs(Activity.Transport, { children: [/* @__PURE__ */ jsx(IconButton, {
+				label: "Reset discovery wall",
+				onClick: reset,
+				disabled: found.size === 0,
+				children: /* @__PURE__ */ jsx(RotateCcw, { "aria-hidden": "true" })
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "lab-transport-state",
+				"aria-live": "polite",
+				children: [/* @__PURE__ */ jsx("strong", { children: allFound ? "All combinations found" : "Build the product" }), /* @__PURE__ */ jsxs("span", { children: [
+					found.size,
+					" of ",
+					total
+				] })]
+			})] })
+		]
+	});
+}
+/** A grid row: the row label cell + its children cells (keeps JSX flat above). */
+function FragmentRow({ label, children }) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+		className: "discrete-grid-label discrete-row-label",
+		children: label
+	}), children] });
+}
+
+//#endregion
+export { CombinationStudioLab };

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

@@ -1,6 +1,6 @@
 //#region src/discrete/core/combinatorics.d.ts
 /**
- * Combinatorics kernel — the counting source-of-truth every discrete-math lab
+ * 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").
@@ -10,14 +10,37 @@ declare function factorial(n: number): number;
 declare function nPr(n: number, r: number): number;
 /** Unordered selections: nPr/k!, via the exact step-wise multiplicative form. */
 declare function nCr(n: number, r: number): number;
-/** Binomial coefficient — alias of nCr (the "n choose k"). */
+/** Binomial coefficient, alias of nCr (the "n choose k"). */
 declare const binomial: typeof nCr;
 /** Arrangements of a multiset: n! / (k1! k2! …), where Σki = n. */
 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). */
 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. */
+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). */
+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. */
+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. */
+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.) */
+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). */
+declare function multichoose(n: number, k: number): number;
+declare const combinationsWithRepetition: typeof multichoose;
 declare function gcd(a: number, b: number): number;
 declare function lcm(a: number, b: number): number;
 //#endregion
-export { binomial, factorial, gcd, lcm, multinomial, nCr, nPr, starsAndBars };
+export { binomial, cartesianProduct, circularPermutations, combinationsWithRepetition, factorial, gcd, lcm, multichoose, multinomial, nCr, nPr, permutationsWithRepetition, ruleOfProduct, ruleOfSum, starsAndBars };

package/dist/discrete/core/combinatorics.mjs

@@ -1,6 +1,6 @@
 //#region src/discrete/core/combinatorics.ts
 /**
-* Combinatorics kernel — the counting source-of-truth every discrete-math lab
+* 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").
@@ -28,7 +28,7 @@ function nCr(n, r) {
 	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"). */
+/** 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) {
@@ -42,6 +42,46 @@ 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);
@@ -54,4 +94,4 @@ function lcm(a, b) {
 }
 
 //#endregion
-export { binomial, factorial, gcd, lcm, multinomial, nCr, nPr, starsAndBars };
+export { binomial, cartesianProduct, circularPermutations, combinationsWithRepetition, factorial, gcd, lcm, multichoose, multinomial, nCr, nPr, permutationsWithRepetition, ruleOfProduct, ruleOfSum, starsAndBars };

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

@@ -1,6 +1,6 @@
 //#region src/discrete/core/pigeonhole.d.ts
 /**
- * Pigeonhole kernel — the certainty math behind "guarantee ≠ likely". With more
+ * Pigeonhole kernel, the certainty math behind "guarantee ≠ likely". With more
  * pigeons than holes some hole holds ≥ ⌈n/k⌉. The lab's adversary deals the
  * worst case; these functions say exactly when a collision is FORCED.
  */

package/dist/discrete/core/pigeonhole.mjs

@@ -1,6 +1,6 @@
 //#region src/discrete/core/pigeonhole.ts
 /**
-* Pigeonhole kernel — the certainty math behind "guarantee ≠ likely". With more
+* Pigeonhole kernel, the certainty math behind "guarantee ≠ likely". With more
 * pigeons than holes some hole holds ≥ ⌈n/k⌉. The lab's adversary deals the
 * worst case; these functions say exactly when a collision is FORCED.
 */

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

@@ -1,6 +1,6 @@
 //#region src/discrete/core/probability.d.ts
 /**
- * Probability kernel — equally-likely sample spaces, conditioning, Bayes,
+ * 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|.
@@ -8,7 +8,7 @@
 /** Favourable / total over an equally-likely space. */
 declare function probability(favorable: number, total: number): number;
 declare function complement(p: number): number;
-/** P(A|B) = P(A∩B) / P(B) — restrict the world to B, then re-count. */
+/** P(A|B) = P(A∩B) / P(B), restrict the world to B, then re-count. */
 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),
@@ -16,7 +16,7 @@ declare function conditional(pAandB: number, pB: number): number;
  */
 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. */
+ *  disjoint, disjoint events are maximally DEPENDENT. */
 declare function independent(pA: number, pB: number, pAandB: number, eps?: number): boolean;
 /** Expected value Σ p·value (probabilities should sum to 1). */
 declare function expectedValue(outcomes: ReadonlyArray<{

package/dist/discrete/core/probability.mjs

@@ -1,6 +1,6 @@
 //#region src/discrete/core/probability.ts
 /**
-* Probability kernel — equally-likely sample spaces, conditioning, Bayes,
+* 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|.
@@ -12,7 +12,7 @@ function probability(favorable, total) {
 function complement(p) {
 	return 1 - p;
 }
-/** P(A|B) = P(A∩B) / P(B) — restrict the world to B, then re-count. */
+/** 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;
 }
@@ -26,7 +26,7 @@ function bayes(pBgivenA, pA, pBgivenNotA) {
 	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. */
+*  disjoint, disjoint events are maximally DEPENDENT. */
 function independent(pA, pB, pAandB, eps = 1e-9) {
 	return Math.abs(pAandB - pA * pB) <= eps;
 }

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

@@ -1,6 +1,6 @@
 //#region src/discrete/core/sets.d.ts
 /**
- * Finite-set kernel — set algebra over arrays of primitives (the Venn /
+ * Finite-set kernel, set algebra over arrays of primitives (the Venn /
  * inclusion–exclusion labs run on these). De Morgan here mirrors the logic
  * kernel's De Morgan: ∩↔∧, ∪↔∨, complement↔¬ (the "trinity" spine). Order is
  * first-seen (insertion) and duplicates are collapsed, so results are clean sets.