@classytic/labs 0.1.0

package/dist/blocks/statistics.d.mts

@@ -0,0 +1,29 @@
+import { CenterSpreadLab } from "../statistics/center-spread/preset.mjs";
+import { SequenceLab } from "../statistics/sequence/preset.mjs";
+import { GaltonBoardLab } from "../statistics/galton/preset.mjs";
+import { HistogramBoxLab } from "../statistics/histogram/preset.mjs";
+import { NormalDistributionLab } from "../statistics/normal/preset.mjs";
+import { ZTableLab } from "../statistics/z-table/preset.mjs";
+import { SamplingDistributionLab } from "../statistics/sampling/preset.mjs";
+import { z } from "zod";
+
+//#region src/blocks/statistics.d.ts
+declare const CenterSpreadBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const SeriesBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const GaltonBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const HistogramBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const NormalBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const ZTableBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const SamplingBlock: import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+declare const statisticsBlocks: readonly [import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, import("@classytic/cms-ui/contract").CmsBlock<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>];
+declare const statisticsComponents: {
+  readonly CenterSpread: typeof CenterSpreadLab;
+  readonly Series: typeof SequenceLab;
+  readonly GaltonBoard: typeof GaltonBoardLab;
+  readonly HistogramBox: typeof HistogramBoxLab;
+  readonly NormalDistribution: typeof NormalDistributionLab;
+  readonly ZTable: typeof ZTableLab;
+  readonly SamplingDistribution: typeof SamplingDistributionLab;
+};
+//#endregion
+export { CenterSpreadBlock, GaltonBlock, HistogramBlock, NormalBlock, SamplingBlock, SeriesBlock, ZTableBlock, statisticsBlocks, statisticsComponents };

package/dist/blocks/statistics.mjs

@@ -0,0 +1,123 @@
+import { CenterSpreadLab } from "../statistics/center-spread/preset.mjs";
+import { SequenceLab } from "../statistics/sequence/preset.mjs";
+import { GaltonBoardLab } from "../statistics/galton/preset.mjs";
+import { HistogramBoxLab } from "../statistics/histogram/preset.mjs";
+import { NormalDistributionLab } from "../statistics/normal/preset.mjs";
+import { ZTableLab } from "../statistics/z-table/preset.mjs";
+import { SamplingDistributionLab } from "../statistics/sampling/preset.mjs";
+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/statistics.tsx
+const common = {
+	title: z.string().optional(),
+	prompt: z.string().optional(),
+	objectives: z.array(z.string()).optional(),
+	hints: z.array(z.string()).optional(),
+	controlId: z.string().optional()
+};
+function lab(key, tag, label, description, schema, Comp) {
+	return defineBlock({
+		key,
+		tag,
+		void: true,
+		label,
+		description,
+		category: "interactive",
+		schema,
+		Component: ({ attributes, mode, updateAttributes }) => {
+			const widget = Comp(attributes);
+			if (mode !== "editing" || !updateAttributes) return widget;
+			return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(LabConfig, {
+				schema,
+				value: attributes,
+				onChange: updateAttributes
+			}), widget] });
+		}
+	});
+}
+const centerSchema = z.object({
+	data: z.array(z.number()).optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	step: z.number().optional(),
+	showSigma: z.boolean().optional(),
+	challenge: z.object({
+		stat: z.enum(["mean", "median"]),
+		target: z.number()
+	}).optional(),
+	...common
+});
+const CenterSpreadBlock = lab("center-spread", "CenterSpread", "Centre & spread (mean as balance point)", "Drag data points on a number line: the mean rides as a balance-point fulcrum, the median holds, the mode lights up, and a σ band breathes. Outliers move the mean, not the median.", centerSchema, (a) => /* @__PURE__ */ jsx(CenterSpreadLab, { ...a }));
+const seqSchema = z.object({
+	kind: z.enum(["arithmetic", "geometric"]).optional(),
+	first: z.number().optional(),
+	step: z.number().optional(),
+	count: z.number().optional(),
+	...common
+});
+const SeriesBlock = lab("series", "Series", "Sequences & series", "Arithmetic / geometric sequences as bars with a running-total line; for |r|<1 the total converges onto the dashed S∞ guide.", seqSchema, (a) => /* @__PURE__ */ jsx(SequenceLab, { ...a }));
+const galtonSchema = z.object({
+	rows: z.number().optional(),
+	seed: z.number().optional(),
+	showCurve: z.boolean().optional(),
+	...common
+});
+const GaltonBlock = lab("galton", "GaltonBoard", "Galton board (central limit theorem)", "Balls bounce through pegs (each a coin-flip) and pile into a bell curve hugging the theoretical normal — the CLT made visible.", galtonSchema, (a) => /* @__PURE__ */ jsx(GaltonBoardLab, { ...a }));
+const histoSchema = z.object({
+	data: z.array(z.number()).optional(),
+	bins: z.number().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	...common
+});
+const HistogramBlock = lab("histogram", "HistogramBox", "Histogram & box plot", "The shape of data: a binned histogram + a box-and-whisker on a shared axis. Click to drop points; symmetric/skewed/bimodal presets; outliers beyond 1.5·IQR.", histoSchema, (a) => /* @__PURE__ */ jsx(HistogramBoxLab, { ...a }));
+const normalSchema = z.object({
+	mu: z.number().optional(),
+	sigma: z.number().optional(),
+	a: z.number().optional(),
+	b: z.number().optional(),
+	mode: z.enum(["area", "rule"]).optional(),
+	...common
+});
+const NormalBlock = lab("normal", "NormalDistribution", "Normal curve, area & z-scores", "Drag the shaded bounds → P(a≤X≤b) as area, with z-scores; or the 68-95-99.7 rule view. Slide μ and σ to reshape it.", normalSchema, (a) => /* @__PURE__ */ jsx(NormalDistributionLab, { ...a }));
+const ztableSchema = z.object({
+	x: z.number().optional(),
+	mu: z.number().optional(),
+	sigma: z.number().optional(),
+	tail: z.enum(["left", "right"]).optional(),
+	...common
+});
+const ZTableBlock = lab("z-table", "ZTable", "z-table (standardize & look up)", "Standardize x → z, and the live Φ(z) grid highlights the row/column/cell (auto-scrolled) while a mini curve shades the tail. Negative z via symmetry.", ztableSchema, (a) => /* @__PURE__ */ jsx(ZTableLab, { ...a }));
+const samplingSchema = z.object({
+	mu: z.number().optional(),
+	sigma: z.number().optional(),
+	n: z.number().optional(),
+	confidence: z.number().optional(),
+	mode: z.enum(["sampling", "ci"]).optional(),
+	...common
+});
+const SamplingBlock = lab("sampling", "SamplingDistribution", "Sampling distribution & confidence intervals", "Stack confidence intervals → ~C% capture μ (what \"95% confident\" means), or watch sample means pile into Normal(μ, σ/√n).", samplingSchema, (a) => /* @__PURE__ */ jsx(SamplingDistributionLab, { ...a }));
+const statisticsBlocks = [
+	CenterSpreadBlock,
+	SeriesBlock,
+	GaltonBlock,
+	HistogramBlock,
+	NormalBlock,
+	ZTableBlock,
+	SamplingBlock
+];
+const statisticsComponents = {
+	CenterSpread: CenterSpreadLab,
+	Series: SequenceLab,
+	GaltonBoard: GaltonBoardLab,
+	HistogramBox: HistogramBoxLab,
+	NormalDistribution: NormalDistributionLab,
+	ZTable: ZTableLab,
+	SamplingDistribution: SamplingDistributionLab
+};
+
+//#endregion
+export { CenterSpreadBlock, GaltonBlock, HistogramBlock, NormalBlock, SamplingBlock, SeriesBlock, ZTableBlock, statisticsBlocks, statisticsComponents };

package/dist/catalog/index.d.mts

@@ -0,0 +1,3 @@
+import { registerBuiltinTemplates } from "./templates.mjs";
+import { LabTemplate, getLabTemplate, instantiateTemplate, listLabTemplates, listLabTemplatesByCategory, registerLabTemplate } from "./registry.mjs";
+export { type LabTemplate, getLabTemplate, instantiateTemplate, listLabTemplates, listLabTemplatesByCategory, registerBuiltinTemplates, registerLabTemplate };

package/dist/catalog/index.mjs

@@ -0,0 +1,8 @@
+import { getLabTemplate, instantiateTemplate, listLabTemplates, listLabTemplatesByCategory, registerLabTemplate } from "./registry.mjs";
+import { registerBuiltinTemplates } from "./templates.mjs";
+
+//#region src/catalog/index.ts
+registerBuiltinTemplates();
+
+//#endregion
+export { getLabTemplate, instantiateTemplate, listLabTemplates, listLabTemplatesByCategory, registerBuiltinTemplates, registerLabTemplate };

package/dist/catalog/registry.d.mts

@@ -0,0 +1,46 @@
+import { LabMeta, SceneDoc } from "@classytic/stage";
+import { ZodTypeAny } from "zod";
+
+//#region src/catalog/registry.d.ts
+interface LabTemplate {
+  /** Stable id, kebab-case (e.g. 'balance-algebra'). */
+  id: string;
+  /** Human title for the catalog. */
+  title: string;
+  /** Domain bucket — 'algebra' | 'calculus' | 'physics' | 'circuits' | … */
+  category: string;
+  /** One-line description for the catalog card. */
+  description?: string;
+  /** Zod schema validating the creator-facing params (optional). */
+  paramsSchema?: ZodTypeAny;
+  /** Params used when a creator first inserts the template. */
+  defaultParams: Record<string, unknown>;
+  /** Params → a portable SceneDoc (the asset self-registers on factory import). */
+  factory: (params: Record<string, unknown>) => SceneDoc;
+  /** Default pedagogy carried into the SceneDoc.meta. */
+  pedagogy?: LabMeta;
+}
+declare function registerLabTemplate(t: LabTemplate): void;
+declare function listLabTemplates(): LabTemplate[];
+declare function listLabTemplatesByCategory(category: string): LabTemplate[];
+declare function getLabTemplate(id: string): LabTemplate | undefined;
+/** Result of instantiating a template — typed errors before a bad scene is built. */
+type InstantiateResult = {
+  ok: true;
+  doc: SceneDoc;
+} | {
+  ok: false;
+  error: string;
+  issues?: {
+    path: string;
+    message: string;
+  }[];
+};
+/**
+ * Validate params against the family's `paramsSchema` (zod), then build the
+ * SceneDoc. Returns typed errors so a marketplace/authoring UI can surface bad
+ * input WITHOUT producing a broken scene.
+ */
+declare function instantiateTemplate(id: string, params?: Record<string, unknown>): InstantiateResult;
+//#endregion
+export { LabTemplate, getLabTemplate, instantiateTemplate, listLabTemplates, listLabTemplatesByCategory, registerLabTemplate };

package/dist/catalog/registry.mjs

@@ -0,0 +1,56 @@
+//#region src/catalog/registry.ts
+const TEMPLATES = /* @__PURE__ */ new Map();
+function registerLabTemplate(t) {
+	TEMPLATES.set(t.id, t);
+}
+function listLabTemplates() {
+	return [...TEMPLATES.values()];
+}
+function listLabTemplatesByCategory(category) {
+	return listLabTemplates().filter((t) => t.category === category);
+}
+function getLabTemplate(id) {
+	return TEMPLATES.get(id);
+}
+/**
+* Validate params against the family's `paramsSchema` (zod), then build the
+* SceneDoc. Returns typed errors so a marketplace/authoring UI can surface bad
+* input WITHOUT producing a broken scene.
+*/
+function instantiateTemplate(id, params) {
+	const t = TEMPLATES.get(id);
+	if (!t) return {
+		ok: false,
+		error: `Unknown template: ${id}`
+	};
+	const merged = {
+		...t.defaultParams,
+		...params ?? {}
+	};
+	if (t.paramsSchema) {
+		const parsed = t.paramsSchema.safeParse(merged);
+		if (!parsed.success) {
+			const issues = parsed.error.issues.map((i) => ({
+				path: i.path.join("."),
+				message: i.message
+			}));
+			return {
+				ok: false,
+				error: `Invalid params for "${id}": ${issues.map((i) => `${i.path || "(root)"} ${i.message}`).join("; ")}`,
+				issues
+			};
+		}
+	}
+	const doc = t.factory(merged);
+	if (t.pedagogy && !doc.meta?.pedagogy) doc.meta = {
+		...doc.meta,
+		pedagogy: t.pedagogy
+	};
+	return {
+		ok: true,
+		doc
+	};
+}
+
+//#endregion
+export { getLabTemplate, instantiateTemplate, listLabTemplates, listLabTemplatesByCategory, registerLabTemplate };

package/dist/catalog/templates.d.mts

@@ -0,0 +1,11 @@
+//#region src/catalog/templates.d.ts
+/**
+ * Register the built-in lab families. Importing this module imports each
+ * preset's doc factory — which self-registers its stage asset — and adds the
+ * family to the registry. New family = add one entry here.
+ */
+/** Register all built-in families. Called from the catalog entry (a used import
+ *  so the registrations are never tree-shaken). Idempotent. */
+declare function registerBuiltinTemplates(): void;
+//#endregion
+export { registerBuiltinTemplates };

package/dist/catalog/templates.mjs

@@ -0,0 +1,141 @@
+import { leverBalanceDoc } from "../physics/lever/preset.mjs";
+import { opticsDoc } from "../physics/optics/preset.mjs";
+import { areaModelDoc } from "../math/area-model/preset.mjs";
+import { growingPatternDoc } from "../math/pattern/preset.mjs";
+import { mysteryBucketDoc } from "../math/mystery-bucket/preset.mjs";
+import { balanceAlgebraDoc } from "../math/balance-algebra/preset.mjs";
+import { circuitDoc } from "../circuits/circuit/preset.mjs";
+import { registerLabTemplate } from "./registry.mjs";
+import { z } from "zod";
+
+//#region src/catalog/templates.ts
+/**
+* Register the built-in lab families. Importing this module imports each
+* preset's doc factory — which self-registers its stage asset — and adds the
+* family to the registry. New family = add one entry here.
+*/
+/** Register all built-in families. Called from the catalog entry (a used import
+*  so the registrations are never tree-shaken). Idempotent. */
+function registerBuiltinTemplates() {
+	registerLabTemplate({
+		id: "mystery-bucket",
+		title: "Mystery bucket (weigh the unknown)",
+		category: "algebra",
+		description: "Add unit weights until a balance is level — discover the hidden weight (the unknown) with no symbols. The essentials opener.",
+		paramsSchema: z.object({
+			bucketWeight: z.number(),
+			maxWeights: z.number().optional()
+		}),
+		defaultParams: {
+			bucketWeight: 5,
+			maxWeights: 10
+		},
+		factory: (p) => mysteryBucketDoc({
+			bucketWeight: p.bucketWeight ?? 5,
+			count: 0,
+			maxWeights: p.maxWeights
+		})
+	});
+	registerLabTemplate({
+		id: "balance-algebra",
+		title: "Balance scale (algebra)",
+		category: "algebra",
+		description: "Solve a·x + b = c by keeping a scale balanced.",
+		paramsSchema: z.object({
+			coef: z.number(),
+			addend: z.number(),
+			rhs: z.number(),
+			answer: z.number()
+		}),
+		defaultParams: {
+			coef: 2,
+			addend: 1,
+			rhs: 7,
+			answer: 3
+		},
+		factory: (p) => balanceAlgebraDoc(p)
+	});
+	registerLabTemplate({
+		id: "area-model",
+		title: "Area model (algebra tiles)",
+		category: "algebra",
+		description: "(x+a)(x+b) as a partitioned rectangle — expand or factor.",
+		paramsSchema: z.object({
+			a: z.number(),
+			b: z.number(),
+			mode: z.enum(["expand", "factor"]).optional()
+		}),
+		defaultParams: {
+			a: 3,
+			b: 2,
+			mode: "expand"
+		},
+		factory: (p) => areaModelDoc(p)
+	});
+	registerLabTemplate({
+		id: "growing-pattern",
+		title: "Pattern → formula",
+		category: "algebra",
+		description: "Find the rule a·n + b from a growing figure.",
+		paramsSchema: z.object({
+			a: z.number(),
+			b: z.number(),
+			steps: z.number().optional()
+		}),
+		defaultParams: {
+			a: 2,
+			b: 3,
+			steps: 4
+		},
+		factory: (p) => growingPatternDoc(p)
+	});
+	registerLabTemplate({
+		id: "balance-lever",
+		title: "Lever / torque",
+		category: "physics",
+		description: "Balance the mobile — set the unknown weight so Σ(w·d) matches.",
+		paramsSchema: z.object({
+			items: z.array(z.unknown()).optional(),
+			start: z.number().optional(),
+			maxWeight: z.number().optional()
+		}),
+		defaultParams: {
+			start: 1,
+			maxWeight: 12
+		},
+		factory: (p) => leverBalanceDoc(p)
+	});
+	registerLabTemplate({
+		id: "optics",
+		title: "Optics — reflection",
+		category: "physics",
+		description: "Reflect a light ray off mirrors into the target.",
+		defaultParams: {},
+		factory: () => opticsDoc()
+	});
+	registerLabTemplate({
+		id: "circuit",
+		title: "Circuit",
+		category: "circuits",
+		description: "Battery + series/parallel branches — light the bulb.",
+		paramsSchema: z.object({
+			emf: z.number().optional(),
+			branches: z.array(z.unknown()).optional()
+		}),
+		defaultParams: {
+			emf: 6,
+			branches: [[{
+				type: "switch",
+				closed: false
+			}, {
+				type: "bulb",
+				ohms: 6
+			}]],
+			goal: { kind: "lightBulb" }
+		},
+		factory: (p) => circuitDoc(p)
+	});
+}
+
+//#endregion
+export { registerBuiltinTemplates };

package/dist/chem/battery.d.mts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+
+//#region src/chem/battery.d.ts
+interface BatteryProps {
+  /** Cell EMF in volts (Zn–Cu Daniell ≈ 1.10). */
+  emf?: number | string;
+  title?: string;
+  height?: number;
+}
+declare function Battery({
+  emf,
+  title,
+  height
+}?: BatteryProps): ReactNode;
+//#endregion
+export { Battery, BatteryProps };