@classytic/labs 0.1.0

package/dist/core/rng.d.mts

@@ -0,0 +1,21 @@
+//#region src/core/rng.d.ts
+/**
+ * Seeded PRNG — deterministic randomness so a simulation is REPLAYABLE (same
+ * seed → same run; an agent can pin a seed, a lesson reproduces exactly, SSR /
+ * Remotion stays stable). mulberry32: tiny, fast, good enough for teaching. This
+ * is the canonical home (generic numerics live in core, per the shared-math rule);
+ * discrete/core re-exports it for back-compat. NEVER use Math.random in a lab.
+ */
+type Rng = () => number;
+/** A PRNG returning [0,1). Same seed → same sequence. */
+declare function mulberry32(seed: number): Rng;
+/** Integer in [lo, hi] inclusive. */
+declare function randInt(rng: Rng, lo: number, hi: number): number;
+/** Fisher–Yates shuffle (new array; does not mutate input). */
+declare function shuffle<T>(arr: readonly T[], rng: Rng): T[];
+/** Sample `k` distinct items (without replacement). */
+declare function sample<T>(arr: readonly T[], k: number, rng: Rng): T[];
+/** A normal (Gaussian) variate via Box–Muller — for sampling-distribution sims. */
+declare function gaussian(rng: Rng, mu?: number, sigma?: number): number;
+//#endregion
+export { Rng, gaussian, mulberry32, randInt, sample, shuffle };

package/dist/core/rng.mjs

@@ -0,0 +1,39 @@
+//#region src/core/rng.ts
+/** A PRNG returning [0,1). Same seed → same sequence. */
+function mulberry32(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a |= 0;
+		a = a + 1831565813 | 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Integer in [lo, hi] inclusive. */
+function randInt(rng, lo, hi) {
+	return lo + Math.floor(rng() * (hi - lo + 1));
+}
+/** Fisher–Yates shuffle (new array; does not mutate input). */
+function shuffle(arr, rng) {
+	const a = arr.slice();
+	for (let i = a.length - 1; i > 0; i--) {
+		const j = Math.floor(rng() * (i + 1));
+		[a[i], a[j]] = [a[j], a[i]];
+	}
+	return a;
+}
+/** Sample `k` distinct items (without replacement). */
+function sample(arr, k, rng) {
+	return shuffle(arr, rng).slice(0, Math.max(0, Math.min(k, arr.length)));
+}
+/** A normal (Gaussian) variate via Box–Muller — for sampling-distribution sims. */
+function gaussian(rng, mu = 0, sigma = 1) {
+	let u = 0, v = 0;
+	while (u === 0) u = rng();
+	while (v === 0) v = rng();
+	return mu + sigma * Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+
+//#endregion
+export { gaussian, mulberry32, randInt, sample, shuffle };

package/dist/core/tex.d.mts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+
+//#region src/core/tex.d.ts
+declare function Tex({
+  tex,
+  block,
+  className
+}: {
+  tex: string;
+  block?: boolean;
+  className?: string;
+}): ReactNode;
+//#endregion
+export { Tex };

package/dist/core/tex.mjs

@@ -0,0 +1,44 @@
+'use client';
+
+import katex from "katex";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/core/tex.tsx
+/**
+* Tex — render a LaTeX string with KaTeX AT RENDER TIME, so the markup is
+* identical on the server and client: SSR/static exports show real maths (not raw
+* `\cdot`/`\dfrac`), there's no raw-then-hydrate flash, and hydration matches.
+*
+* `katex` is a static import kept in this OWN module — stage/labs `neverBundle`
+* leave it external, so only `<Tex>` importers pull it (the consumer resolves the
+* optional peer; non-Tex consumers never bundle it). If `renderToString` throws on
+* a malformed string we fall back to the raw LaTeX in a `<code>`. Pair with
+* `toLatex(ast)` from the expr engine to show equations/derivatives beautifully.
+*
+* The consumer must import KaTeX's stylesheet once for correct glyphs:
+*   import 'katex/dist/katex.min.css';
+*/
+function Tex({ tex, block = false, className }) {
+	const html = useMemo(() => {
+		try {
+			return katex.renderToString(tex, {
+				displayMode: block,
+				throwOnError: false
+			});
+		} catch {
+			return null;
+		}
+	}, [tex, block]);
+	if (html == null) return /* @__PURE__ */ jsx("code", {
+		className,
+		children: tex
+	});
+	return /* @__PURE__ */ jsx("span", {
+		className,
+		dangerouslySetInnerHTML: { __html: html }
+	});
+}
+
+//#endregion
+export { Tex };

package/dist/core/timeline.d.mts

@@ -0,0 +1,34 @@
+import { Easing } from "./easing.mjs";
+
+//#region src/core/timeline.d.ts
+interface TweenOptions {
+  from?: number;
+  to: number;
+  durationMs?: number;
+  ease?: Easing;
+  autoplay?: boolean;
+  loop?: boolean | 'pingpong';
+}
+interface TweenState {
+  value: number;
+  progress: number;
+  playing: boolean;
+  play: () => void;
+  pause: () => void;
+  reset: () => void;
+}
+declare function useTween(opts: TweenOptions): TweenState;
+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`.
+ */
+declare function keyframes(frames: Keyframe[]): (t: number) => number;
+//#endregion
+export { Keyframe, TweenOptions, TweenState, keyframes, useTween };

package/dist/core/timeline.mjs

@@ -0,0 +1,77 @@
+'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 });
+	return {
+		value: lerp(from, to, ease(clamp(progress, 0, 1))),
+		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/core/util.d.mts

@@ -0,0 +1,19 @@
+import { ClassValue } from "clsx";
+
+//#region src/core/util.d.ts
+/** Tailwind-aware class merge (clsx + tailwind-merge). */
+declare function cn(...inputs: ClassValue[]): string;
+/** Coerce an unknown (e.g. an MDX string attribute) to a finite number, or a fallback. */
+declare function num(v: unknown, fallback: number): number;
+declare const clamp: (v: number, lo: number, hi: number) => number;
+declare const lerp: (a: number, b: number, t: number) => number;
+/** Degrees → radians. */
+declare const toRad: (deg: number) => number;
+/** Radians → degrees. */
+declare const toDeg: (rad: number) => number;
+/** Are two numbers equal within a tolerance (default 1e-6)? */
+declare const approxEq: (a: number, b: number, eps?: number) => boolean;
+/** Map x from [inMin,inMax] to [outMin,outMax], optionally clamped. */
+declare function remap(x: number, inMin: number, inMax: number, outMin: number, outMax: number, doClamp?: boolean): number;
+//#endregion
+export { approxEq, clamp, cn, lerp, num, remap, toDeg, toRad };

package/dist/core/util.mjs

@@ -0,0 +1,31 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+//#region src/core/util.ts
+/** Tailwind-aware class merge (clsx + tailwind-merge). */
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+/** Coerce an unknown (e.g. an MDX string attribute) to a finite number, or a fallback. */
+function num(v, fallback) {
+	const n = typeof v === "number" ? v : Number.parseFloat(String(v ?? ""));
+	return Number.isFinite(n) ? n : fallback;
+}
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+const lerp = (a, b, t) => a + (b - a) * t;
+const DEG = Math.PI / 180;
+/** Degrees → radians. */
+const toRad = (deg) => deg * DEG;
+/** Radians → degrees. */
+const toDeg = (rad) => rad / DEG;
+/** Are two numbers equal within a tolerance (default 1e-6)? */
+const approxEq = (a, b, eps = 1e-6) => Math.abs(a - b) <= eps;
+/** Map x from [inMin,inMax] to [outMin,outMax], optionally clamped. */
+function remap(x, inMin, inMax, outMin, outMax, doClamp = false) {
+	const t = inMax === inMin ? 0 : (x - inMin) / (inMax - inMin);
+	const v = outMin + (outMax - outMin) * t;
+	return doClamp ? clamp(v, Math.min(outMin, outMax), Math.max(outMin, outMax)) : v;
+}
+
+//#endregion
+export { approxEq, clamp, cn, lerp, num, remap, toDeg, toRad };

package/dist/discrete/arrangements/preset.d.mts

@@ -0,0 +1,28 @@
+import { ReactNode } from "react";
+
+//#region src/discrete/arrangements/preset.d.ts
+interface ArrangeItem {
+  label: string;
+  count: number;
+  color?: string;
+}
+interface ArrangementsProps {
+  word?: string;
+  items?: ArrangeItem[];
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  hints?: string[];
+  controlId?: string;
+}
+declare function ArrangementsLab({
+  word,
+  items,
+  title,
+  prompt,
+  objectives,
+  hints: hintList,
+  controlId
+}: ArrangementsProps): ReactNode;
+//#endregion
+export { ArrangeItem, ArrangementsLab, ArrangementsProps };

package/dist/discrete/arrangements/preset.mjs

@@ -0,0 +1,304 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { CheckButton, Chip, StatusPill, Stepper } from "../../kit/controls.mjs";
+import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { HintLadder, RevealSolution, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
+import { factorial, multinomial } from "../core/combinatorics.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useControlSurface } from "@classytic/stage";
+
+//#region src/discrete/arrangements/preset.tsx
+/**
+* ArrangementsLab — arranging things in a row when some are IDENTICAL (the multiset
+* permutation the slots/selection labs don't cover). The classic MISSISSIPPI, or a
+* row of coloured beads. The derivation, made concrete: if all n were distinct
+* there'd be n! orders; but swapping two identical letters gives the SAME word, so
+* each real arrangement is counted (count of that letter)! times — divide it out:
+*
+*   n! / (n₁! · n₂! · …)        (the multinomial coefficient)
+*
+* You watch two identical tiles swap into the same row (the overcount), then the
+* formula falls out. Predict-then-check. Kernel = factorial / multinomial.
+*/
+const PALETTE = [
+	"#1c7ed6",
+	"#e8590c",
+	"#2f9e44",
+	"#9c36b5",
+	"#e03131",
+	"#0ca678",
+	"#f59f00",
+	"#1098ad"
+];
+function fromWord(w) {
+	const order = [], m = /* @__PURE__ */ new Map();
+	for (const ch of w.toUpperCase()) {
+		if (!/[A-Z]/.test(ch)) continue;
+		if (!m.has(ch)) order.push(ch);
+		m.set(ch, (m.get(ch) ?? 0) + 1);
+	}
+	return order.map((l) => ({
+		label: l,
+		count: m.get(l)
+	}));
+}
+function ArrangementsLab({ word, items, title = "Arrange with repeats", prompt, objectives, hints: hintList, controlId }) {
+	const base = useMemo(() => items ?? (word ? fromWord(word) : fromWord("MISSISSIPPI")), [items, word]);
+	const [counts, setCounts] = useState(base.map((g) => g.count));
+	const [guess, setGuess] = useState(0);
+	const [checked, setChecked] = useState(false);
+	const [peeked, setPeeked] = useState(false);
+	const hints = useHints(hintList);
+	const live = base.map((g, i) => ({
+		...g,
+		count: counts[i],
+		color: g.color ?? PALETTE[i % PALETTE.length]
+	})).filter((g) => g.count > 0);
+	const n = live.reduce((a, g) => a + g.count, 0);
+	const nFact = factorial(n);
+	const total = useMemo(() => n > 0 ? multinomial(...live.map((g) => g.count)) : 1, [counts]);
+	const repeats = live.filter((g) => g.count > 1);
+	const tiles = live.flatMap((g) => Array.from({ length: g.count }, () => g));
+	const swapGroup = repeats.slice().sort((a, b) => b.count - a.count)[0];
+	const setI = (i, v) => {
+		setChecked(false);
+		setCounts((c) => c.map((x, j) => j === i ? Math.max(0, Math.min(8, v)) : x));
+	};
+	const reset = () => {
+		setChecked(false);
+		setPeeked(false);
+		setGuess(0);
+		setCounts(base.map((g) => g.count));
+	};
+	const solved = checked && guess === total && !peeked;
+	useCheckpoint({
+		solved,
+		activity: `arrangements:${title}`,
+		hintsUsed: hints.count
+	});
+	useControlSurface(controlId, {
+		...Object.fromEntries(base.map((g, i) => [`count_${g.label}`, {
+			type: "number",
+			label: `# of ${g.label}`,
+			min: 0,
+			max: 8,
+			step: 1,
+			get: () => counts[i] ?? 0,
+			set: (v) => setI(i, v)
+		}])),
+		reveal: {
+			type: "action",
+			label: "reveal the count",
+			invoke: () => {
+				setPeeked(true);
+				setGuess(total);
+				setChecked(true);
+			}
+		},
+		reset: {
+			type: "action",
+			label: "reset",
+			invoke: reset
+		}
+	});
+	const figure = /* @__PURE__ */ jsxs("div", {
+		style: {
+			display: "grid",
+			gap: 16
+		},
+		children: [
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs("p", {
+				className: "lab-field-label",
+				children: [n, " items in a row — identical ones share a colour"]
+			}), /* @__PURE__ */ jsx("div", {
+				style: {
+					display: "flex",
+					gap: 4,
+					flexWrap: "wrap"
+				},
+				children: tiles.map((g, i) => {
+					const isSwap = swapGroup && g.label === swapGroup.label;
+					const swapIdx = isSwap ? tiles.filter((t, j) => j < i && t.label === g.label).length : -1;
+					const flag = isSwap && swapIdx < 2;
+					return /* @__PURE__ */ jsx("span", {
+						style: {
+							display: "inline-flex",
+							alignItems: "center",
+							justifyContent: "center",
+							width: 30,
+							height: 30,
+							borderRadius: 8,
+							fontWeight: 800,
+							fontSize: 15,
+							color: "white",
+							background: g.color,
+							boxShadow: flag ? "0 0 0 2px var(--stage-fg)" : "none"
+						},
+						children: g.label
+					}, i);
+				})
+			})] }),
+			swapGroup && /* @__PURE__ */ jsxs("p", {
+				className: "lab-prompt",
+				children: [
+					"Swap the two ringed ",
+					/* @__PURE__ */ jsx("b", {
+						style: { color: swapGroup.color },
+						children: swapGroup.label
+					}),
+					"'s ⇄ — it's the ",
+					/* @__PURE__ */ jsx("b", { children: "same row" }),
+					". So every arrangement is counted ",
+					swapGroup.count,
+					"! times over (once per ordering of the ",
+					swapGroup.count,
+					" ",
+					swapGroup.label,
+					"'s)."
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				style: {
+					padding: "10px 12px",
+					borderRadius: 10,
+					border: "1px dashed var(--stage-grid)",
+					fontSize: 15,
+					fontVariantNumeric: "tabular-nums",
+					display: "grid",
+					gap: 4
+				},
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						style: {
+							fontSize: 11,
+							fontWeight: 700,
+							color: "var(--stage-muted)"
+						},
+						children: "📐 WHY THE FORMULA"
+					}),
+					/* @__PURE__ */ jsxs("span", { children: [
+						"if all ",
+						n,
+						" were different: ",
+						/* @__PURE__ */ jsxs("b", { children: [n, "!"] }),
+						" = ",
+						nFact.toLocaleString(),
+						" orders"
+					] }),
+					repeats.length > 0 && /* @__PURE__ */ jsxs("span", { children: [
+						"but identical copies repeat: ",
+						/* @__PURE__ */ jsx(Tex$1, { tex: `\\div\\ ${repeats.map((g) => `${g.count}!`).join(" \\cdot ")}` }),
+						" ",
+						/* @__PURE__ */ jsxs("span", {
+							style: { color: "var(--stage-muted)" },
+							children: [
+								"(",
+								repeats.map((g) => `the ${g.count} ${g.label}'s`).join(", "),
+								")"
+							]
+						})
+					] }),
+					/* @__PURE__ */ jsxs("span", {
+						style: { fontWeight: 800 },
+						children: [
+							/* @__PURE__ */ jsx(Tex$1, { tex: `${n}! / (${live.map((g) => `${g.count}!`).join(" \\cdot ")}) = ${nFact.toLocaleString().replace(/,/g, "{,}")} / ${live.reduce((a, g) => a * factorial(g.count), 1).toLocaleString().replace(/,/g, "{,}")} =` }),
+							" ",
+							/* @__PURE__ */ jsx("span", {
+								style: { color: "var(--stage-good)" },
+								children: total.toLocaleString()
+							}),
+							" distinct arrangements"
+						]
+					})
+				]
+			})
+		]
+	});
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		aside: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs(Callout, {
+			tone: "result",
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					style: {
+						fontSize: 12,
+						color: "var(--stage-muted)",
+						fontWeight: 600
+					},
+					children: "distinct arrangements"
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "lab-callout-big",
+					children: total.toLocaleString()
+				}),
+				/* @__PURE__ */ jsx("span", {
+					style: {
+						fontSize: 12,
+						color: "var(--stage-muted)"
+					},
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `${n}! / ${live.map((g) => `${g.count}!`).join(" \\cdot ")}` })
+				})
+			]
+		}), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("p", {
+			className: "lab-prompt",
+			children: "🎯 How many distinct rows? Guess, then check."
+		}), /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(Field, {
+				label: "your answer",
+				children: /* @__PURE__ */ jsx(Stepper, {
+					value: guess,
+					onChange: (v) => {
+						setGuess(v);
+						setChecked(false);
+					},
+					min: 0,
+					max: Math.max(100, total)
+				})
+			}),
+			/* @__PURE__ */ jsx(CheckButton, {
+				onClick: () => setChecked(true),
+				children: "Check"
+			}),
+			checked && /* @__PURE__ */ jsx(StatusPill, {
+				ok: guess === total,
+				children: guess === total ? "✓ right!" : "not yet"
+			})
+		] })] })] }),
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [base.map((g, i) => /* @__PURE__ */ jsx(Field, {
+			label: `# ${g.label}`,
+			children: /* @__PURE__ */ jsx(Stepper, {
+				value: counts[i] ?? 0,
+				onChange: (v) => setI(i, v),
+				min: 0,
+				max: 8
+			})
+		}, g.label)), /* @__PURE__ */ jsx(Chip, {
+			selected: false,
+			onClick: reset,
+			children: "reset"
+		})] }),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(RevealSolution, {
+			available: !solved,
+			buttonLabel: "Show the count",
+			solution: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsx(Tex$1, { tex: `${n}! / (${live.map((g) => `${g.count}!`).join(" \\cdot ")}) =` }),
+				" ",
+				/* @__PURE__ */ jsx("b", { children: total.toLocaleString() }),
+				" distinct arrangements."
+			] }),
+			onReveal: () => {
+				setPeeked(true);
+				setGuess(total);
+				setChecked(true);
+			}
+		}), /* @__PURE__ */ jsx(HintLadder, { hints })] }),
+		children: figure
+	});
+}
+
+//#endregion
+export { ArrangementsLab };

package/dist/discrete/bayes/preset.d.mts

@@ -0,0 +1,33 @@
+import { ReactNode } from "react";
+
+//#region src/discrete/bayes/preset.d.ts
+interface BayesProps {
+  prior?: number;
+  sensitivity?: number;
+  falsePositive?: number;
+  population?: number;
+  conditionLabels?: [string, string];
+  testLabels?: [string, string];
+  predict?: boolean;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  hints?: string[];
+  controlId?: string;
+}
+declare function BayesLab({
+  prior,
+  sensitivity,
+  falsePositive,
+  population,
+  conditionLabels,
+  testLabels,
+  predict,
+  title,
+  prompt,
+  objectives,
+  hints: hintList,
+  controlId
+}: BayesProps): ReactNode;
+//#endregion
+export { BayesLab, BayesProps };