@classytic/labs 0.1.0 → 0.2.0

package/dist/build/parts/bulb.mjs

@@ -0,0 +1,50 @@
+'use client';
+
+import { BulbGlyph } from "../../kit/electronics.mjs";
+import { labelOf, num, render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/bulb.tsx
+/** Lamp / bulb: a resistor that glows. `ohms` sets its resistance; brightness tracks |current|. */
+const BULB = {
+	kind: "bulb",
+	label: "Lamp",
+	pins: ["a", "b"],
+	defaultProps: {
+		ohms: 100,
+		maxPower: 2
+	},
+	controls: [{
+		key: "ohms",
+		label: "Resistance",
+		unit: "Ω",
+		min: 1,
+		max: 1e4,
+		step: 10
+	}, {
+		key: "maxPower",
+		label: "Power rating",
+		unit: "W",
+		min: 0,
+		max: 50,
+		step: .1
+	}],
+	terminalAt: term2,
+	toElems: (i, n) => [{
+		kind: "R",
+		n1: n("a"),
+		n2: n("b"),
+		value: num(i.props?.ohms, 100)
+	}],
+	render: (i, s) => render2(i, labelOf(i) ?? "lamp", (cx, cy, h, l) => /* @__PURE__ */ jsx(BulbGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		brightness: Math.max(0, Math.min(1, Math.abs(s.i) * 40)),
+		label: l
+	}))
+};
+
+//#endregion
+export { BULB };

package/dist/build/parts/capacitor.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/capacitor.mjs

@@ -0,0 +1,26 @@
+'use client';
+
+import { CapacitorGlyph } from "../../kit/electronics.mjs";
+import { labelOf, render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/capacitor.tsx
+/** Capacitor: stores charge. Open at DC (no element here); the transient solver gives it dynamics. */
+const CAPACITOR = {
+	kind: "capacitor",
+	label: "Capacitor",
+	pins: ["a", "b"],
+	defaultProps: { farads: 1e-5 },
+	terminalAt: term2,
+	toElems: () => [],
+	render: (i, s) => render2(i, labelOf(i), (cx, cy, h, l) => /* @__PURE__ */ jsx(CapacitorGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		label: l
+	}))
+};
+
+//#endregion
+export { CAPACITOR };

package/dist/build/parts/cell.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/cell.mjs

@@ -0,0 +1,40 @@
+'use client';
+
+import { CellGlyph } from "../../kit/electronics.mjs";
+import { num, render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/cell.tsx
+/** Battery / cell: an ideal voltage source. `volts` sets its EMF; it drives the loop current. */
+const CELL = {
+	kind: "cell",
+	label: "Battery",
+	pins: ["a", "b"],
+	defaultProps: { volts: 5 },
+	controls: [{
+		key: "volts",
+		label: "Voltage",
+		unit: "V",
+		min: 0,
+		max: 24,
+		step: .5
+	}],
+	terminalAt: term2,
+	toElems: (i, n) => [{
+		kind: "V",
+		n1: n("a"),
+		n2: n("b"),
+		value: num(i.props?.volts, 5),
+		id: i.id
+	}],
+	render: (i, s) => render2(i, `${num(i.props?.volts, 5)} V`, (cx, cy, h, l) => /* @__PURE__ */ jsx(CellGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		label: l
+	}))
+};
+
+//#endregion
+export { CELL };

package/dist/build/parts/diode.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/diode.mjs

@@ -0,0 +1,33 @@
+'use client';
+
+import { DiodeGlyph } from "../../kit/electronics.mjs";
+import { labelOf, render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/diode.tsx
+/** Diode: one-way valve (Shockley model in the solver). Conducts a→b above ~0.7 V, blocks reverse. */
+const DIODE = {
+	kind: "diode",
+	label: "Diode",
+	pins: ["a", "b"],
+	defaultProps: {},
+	terminalAt: term2,
+	toElems: (i, n) => [{
+		kind: "D",
+		n1: n("a"),
+		n2: n("b"),
+		value: 0,
+		id: i.id
+	}],
+	render: (i, s) => render2(i, labelOf(i), (cx, cy, h, l) => /* @__PURE__ */ jsx(DiodeGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		conducting: s.live,
+		label: l
+	}))
+};
+
+//#endregion
+export { DIODE };

package/dist/build/parts/index.d.mts

@@ -0,0 +1,5 @@
+//#region src/build/parts/index.d.ts
+/** Register the built-in parts (idempotent). Imported for its side effect. */
+declare function registerBuiltinParts(): void;
+//#endregion
+export { registerBuiltinParts };

package/dist/build/parts/index.mjs

@@ -0,0 +1,43 @@
+import { registerPart } from "../registry.mjs";
+import { CELL } from "./cell.mjs";
+import { RESISTOR } from "./resistor.mjs";
+import { BULB } from "./bulb.mjs";
+import { SWITCH } from "./switch.mjs";
+import { DIODE } from "./diode.mjs";
+import { CAPACITOR } from "./capacitor.mjs";
+import { AMMETER } from "./ammeter.mjs";
+import { NODE } from "./node.mjs";
+import { NMOS, PMOS } from "./mosfet.mjs";
+
+//#region src/build/parts/index.ts
+/**
+* Built-in part registry. Each component is its own module (cell, resistor, bulb, switch,
+* diode, capacitor, mosfet, node, ammeter), self-contained: its pins, electrical stamp, glyph,
+* tunables and any tap behaviour. This barrel is the ONE place that wires them into the live
+* registry. Add a component = add a file here and one line below. Nothing else special-cases a
+* part kind, so the solver and renderer stay component-agnostic.
+*/
+/** The built-ins in palette order. */
+const BUILTIN_PARTS = [
+	CELL,
+	RESISTOR,
+	BULB,
+	SWITCH,
+	DIODE,
+	CAPACITOR,
+	AMMETER,
+	NODE,
+	NMOS,
+	PMOS
+];
+let registered = false;
+/** Register the built-in parts (idempotent). Imported for its side effect. */
+function registerBuiltinParts() {
+	if (registered) return;
+	registered = true;
+	BUILTIN_PARTS.forEach(registerPart);
+}
+registerBuiltinParts();
+
+//#endregion
+export { registerBuiltinParts };

package/dist/build/parts/mosfet.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/mosfet.mjs

@@ -0,0 +1,95 @@
+'use client';
+
+import { MosfetGlyph } from "../../kit/electronics.mjs";
+import { num } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/mosfet.tsx
+const MOS_HALF = 34, GATE_OFF = 37;
+const mosTerminal = (i, pin) => {
+	const { x, y } = i.at;
+	return pin === "d" ? {
+		x,
+		y: y - MOS_HALF
+	} : pin === "s" ? {
+		x,
+		y: y + MOS_HALF
+	} : {
+		x: x - GATE_OFF,
+		y
+	};
+};
+const mosDef = (kind, pmos) => ({
+	kind,
+	label: pmos ? "PMOS" : "NMOS",
+	pins: [
+		"d",
+		"s",
+		"g"
+	],
+	defaultProps: {
+		vth: 2,
+		k: .5,
+		maxPower: .5,
+		maxVoltage: 20
+	},
+	controls: [
+		{
+			key: "vth",
+			label: "Threshold",
+			unit: "V",
+			min: .5,
+			max: 5,
+			step: .1
+		},
+		{
+			key: "k",
+			label: "Gain k",
+			min: .1,
+			max: 2,
+			step: .1
+		},
+		{
+			key: "maxPower",
+			label: "Power rating",
+			unit: "W",
+			min: 0,
+			max: 50,
+			step: .1
+		},
+		{
+			key: "maxVoltage",
+			label: "Breakdown V",
+			unit: "V",
+			min: 0,
+			max: 100,
+			step: 1
+		}
+	],
+	terminalAt: mosTerminal,
+	toElems: (i, n) => [{
+		kind: "M",
+		pmos,
+		n1: n("d"),
+		n2: n("s"),
+		n3: n("g"),
+		value: 0,
+		vth: num(i.props?.vth, 2),
+		k: num(i.props?.k, .5),
+		id: i.id
+	}],
+	render: (i, s) => /* @__PURE__ */ jsx("g", { children: /* @__PURE__ */ jsx(MosfetGlyph, {
+		cx: i.at.x + 9,
+		cy: i.at.y,
+		half: MOS_HALF,
+		pmos,
+		on: s.live,
+		live: s.live,
+		label: i.props?.label
+	}) }, i.id)
+});
+const NMOS = mosDef("nmos", false);
+const PMOS = mosDef("pmos", true);
+
+//#endregion
+export { NMOS, PMOS };

package/dist/build/parts/node.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/node.mjs

@@ -0,0 +1,32 @@
+'use client';
+
+import { JunctionDot } from "../../kit/electronics.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/node.tsx
+/**
+* Junction node: a free connection point (one pin, no element = a perfect conductor). Every
+* wire touching it shares one electrical net, so it is how parallel branches, bridges and
+* ladders are built. The editor only ever creates one ON a wire (a tap), and prunes any that
+* fall below two connections, so junctions never float as clutter.
+*/
+const NODE = {
+	kind: "node",
+	label: "Node (junction)",
+	pins: ["j"],
+	defaultProps: {},
+	terminalAt: (i) => ({
+		x: i.at.x,
+		y: i.at.y
+	}),
+	toElems: () => [],
+	render: (i, s) => /* @__PURE__ */ jsx(JunctionDot, {
+		x: i.at.x,
+		y: i.at.y,
+		live: s.live,
+		r: 5
+	}, i.id)
+};
+
+//#endregion
+export { NODE };

package/dist/build/parts/resistor.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/resistor.mjs

@@ -0,0 +1,49 @@
+'use client';
+
+import { ResistorGlyph } from "../../kit/electronics.mjs";
+import { num, ohmLabel, render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/resistor.tsx
+/** Resistor: an ohmic element. `ohms` sets its resistance; current = V across it / ohms. */
+const RESISTOR = {
+	kind: "resistor",
+	label: "Resistor",
+	pins: ["a", "b"],
+	defaultProps: {
+		ohms: 1e3,
+		maxPower: .5
+	},
+	controls: [{
+		key: "ohms",
+		label: "Resistance",
+		unit: "Ω",
+		min: 1,
+		max: 1e5,
+		step: 10
+	}, {
+		key: "maxPower",
+		label: "Power rating",
+		unit: "W",
+		min: 0,
+		max: 50,
+		step: .05
+	}],
+	terminalAt: term2,
+	toElems: (i, n) => [{
+		kind: "R",
+		n1: n("a"),
+		n2: n("b"),
+		value: num(i.props?.ohms, 1e3)
+	}],
+	render: (i, s) => render2(i, ohmLabel(num(i.props?.ohms, 1e3)), (cx, cy, h, l) => /* @__PURE__ */ jsx(ResistorGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		label: l
+	}))
+};
+
+//#endregion
+export { RESISTOR };

package/dist/build/parts/shared.mjs

@@ -0,0 +1,42 @@
+'use client';
+
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/build/parts/shared.tsx
+/** centre → terminal distance for a 2-terminal part, px. */
+const HALF = 30;
+const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+const ohmLabel = (r) => r >= 1e3 ? `${r / 1e3} kΩ` : `${r} Ω`;
+const labelOf = (i) => i.props?.label ?? void 0;
+/** terminal world position for a 2-terminal part (a = left/top, b = right/bottom). */
+function term2(inst, pin) {
+	const { x, y } = inst.at, o = inst.orient ?? "h", s = pin === "a" ? -1 : 1;
+	return o === "v" ? {
+		x,
+		y: y + s * 30
+	} : {
+		x: x + s * 30,
+		y
+	};
+}
+/** render a 2-terminal glyph at the instance, rotated for 'v', label kept horizontal. */
+function render2(inst, label, glyph) {
+	const { x, y } = inst.at;
+	if ((inst.orient ?? "h") === "v") return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("g", {
+		transform: `rotate(90 ${x} ${y})`,
+		children: glyph(x, y, 30, void 0)
+	}), label && /* @__PURE__ */ jsx("text", {
+		x: x + 30 + 8,
+		y: y + 4,
+		fill: "var(--stage-fg)",
+		fontSize: 11,
+		fontWeight: 600,
+		textAnchor: "start",
+		style: { pointerEvents: "none" },
+		children: label
+	})] }, inst.id);
+	return /* @__PURE__ */ jsx("g", { children: glyph(x, y, 30, label) }, inst.id);
+}
+
+//#endregion
+export { labelOf, num, ohmLabel, render2, term2 };

package/dist/build/parts/switch.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/switch.mjs

@@ -0,0 +1,34 @@
+'use client';
+
+import { SwitchGlyph } from "../../kit/electronics.mjs";
+import { labelOf, render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/switch.tsx
+/** Switch: closed = a 0 V short (conducts), open = no element (breaks the loop). Tap to toggle. */
+const SWITCH = {
+	kind: "switch",
+	label: "Switch",
+	pins: ["a", "b"],
+	defaultProps: { closed: false },
+	terminalAt: term2,
+	toElems: (i, n) => i.props?.closed ? [{
+		kind: "V",
+		n1: n("a"),
+		n2: n("b"),
+		value: 0,
+		id: i.id
+	}] : [],
+	render: (i, s) => render2(i, labelOf(i), (cx, cy, h, l) => /* @__PURE__ */ jsx(SwitchGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		closed: !!i.props?.closed,
+		label: l
+	})),
+	tap: (i) => ({ closed: !i.props?.closed })
+};
+
+//#endregion
+export { SWITCH };

package/dist/build/parts.d.mts

@@ -0,0 +1 @@
+import { registerBuiltinParts } from "./parts/index.mjs";

package/dist/build/registry.d.mts

@@ -0,0 +1,9 @@
+import { PartDef, PartKind } from "./contract.mjs";
+
+//#region src/build/registry.d.ts
+declare function registerPart(def: PartDef): void;
+declare function getPart(kind: PartKind): PartDef | undefined;
+/** Every registered part (drives the builder palette). */
+declare function listParts(): PartDef[];
+//#endregion
+export { getPart, listParts, registerPart };

package/dist/build/registry.mjs

@@ -0,0 +1,15 @@
+//#region src/build/registry.ts
+const REGISTRY = /* @__PURE__ */ new Map();
+function registerPart(def) {
+	REGISTRY.set(def.kind, def);
+}
+function getPart(kind) {
+	return REGISTRY.get(kind);
+}
+/** Every registered part (drives the builder palette). */
+function listParts() {
+	return [...REGISTRY.values()];
+}
+
+//#endregion
+export { getPart, listParts, registerPart };

package/dist/build/solve.d.mts

@@ -0,0 +1,8 @@
+import { CircuitDoc, CircuitSolution, PartInstance, PartState } from "./contract.mjs";
+
+//#region src/build/solve.d.ts
+declare function solveCircuit(doc: CircuitDoc): CircuitSolution;
+/** Derive the drawing state (current/voltage/live) for one part from the solution. */
+declare function partState(part: PartInstance, sol: CircuitSolution): PartState;
+//#endregion
+export { partState, solveCircuit };

package/dist/catalog/registry.d.mts

@@ -7,7 +7,7 @@ interface LabTemplate {
   id: string;
   /** Human title for the catalog. */
   title: string;
-  /** Domain bucket — 'algebra' | 'calculus' | 'physics' | 'circuits' | … */
+  /** Domain bucket, 'algebra' | 'calculus' | 'physics' | 'circuits' | … */
   category: string;
   /** One-line description for the catalog card. */
   description?: string;
@@ -24,7 +24,7 @@ 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. */
+/** Result of instantiating a template, typed errors before a bad scene is built. */
 type InstantiateResult = {
   ok: true;
   doc: SceneDoc;

package/dist/catalog/templates.d.mts

@@ -1,7 +1,7 @@
 //#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
+ * 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

package/dist/catalog/templates.mjs

@@ -11,7 +11,7 @@ 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
+* 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
@@ -21,7 +21,7 @@ function registerBuiltinTemplates() {
 		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.",
+		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()
@@ -59,7 +59,7 @@ function registerBuiltinTemplates() {
 		id: "area-model",
 		title: "Area model (algebra tiles)",
 		category: "algebra",
-		description: "(x+a)(x+b) as a partitioned rectangle — expand or factor.",
+		description: "(x+a)(x+b) as a partitioned rectangle, expand or factor.",
 		paramsSchema: z.object({
 			a: z.number(),
 			b: z.number(),
@@ -93,7 +93,7 @@ function registerBuiltinTemplates() {
 		id: "balance-lever",
 		title: "Lever / torque",
 		category: "physics",
-		description: "Balance the mobile — set the unknown weight so Σ(w·d) matches.",
+		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(),
@@ -107,7 +107,7 @@ function registerBuiltinTemplates() {
 	});
 	registerLabTemplate({
 		id: "optics",
-		title: "Optics — reflection",
+		title: "Optics: reflection",
 		category: "physics",
 		description: "Reflect a light ray off mirrors into the target.",
 		defaultParams: {},
@@ -117,7 +117,7 @@ function registerBuiltinTemplates() {
 		id: "circuit",
 		title: "Circuit",
 		category: "circuits",
-		description: "Battery + series/parallel branches — light the bulb.",
+		description: "Battery + series/parallel branches, light the bulb.",
 		paramsSchema: z.object({
 			emf: z.number().optional(),
 			branches: z.array(z.unknown()).optional()

package/dist/chem/battery.mjs

@@ -12,7 +12,7 @@ import { Dot, Label, Polygon, Segment, Stage, useFrameLoop } from "@classytic/st
 
 //#region src/chem/battery.tsx
 /**
-* Battery — a galvanic (voltaic) cell. Two half-cells: at the anode a metal is
+* Battery, a galvanic (voltaic) cell. Two half-cells: at the anode a metal is
 * oxidized and releases electrons; they flow through the external wire to the
 * cathode, where ions are reduced. Watch the electrons stream, see the
 * half-reactions and the cell EMF.

package/dist/chem/bohr-atom.mjs

@@ -10,13 +10,13 @@ import { Circle, Dot, Label, Stage, useFrameLoop } from "@classytic/stage";
 
 //#region src/chem/bohr-atom.tsx
 /**
-* BohrAtom — the classic shell model of an atom, animated.
+* BohrAtom, the classic shell model of an atom, animated.
 *
 * Nucleus (Z protons) ringed by electron shells filled 2, 8, 8, 18…; electrons
 * orbit at a steady clip via the engine clock. Drag the proton count to walk the
 * first 20 elements and watch shells fill and close.
 *
-* Now on the @classytic/stage engine (SVG, accessible, themed) — shells are
+* Now on the @classytic/stage engine (SVG, accessible, themed), shells are
 * Circles, electrons are Dots, the nucleus is a labelled Circle.
 */
 const SYMBOLS = [
@@ -187,7 +187,7 @@ function BohrAtom({ protons, title = "Bohr model of the atom", height = 340 } =
 	}) });
 	return /* @__PURE__ */ jsx(LabFrame, {
 		title,
-		prompt: "Drag the proton count to walk the first 20 elements — watch the shells fill (2, 8, 8, …).",
+		prompt: "Drag the proton count to walk the first 20 elements, watch the shells fill (2, 8, 8, …).",
 		aside: /* @__PURE__ */ jsx(Callout, {
 			tone: "result",
 			children: /* @__PURE__ */ jsxs("span", {
@@ -197,7 +197,7 @@ function BohrAtom({ protons, title = "Bohr model of the atom", height = 340 } =
 					fontVariantNumeric: "tabular-nums"
 				},
 				children: [
-					/* @__PURE__ */ jsxs("span", { children: ["element ", SYMBOLS[z] ?? "—"] }),
+					/* @__PURE__ */ jsxs("span", { children: ["element ", SYMBOLS[z] ?? ", "] }),
 					/* @__PURE__ */ jsxs("span", { children: ["Z ", z] }),
 					/* @__PURE__ */ jsxs("span", { children: ["config ", shells.join(", ")] })
 				]