@classytic/labs 0.2.0 → 0.3.0

package/dist/domains/math/oblique-triangle/manifest.mjs

@@ -0,0 +1,67 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/oblique-triangle/manifest.ts
+var manifest_default = defineLab({
+	id: "oblique-triangle",
+	tag: "ObliqueTriangle",
+	domain: "math",
+	group: "Trigonometry",
+	title: "Sine rule, cosine rule and the ambiguous case",
+	description: "A triangle with no right angle, solved. Picks the rule from whether a matching pair is present, colours the given parts against the found ones, and draws BOTH triangles when two sides and a non-included angle admit two, with the swinging side that produces them.",
+	schema: z.object({
+		given: z.enum([
+			"sss",
+			"sas",
+			"aas",
+			"ssa"
+		]).optional().describe("which parts are given: sss and sas need the cosine rule, aas and ssa the sine rule"),
+		cases: z.array(z.enum([
+			"sss",
+			"sas",
+			"aas",
+			"ssa"
+		])).min(1).max(4).optional().describe("restrict the selector, for a lesson that teaches one rule at a time"),
+		...commonLabProps
+	}),
+	experience: {
+		objectives: [
+			"Choose between the sine and cosine rules by looking for a matching side and angle",
+			"Find a missing side or angle in a triangle with no right angle",
+			"Recognise when two sides and a non-included angle give two triangles, one, or none"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: [
+			"9",
+			"10",
+			"11"
+		],
+		outcomes: [
+			"trigonometry",
+			"sine-rule",
+			"cosine-rule"
+		],
+		durationMinutes: 12,
+		interaction: "explorer",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/oblique-triangle/runtime.mjs

@@ -0,0 +1,12 @@
+'use client';
+
+import { ObliqueTriangle } from "../../../math/oblique-triangle/preset.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/math/oblique-triangle/runtime.tsx
+function Runtime(p) {
+	return /* @__PURE__ */ jsx(ObliqueTriangle, { ...p });
+}
+
+//#endregion
+export { Runtime as default };

package/dist/domains/math/partial-fractions/manifest.mjs

@@ -0,0 +1,71 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/partial-fractions/manifest.ts
+const factor = z.union([z.object({
+	kind: z.literal("linear"),
+	a: z.number().finite(),
+	b: z.number().finite(),
+	power: z.number().int().min(1).max(3).optional()
+}), z.object({
+	kind: z.literal("quadratic"),
+	a: z.number().finite(),
+	b: z.number().finite(),
+	c: z.number().finite()
+})]);
+var manifest_default = defineLab({
+	id: "partial-fractions",
+	tag: "PartialFractions",
+	domain: "math",
+	group: "Algebra",
+	title: "Partial fractions (choose the form, then see it add up)",
+	description: "The graded decision is the SHAPE of the answer, made before any constant exists, so the menu offers the shapes people actually write wrongly. Once the form is right the constants are solved and the pieces are drawn separately, so the complicated original visibly appears out of simple ones.",
+	schema: z.object({
+		numerator: z.array(z.number().finite()).min(1).max(5).optional().describe("coefficients ascending: [1, 3] is 3x + 1"),
+		factors: z.array(factor).min(1).max(4).optional().describe("denominator factors; a quadratic must be irreducible, and the fraction proper"),
+		options: z.array(z.object({
+			id: z.string().trim().min(1).max(40),
+			tex: z.string().trim().min(1).max(240),
+			correct: z.boolean().optional(),
+			why: z.string().trim().min(1).max(300).optional()
+		})).min(2).max(5).optional().describe("candidate forms; mark exactly one correct and give every other one a reason"),
+		revealed: z.boolean().optional().describe("open with the form already chosen, for a lesson that only wants the graph"),
+		...commonLabProps
+	}),
+	experience: {
+		objectives: [
+			"Choose the correct form of a decomposition before finding any constant",
+			"Give a repeated factor a term at every power, and a quadratic a linear numerator",
+			"Check that the number of unknowns equals the degree of the denominator"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"algebra",
+			"partial-fractions",
+			"rational-functions"
+		],
+		durationMinutes: 12,
+		interaction: "guided",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/partial-fractions/runtime.mjs

@@ -0,0 +1,12 @@
+'use client';
+
+import { PartialFractions } from "../../../math/partial-fractions/preset.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/math/partial-fractions/runtime.tsx
+function Runtime(p) {
+	return /* @__PURE__ */ jsx(PartialFractions, { ...p });
+}
+
+//#endregion
+export { Runtime as default };

package/dist/domains/math/percent-bar/manifest.mjs

@@ -0,0 +1,66 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/percent-bar/manifest.ts
+var manifest_default = defineLab({
+	id: "percent-bar",
+	domain: "math",
+	group: "Math",
+	title: "Percentage bar",
+	description: "A bar is the whole (100%); drag the fill to a target percent and read both the percent and the amount (percent × whole). Author any analogy via whole + unit + an optional segment breakdown.",
+	schema: z.object({
+		whole: z.number().default(100),
+		unit: z.string().default(""),
+		target: z.number().optional(),
+		start: z.number().default(0),
+		snapPct: z.number().positive().default(5),
+		showValue: z.boolean().default(true),
+		referenceLabel: z.string().optional(),
+		segments: z.array(z.object({
+			frac: z.number().nonnegative(),
+			label: z.string().optional(),
+			color: z.string().optional()
+		})).optional(),
+		scene: z.string().default("none"),
+		height: z.number().min(180).max(640).optional(),
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		activity: z.string().optional()
+	}),
+	omit: ["activity"],
+	experience: {
+		objectives: [
+			"Interpret the full bar as one whole or 100 percent",
+			"Connect a percentage fill to its amount for an authored whole",
+			"Transfer percentage reasoning across segmented real-world contexts"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: [
+			"6",
+			"7",
+			"8"
+		],
+		outcomes: ["math", "percentages"],
+		durationMinutes: 8,
+		interaction: "explorer",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/percent-bar/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { PercentBarLab } from "../../../math/percent-bar/preset.mjs";
+
+export { PercentBarLab as default };

package/dist/domains/math/phase-portrait/authoring.mjs

@@ -0,0 +1,132 @@
+'use client';
+
+import { ConfigPanel, ConfigRow, NumField, TextField } from "../../../blocks/authoring.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/domains/math/phase-portrait/authoring.tsx
+function PhasePortraitAuthoring({ value, onChange }) {
+	const xRange = value.xRange ?? [-4, 4], yRange = value.yRange ?? [-4, 4], initial = value.initial ?? [3, 0];
+	const xInvalid = xRange[1] <= xRange[0], yInvalid = yRange[1] <= yRange[0];
+	return /* @__PURE__ */ jsxs(ConfigPanel, { children: [
+		/* @__PURE__ */ jsx(ConfigRow, {
+			label: "Title",
+			children: /* @__PURE__ */ jsx(TextField, {
+				value: value.title ?? "",
+				placeholder: "See a system evolve in state space",
+				onChange: (title) => onChange({ title }),
+				className: "flex-1"
+			})
+		}),
+		/* @__PURE__ */ jsx(ConfigRow, {
+			label: "dx/dt",
+			hint: "Expressions may use x, y, and t.",
+			children: /* @__PURE__ */ jsx(TextField, {
+				value: value.dx ?? "y",
+				mono: true,
+				onChange: (dx) => onChange({ dx }),
+				className: "flex-1"
+			})
+		}),
+		/* @__PURE__ */ jsx(ConfigRow, {
+			label: "dy/dt",
+			children: /* @__PURE__ */ jsx(TextField, {
+				value: value.dy ?? "-x - 0.25*y",
+				mono: true,
+				onChange: (dy) => onChange({ dy }),
+				className: "flex-1"
+			})
+		}),
+		/* @__PURE__ */ jsxs(ConfigRow, {
+			label: "x window",
+			error: xInvalid ? "Maximum must be greater than minimum." : void 0,
+			children: [
+				/* @__PURE__ */ jsx(NumField, {
+					value: xRange[0],
+					invalid: xInvalid,
+					onChange: (minimum) => onChange({ xRange: [minimum, xRange[1]] })
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "text-muted-foreground",
+					children: "to"
+				}),
+				/* @__PURE__ */ jsx(NumField, {
+					value: xRange[1],
+					invalid: xInvalid,
+					onChange: (maximum) => onChange({ xRange: [xRange[0], maximum] })
+				})
+			]
+		}),
+		/* @__PURE__ */ jsxs(ConfigRow, {
+			label: "y window",
+			error: yInvalid ? "Maximum must be greater than minimum." : void 0,
+			children: [
+				/* @__PURE__ */ jsx(NumField, {
+					value: yRange[0],
+					invalid: yInvalid,
+					onChange: (minimum) => onChange({ yRange: [minimum, yRange[1]] })
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "text-muted-foreground",
+					children: "to"
+				}),
+				/* @__PURE__ */ jsx(NumField, {
+					value: yRange[1],
+					invalid: yInvalid,
+					onChange: (maximum) => onChange({ yRange: [yRange[0], maximum] })
+				})
+			]
+		}),
+		/* @__PURE__ */ jsxs(ConfigRow, {
+			label: "Initial state",
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					className: "text-muted-foreground",
+					children: "x₀"
+				}),
+				/* @__PURE__ */ jsx(NumField, {
+					value: initial[0],
+					onChange: (x) => onChange({ initial: [x, initial[1]] })
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "text-muted-foreground",
+					children: "y₀"
+				}),
+				/* @__PURE__ */ jsx(NumField, {
+					value: initial[1],
+					onChange: (y) => onChange({ initial: [initial[0], y] })
+				})
+			]
+		}),
+		/* @__PURE__ */ jsxs(ConfigRow, {
+			label: "Trace",
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					className: "text-muted-foreground",
+					children: "duration"
+				}),
+				/* @__PURE__ */ jsx(NumField, {
+					value: value.duration ?? 10,
+					min: 1,
+					max: 40,
+					step: .5,
+					onChange: (duration) => onChange({ duration: clamp(duration, 1, 40) })
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "text-muted-foreground",
+					children: "step h"
+				}),
+				/* @__PURE__ */ jsx(NumField, {
+					value: value.stepSize ?? .16,
+					min: .02,
+					max: 1,
+					step: .02,
+					onChange: (stepSize) => onChange({ stepSize: clamp(stepSize, .02, 1) })
+				})
+			]
+		})
+	] });
+}
+const clamp = (value, minimum, maximum) => Math.min(maximum, Math.max(minimum, value));
+
+//#endregion
+export { PhasePortraitAuthoring as default };

package/dist/domains/math/phase-portrait/manifest.mjs

@@ -0,0 +1,64 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { calculusExpressionSchema, calculusRangeSchema } from "../schemas.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/phase-portrait/manifest.ts
+var manifest_default = defineLab({
+	id: "phase-portrait",
+	tag: "PhasePortrait",
+	domain: "math",
+	group: "Math",
+	title: "Phase portrait explorer",
+	description: "Explore author-defined two-variable dynamical systems through a vector field and guarded Euler/RK4 trajectories.",
+	schema: z.object({
+		dx: calculusExpressionSchema.optional(),
+		dy: calculusExpressionSchema.optional(),
+		xRange: calculusRangeSchema.optional(),
+		yRange: calculusRangeSchema.optional(),
+		initial: z.tuple([z.number().finite(), z.number().finite()]).optional(),
+		duration: z.number().finite().min(1).max(40).optional(),
+		stepSize: z.number().finite().min(.02).max(1).optional(),
+		title: z.string().optional()
+	}),
+	experience: {
+		objectives: [
+			"Read the direction of change from a two-variable vector field",
+			"Trace how an initial state evolves through phase space",
+			"Classify equilibria and long-run behavior from nearby trajectories"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"math",
+			"calculus",
+			"differential-equations",
+			"dynamical-systems",
+			"phase-portrait"
+		],
+		durationMinutes: 18,
+		interaction: "explorer",
+		authorability: "moderate",
+		representation: "graph",
+		prerequisites: ["differential-equation"],
+		related: ["gradient-descent", "harmonic-form"]
+	},
+	loadRuntime: () => import("./runtime.mjs"),
+	loadAuthoring: () => import("./authoring.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/phase-portrait/runtime.mjs

@@ -0,0 +1,21 @@
+'use client';
+
+import { PhasePortraitExplorer } from "../../../math/phase-portrait/preset.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/math/phase-portrait/runtime.tsx
+function PhasePortraitRuntime(attributes) {
+	return /* @__PURE__ */ jsx(PhasePortraitExplorer, {
+		dx: attributes.dx || "y",
+		dy: attributes.dy || "-x - 0.25*y",
+		xRange: attributes.xRange ?? [-4, 4],
+		yRange: attributes.yRange ?? [-4, 4],
+		initial: attributes.initial ?? [3, 0],
+		duration: attributes.duration,
+		stepSize: attributes.stepSize,
+		title: attributes.title ?? "See a system evolve in state space"
+	});
+}
+
+//#endregion
+export { PhasePortraitRuntime as default };

package/dist/domains/math/polynomial-solver/manifest.mjs

@@ -0,0 +1,57 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/polynomial-solver/manifest.ts
+var manifest_default = defineLab({
+	id: "polynomial-solver",
+	domain: "math",
+	group: "Math",
+	title: "Polynomial solver (factor / solve, step by step)",
+	description: "Type a polynomial in x; the engine factors it or solves =0 and shows the working (split the middle term; factor theorem for higher degree). Any-degree roots incl. complex, client-side.",
+	schema: z.object({
+		expr: z.string().default("x^2 + 5x + 6"),
+		mode: z.enum(["factor", "solve"]).default("factor"),
+		editable: z.boolean().default(true),
+		title: z.string().optional(),
+		prompt: z.string().optional()
+	}),
+	experience: {
+		objectives: [
+			"Predict factors or roots from polynomial structure",
+			"Follow valid algebraic steps from expression to factorization or solutions",
+			"Verify real and complex roots by substitution"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: [
+			"9",
+			"10",
+			"11"
+		],
+		outcomes: [
+			"math",
+			"algebra",
+			"polynomials"
+		],
+		durationMinutes: 12,
+		interaction: "explorer",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/polynomial-solver/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { PolynomialSolverLab } from "../../../math/poly/preset.mjs";
+
+export { PolynomialSolverLab as default };

package/dist/domains/math/radian-wrap/manifest.mjs

@@ -0,0 +1,56 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/radian-wrap/manifest.ts
+var manifest_default = defineLab({
+	id: "radian-wrap",
+	tag: "RadianWrap",
+	domain: "math",
+	group: "Trigonometry",
+	title: "The radian, measured by laying the radius along the rim",
+	description: "A radian is usually introduced as a conversion factor, which teaches the arithmetic and hides the idea. Here the learner lays the radius round the circumference one length at a time and counts: six whole ones and a short stub. The count IS the angle, so 2π stops being a number to memorise and the definition angle = arc / radius is the thing they watched happen.",
+	schema: z.object({
+		startRadians: z.number().min(0).max(6.29).optional().describe("radii of arc laid at the start"),
+		radius: z.number().min(40).max(120).optional().describe("drawn radius; the count does not depend on it"),
+		...commonLabProps
+	}),
+	experience: {
+		objectives: [
+			"Measure an angle in radii of arc rather than in degrees",
+			"Derive 2π radians in a full turn by counting, not by recall",
+			"Read angle = arc / radius as a definition rather than a formula"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: [
+			"10",
+			"11",
+			"12"
+		],
+		outcomes: [
+			"trigonometry",
+			"radian-measure",
+			"circular-motion"
+		],
+		durationMinutes: 6,
+		interaction: "explorer",
+		authorability: "simple"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/radian-wrap/runtime.mjs

@@ -0,0 +1,12 @@
+'use client';
+
+import { RadianWrapLab } from "../../../math/radian-wrap/preset.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/math/radian-wrap/runtime.tsx
+function Runtime(p) {
+	return /* @__PURE__ */ jsx(RadianWrapLab, { ...p });
+}
+
+//#endregion
+export { Runtime as default };

package/dist/domains/math/rate-machine/manifest.mjs

@@ -0,0 +1,73 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/math/rate-machine/manifest.ts
+var manifest_default = defineLab({
+	id: "rate-machine",
+	domain: "math",
+	group: "Math",
+	title: "Proportion machine (drag the count, it scales)",
+	description: "Count-driven concrete → graph: drag the input up and down; objects drop into a vessel, the liquid level rises by the same rate each step, and a point rides up the line leaving a dot at every whole step. Proportionality you scrub. Skinnable (battery, jar, savings) and an optional \"set it to N\" goal.",
+	schema: z.object({
+		rate: z.number().default(5),
+		base: z.number().default(0),
+		maxCount: z.number().default(6),
+		startCount: z.number().default(1),
+		yMax: z.number().default(40),
+		yStep: z.number().default(5),
+		xLabel: z.string().default("Items"),
+		yLabel: z.string().default("Cost"),
+		unit: z.string().default("$"),
+		itemLabel: z.string().optional(),
+		scene: z.string().default("vessel"),
+		extraScenes: z.array(z.string()).default([]),
+		showObjects: z.boolean().default(true),
+		liquidColor: z.string().optional(),
+		objectColor: z.string().optional(),
+		target: z.number().optional(),
+		height: z.number().min(220).max(640).optional(),
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		activity: z.string().optional()
+	}),
+	omit: ["activity"],
+	experience: {
+		objectives: [
+			"Connect repeated equal changes to a constant rate",
+			"Track one quantity across a graph, scene and numeric representation",
+			"Distinguish the rate from the starting value in an authored context"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		grades: [
+			"6",
+			"7",
+			"8"
+		],
+		outcomes: [
+			"math",
+			"proportion",
+			"rate"
+		],
+		durationMinutes: 10,
+		interaction: "explorer",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/rate-machine/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { RateMachineLab } from "../../../math/rate-machine/preset.mjs";
+
+export { RateMachineLab as default };