@classytic/labs 0.2.0 → 0.3.0

package/dist/physics/vector-board/view.mjs

@@ -4,20 +4,6 @@ import { VectorBoardLab } from "./preset.mjs";
 import { jsx } from "react/jsx-runtime";
 
 //#region src/physics/vector-board/view.tsx
-/** Default vectors for a freshly-inserted block. */
-const VECTOR_BOARD_DEMO = [{
-	label: "a",
-	dx: 3,
-	dy: 1,
-	color: "var(--stage-accent)",
-	drag: true
-}, {
-	label: "b",
-	dx: 1,
-	dy: 2,
-	color: "var(--stage-accent-2)",
-	drag: true
-}];
 function VectorBoardView({ vectors, combine = "sum", goalX, goalY, tol, components, angle, parallelogram, title, prompt, view, resultantLabel, objectives, hints }) {
 	const vs = (vectors ?? []).map((v) => ({
 		comp: {
@@ -26,7 +12,8 @@ function VectorBoardView({ vectors, combine = "sum", goalX, goalY, tol, componen
 		},
 		label: v.label,
 		color: v.color || void 0,
-		drag: !!v.drag
+		drag: !!v.drag,
+		lockMagnitude: !!v.lockMagnitude
 	}));
 	const goal = goalX !== void 0 && goalX !== "" && goalY !== void 0 && goalY !== "" ? {
 		match: {
@@ -55,4 +42,4 @@ function VectorBoardView({ vectors, combine = "sum", goalX, goalY, tol, componen
 }
 
 //#endregion
-export { VECTOR_BOARD_DEMO, VectorBoardView };
+export { VectorBoardView };

package/dist/physics/vector-scene.mjs

@@ -1,10 +1,11 @@
 'use client';
 
 import { clamp, toDeg } from "../core/util.mjs";
-import { LabFrame } from "../kit/frame.mjs";
-import { LabeledVector } from "../kit/diagram.mjs";
+import { MechanicsActivity } from "./mechanics/activity.mjs";
+import { ResetTransport, SceneSurface } from "./mechanics/presentation.mjs";
+import { LabeledVector } from "../kit/diagram/annotations.mjs";
 import { useEffect, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Axes, Dot, Grid, MovableDot, Stage } from "@classytic/stage";
 
 //#region src/physics/vector-scene.tsx
@@ -130,13 +131,9 @@ function VectorScene({ vectors, view, title = "Vectors", height = 340 } = {}) {
 	const drawable = resolved.filter((r) => Math.hypot(r.comp.x, r.comp.y) > 1e-6);
 	const draggables = resolved.filter((r) => r.draggable);
 	const labelled = drawable.filter((r) => r.label);
-	const figure = /* @__PURE__ */ jsx("div", {
-		style: {
-			borderRadius: 14,
-			overflow: "hidden",
-			background: "var(--stage-bg)",
-			border: "1px solid var(--stage-grid)"
-		},
+	const figure = /* @__PURE__ */ jsx(SceneSurface, {
+		className: "physics-vector-scene",
+		tone: "grid",
 		children: /* @__PURE__ */ jsxs(Stage, {
 			view: v,
 			height,
@@ -155,7 +152,7 @@ function VectorScene({ vectors, view, title = "Vectors", height = 340 } = {}) {
 					tail: r.tail,
 					comp: r.comp,
 					color: r.color,
-					label: r.label,
+					label: r.label ? r.id : void 0,
 					components: r.components
 				}, r.id)),
 				draggables.map((r) => /* @__PURE__ */ jsx(MovableDot, {
@@ -177,33 +174,60 @@ function VectorScene({ vectors, view, title = "Vectors", height = 340 } = {}) {
 		})
 	});
 	const aside = labelled.length > 0 ? /* @__PURE__ */ jsx("div", {
-		style: {
-			display: "grid",
-			gap: 4,
-			fontVariantNumeric: "tabular-nums",
-			fontWeight: 600
-		},
+		className: "physics-vector-readout",
 		children: labelled.map((r) => {
 			const mag = Math.hypot(r.comp.x, r.comp.y);
 			const ang = toDeg(Math.atan2(r.comp.y, r.comp.x));
 			return /* @__PURE__ */ jsxs("span", {
-				style: { color: r.color },
+				style: { "--vector-color": r.color },
 				children: [
-					r.label,
-					": ",
-					mag.toFixed(2),
-					" ∠ ",
-					ang.toFixed(0),
-					"°"
+					/* @__PURE__ */ jsx("i", { "aria-hidden": "true" }),
+					/* @__PURE__ */ jsx("span", { children: r.label }),
+					/* @__PURE__ */ jsx("strong", { children: mag.toFixed(1) }),
+					/* @__PURE__ */ jsxs("small", { children: [ang.toFixed(0), "°"] })
 				]
 			}, r.id);
 		})
 	}) : void 0;
-	return /* @__PURE__ */ jsx(LabFrame, {
+	const reset = () => setOverrides({});
+	const primary = labelled[labelled.length - 1];
+	const primaryMag = primary ? Math.hypot(primary.comp.x, primary.comp.y) : 0;
+	const primaryAngle = primary ? toDeg(Math.atan2(primary.comp.y, primary.comp.x)) : 0;
+	return /* @__PURE__ */ jsx(MechanicsActivity, {
+		className: "physics-vector-scene",
+		eyebrow: "Vectors and motion",
 		title,
-		prompt: draggables.length > 0 ? "Drag a vector’s tip to change it, sums and components update live." : void 0,
-		aside,
-		children: figure
+		prompt: draggables.length > 0 ? "Drag a vector’s tip to change it; derived sums and components update live." : "Read the authored vector relationships and component construction.",
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("strong", { children: draggables.length ? "Interactive scene" : "Authored scene" }),
+			/* @__PURE__ */ jsxs("span", { children: [drawable.length, " vectors"] }),
+			primary ? /* @__PURE__ */ jsxs("span", { children: [
+				primary.label,
+				" ",
+				primaryMag.toFixed(1),
+				" ∠ ",
+				primaryAngle.toFixed(0),
+				"°"
+			] }) : null
+		] }),
+		figure,
+		instruments: aside ?? /* @__PURE__ */ jsx("p", {
+			className: "physics-explain",
+			children: "No labelled vectors in this scene."
+		}),
+		controls: /* @__PURE__ */ jsx("p", {
+			className: "physics-explain",
+			children: draggables.length ? "Drag the visible handles; dependent vectors recompute from the authored add/subtract relationships." : "This scene is locked by the author for explanation or assessment."
+		}),
+		feedback: "Every derived arrow is calculated from the authored vector graph, so one scene can model resultants, relative motion, components, or force balance.",
+		transport: /* @__PURE__ */ jsx(ResetTransport, {
+			onReset: reset,
+			state: draggables.length ? "Drag to explore" : "Reference scene",
+			detail: `${drawable.length} vector${drawable.length === 1 ? "" : "s"}`,
+			resetLabel: "Reset vector scene"
+		}),
+		canvasLabel: "Authorable vector algebra scene",
+		inspectorLabel: "Vector measurements and scene guidance"
 	});
 }
 

package/dist/physics/vector-types/preset.d.mts

@@ -1,3 +1,4 @@
+import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
 import { ReactNode } from "react";
 import { Vec2 } from "@classytic/stage";
 
@@ -18,10 +19,16 @@ interface TypePanel {
 interface VectorTypesProps {
   types?: TypePanel[];
   title?: string;
+  prompt?: string;
+  objectives?: string[];
+  activity?: string | AuthoredActivity;
 }
 declare function VectorTypesLab({
   types,
-  title
+  title,
+  prompt,
+  objectives,
+  activity
 }: VectorTypesProps): ReactNode;
 //#endregion
 export { TypePanel, VectorTypesLab, VectorTypesProps };

package/dist/physics/vector-types/preset.mjs

@@ -1,9 +1,9 @@
 'use client';
 
-import { LabFrame } from "../../kit/frame.mjs";
-import { ChallengeCard, useChallenge, useCheckpoint } from "../../kit/pedagogy.mjs";
+import { AuthoredActivityRuntime } from "../../kit/authored-activity-runtime.mjs";
+import { SceneSurface } from "../mechanics/presentation.mjs";
 import { Fragment } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Dot, Label, Stage, Vector } from "@classytic/stage";
 
 //#region src/physics/vector-types/preset.tsx
@@ -77,7 +77,7 @@ const DEFAULT_TYPES = [
 		origin: true
 	},
 	{
-		name: "Unit (â)",
+		name: "Unit (â)",
 		caption: "Magnitude 1: direction only.",
 		vectors: [{
 			comp: {
@@ -85,7 +85,7 @@ const DEFAULT_TYPES = [
 				y: 0
 			},
 			color: "var(--stage-good)",
-			label: "â"
+			label: "â"
 		}],
 		origin: true
 	},
@@ -179,47 +179,118 @@ function Panel({ p }) {
 		]
 	});
 }
-const CHALLENGE = [{
-	id: "vector-vs-scalar",
-	prompt: "Which of these is a VECTOR (it has a direction, not just a size)?",
-	choices: [
+const VECTOR_TYPES_ACTIVITY = {
+	pattern: "investigation",
+	title: "Read the grammar of vector arrows",
+	objectives: [
+		"Distinguish vectors from scalars",
+		"Compare vector magnitude and direction",
+		"Recognize equal, negative, null, unit, parallel, and position vectors"
+	],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Choose the vector",
+			lead: "Use magnitude and direction to distinguish a vector from a scalar.",
+			success: "vector-answer"
+		},
 		{
-			value: "velocity",
-			label: "Velocity"
+			id: "act",
+			phase: "act",
+			title: "Compare the arrows",
+			lead: "Inspect what changes across the authored vector cards.",
+			reveal: ["model"]
 		},
 		{
-			value: "speed",
-			label: "Speed"
+			id: "observe",
+			phase: "observe",
+			title: "Name the invariant",
+			lead: "Compare magnitude, direction, and origin.",
+			reveal: ["model", "evidence"]
 		},
 		{
-			value: "mass",
-			label: "Mass"
+			id: "explain",
+			phase: "explain",
+			title: "Explain one pair",
+			lead: "Explain why equal and negative vectors differ."
 		},
 		{
-			value: "temperature",
-			label: "Temperature"
+			id: "transfer",
+			phase: "transfer",
+			title: "Classify a new quantity",
+			lead: "Apply the same test: does it need direction as well as magnitude?"
 		}
 	],
-	answer: "velocity",
-	explain: "Velocity is a vector: it carries a direction (e.g. 5 m/s north). Speed, mass and temperature are scalars: magnitude only."
-}];
-function VectorTypesLab({ types = DEFAULT_TYPES, title = "Types of vectors" }) {
-	const ch = useChallenge(CHALLENGE);
-	useCheckpoint({
-		solved: ch.allCorrect,
-		activity: "vector-types"
-	});
-	return /* @__PURE__ */ jsx(LabFrame, {
-		title,
-		footer: /* @__PURE__ */ jsx(ChallengeCard, {
-			questions: CHALLENGE,
-			state: ch
-		}),
+	questions: [{
+		id: "vector-vs-scalar",
+		prompt: "Which quantity is a vector?",
+		choices: [
+			{
+				value: "velocity",
+				label: "Velocity"
+			},
+			{
+				value: "speed",
+				label: "Speed"
+			},
+			{
+				value: "mass",
+				label: "Mass"
+			},
+			{
+				value: "temperature",
+				label: "Temperature"
+			}
+		],
+		answer: "velocity",
+		explain: "Velocity has magnitude and direction; the other quantities are scalars."
+	}],
+	success: [{
+		id: "vector-answer",
+		source: "answer",
+		key: "vector-vs-scalar",
+		operator: "eq",
+		value: "velocity",
+		pendingLabel: "Choose the quantity that includes direction."
+	}]
+};
+function VectorTypesLab({ types = DEFAULT_TYPES, title = "Types of vectors", prompt = "Compare the defining relationships, then test whether a quantity is a vector or a scalar.", objectives, activity = "vector-types" }) {
+	const activityId = typeof activity === "string" ? activity : "vector-types";
+	const authoredActivity = typeof activity === "string" ? VECTOR_TYPES_ACTIVITY : activity;
+	const figure = /* @__PURE__ */ jsx(SceneSurface, {
+		className: "physics-vector-types-scene",
 		children: /* @__PURE__ */ jsx("div", {
-			className: "lang-typegrid",
+			className: "lang-typegrid physics-vector-type-grid",
 			children: types.map((p, i) => /* @__PURE__ */ jsx(Panel, { p }, i))
 		})
 	});
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity: {
+			...authoredActivity,
+			objectives: objectives ?? authoredActivity.objectives
+		},
+		activityId,
+		eyebrow: "Vectors and motion",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", { children: "Reference" }), /* @__PURE__ */ jsxs("span", { children: [types.length, " vector types"] })] }),
+		evidence: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+			className: "physics-probe",
+			children: [
+				/* @__PURE__ */ jsx("span", { children: "Definition" }),
+				/* @__PURE__ */ jsx("strong", { children: "Magnitude + direction" }),
+				/* @__PURE__ */ jsx("small", { children: "Scalars have magnitude only" })
+			]
+		}), /* @__PURE__ */ jsx("p", {
+			className: "physics-explain",
+			children: "Compare direction, magnitude, and origin across the cards."
+		})] }),
+		observation: "The arrow grammar separates magnitude, direction, and origin so the same relationships transfer to motion and forces.",
+		transcript: /* @__PURE__ */ jsx("p", { children: `${types.length} vector type cards compare magnitude, direction, and origin.` }),
+		children: figure
+	});
 }
 
 //#endregion

package/dist/physics/venturi/core.mjs

@@ -0,0 +1,67 @@
+//#region src/physics/venturi/core.ts
+/**
+* Flow through a narrowing pipe: continuity and Bernoulli's equation.
+*
+* Squeeze a pipe and the pressure in the narrow part goes DOWN. It feels backwards, because
+* squeezing sounds like pressing. The two rules behind it are simple. The same volume of water
+* passes every section each second, so where the pipe is narrow the water must move faster:
+* A₁v₁ = A₂v₂. And the water only speeds up if something pushes it forward, which means the
+* pressure behind it must be higher than the pressure ahead: P + ½ρv² stays the same along the
+* pipe. Fast water is low-pressure water.
+*
+* Idealised as the syllabus does: incompressible, no viscosity, a horizontal pipe, and pressure
+* read by open vertical tubes whose water columns stand at a height h = (P − P_atm) ÷ ρg.
+*/
+const WATER_DENSITY = 1e3;
+const G = 9.8;
+/** The pipe's length in metres, and where its sections begin and end. */
+const PIPE = {
+	length: 3,
+	converge: [.8, 1.3],
+	diverge: [1.7, 2.2]
+};
+/** Radius at position x along the pipe, as a fraction of the wide radius. Smooth, no steps. */
+function radiusAt(x, throatRatio) {
+	const [c0, c1] = PIPE.converge, [d0, d1] = PIPE.diverge;
+	const ease = (f) => .5 - .5 * Math.cos(Math.PI * Math.max(0, Math.min(1, f)));
+	if (x <= c0 || x >= d1) return 1;
+	if (x < c1) return 1 - (1 - throatRatio) * ease((x - c0) / (c1 - c0));
+	if (x <= d0) return throatRatio;
+	return throatRatio + (1 - throatRatio) * ease((x - d0) / (d1 - d0));
+}
+/**
+* Speed from continuity. The area goes as the radius squared, so halving the radius quarters the
+* area and quadruples the speed.
+*/
+function speedAt(f, x) {
+	const r = radiusAt(x, f.throatRatio);
+	return f.inletSpeed / (r * r);
+}
+/** Pressure relative to the wide pipe, Pa, from P + ½ρv² = constant. */
+function pressureDrop(f, x) {
+	const rho = f.density ?? 1e3;
+	const v = speedAt(f, x);
+	return .5 * rho * (v * v - f.inletSpeed * f.inletSpeed);
+}
+/**
+* The height the water stands in an open tube at x. It falls by (v² − v₁²) ÷ 2g where the water
+* is faster, and below zero the tube would suck air in instead of holding water: that is how a
+* Venturi pump and a perfume spray work.
+*/
+function headAt(f, x) {
+	const g = f.g ?? 9.8;
+	const v = speedAt(f, x);
+	return f.inletHead - (v * v - f.inletSpeed * f.inletSpeed) / (2 * g);
+}
+/** The throat speed and the head lost there, for the readout. */
+function throat(f) {
+	const mid = (PIPE.converge[1] + PIPE.diverge[0]) / 2;
+	return {
+		speed: speedAt(f, mid),
+		headDrop: f.inletHead - headAt(f, mid),
+		pressureDrop: pressureDrop(f, mid)
+	};
+}
+
+//#endregion
+export { PIPE, headAt, radiusAt, speedAt, throat };

package/dist/physics/venturi/index.d.mts

@@ -0,0 +1 @@
+import { VenturiLab, VenturiProps } from "./preset.mjs";

package/dist/physics/venturi/preset.d.mts

@@ -0,0 +1,27 @@
+import { ReactNode } from "react";
+
+//#region src/physics/venturi/preset.d.ts
+interface VenturiProps {
+  /** Water speed in the wide pipe, m/s. */
+  inletSpeed?: number;
+  /** Throat radius as a fraction of the wide radius. */
+  throatRatio?: number;
+  /** Water height in the first tube, m. */
+  inletHead?: number;
+  /** Hide the water columns until the learner predicts. */
+  predict?: boolean;
+  title?: string;
+  prompt?: string;
+  activity?: string;
+}
+declare function VenturiLab({
+  inletSpeed: initialSpeed,
+  throatRatio: initialRatio,
+  inletHead,
+  predict,
+  title,
+  prompt,
+  activity
+}?: VenturiProps): ReactNode;
+//#endregion
+export { VenturiLab, VenturiProps };