@classytic/labs 0.3.0 → 0.4.0

package/dist/circuits/energy-cost/activity.mjs

@@ -0,0 +1,120 @@
+import { defineAuthoredActivity } from "../../kit/activity-authoring.mjs";
+
+//#region src/circuits/energy-cost/activity.ts
+/**
+* The arc runs on one prediction that is almost always wrong.
+*
+* Asked which appliance costs the most, students name the one with the biggest number on it. The
+* iron is 1000 W and the fridge is 150 W, so the iron must be worse. It is not, by a factor of ten,
+* because the fridge never switches off. Committing to the wrong answer first is what makes the
+* multiplication memorable.
+*/
+const energyCostActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Find out what is actually running up the bill",
+	objectives: [
+		"Convert a power rating and a running time into units of energy",
+		"State what a kilowatt-hour is in joules, and why it is an energy and not a power",
+		"Identify which appliance dominates a bill, and why it is rarely the largest one",
+		"Work out whether an efficient replacement pays for itself"
+	],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Name the expensive one",
+			lead: "A 1000 W iron, a 150 W refrigerator, four 60 W lamps and two 75 W fans. Before adding anything up: which one do you think costs the most each month?"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Change how long things run",
+			lead: "Adjust the hours. Watch the shares move. The power ratings never change, and the answer does.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Read the shares, not the ratings",
+			lead: "The refrigerator is one of the smallest numbers on the list and one of the largest shares of the bill, because it is the only thing that never switches off."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Account for it",
+			lead: "Energy is power multiplied by time. A rating plate gives you one of those two numbers and tells you nothing about the other."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Decide whether a swap is worth it",
+			lead: "Replace the filament lamps with efficient ones. The saving per month is easy. The question worth asking is how many days it takes to pay back what they cost to buy.",
+			controls: true
+		}
+	],
+	questions: [
+		{
+			id: "unit",
+			prompt: "One kilowatt-hour is",
+			choices: [
+				{
+					value: "energy",
+					label: "an amount of energy, equal to 3.6 megajoules"
+				},
+				{
+					value: "power",
+					label: "an amount of power, equal to 1000 watts"
+				},
+				{
+					value: "rate",
+					label: "a rate of spending, in taka per hour"
+				}
+			],
+			answer: "energy",
+			explain: "It is 1000 W sustained for 3600 s, which multiplies to 3.6 × 10⁶ J. The confusing part is that a unit of energy has a power unit inside its name."
+		},
+		{
+			id: "dominant",
+			prompt: "A 1000 W iron used 15 minutes a day against a 150 W fridge running all day. Over a month the fridge uses",
+			choices: [
+				{
+					value: "more",
+					label: "far more energy, because it never switches off"
+				},
+				{
+					value: "less",
+					label: "far less, because its power rating is much lower"
+				},
+				{
+					value: "same",
+					label: "about the same"
+				}
+			],
+			answer: "more",
+			explain: "The iron uses 0.25 kWh a day and the fridge 3.6 kWh. A rating plate gives the power and says nothing about the hours, and the hours are what differ here."
+		},
+		{
+			id: "voltage",
+			prompt: "A heater rated 220 V, 1500 W is connected to a 110 V supply. It delivers",
+			choices: [
+				{
+					value: "quarter",
+					label: "about 375 W, a quarter of its rating"
+				},
+				{
+					value: "half",
+					label: "about 750 W, half of its rating"
+				},
+				{
+					value: "full",
+					label: "still 1500 W"
+				}
+			],
+			answer: "quarter",
+			explain: "Its resistance does not change, and P = V²/R. Halving the voltage quarters the power, because the current halves as well."
+		}
+	]
+});
+
+//#endregion
+export { energyCostActivity };

package/dist/circuits/energy-cost/core.mjs

@@ -0,0 +1,93 @@
+//#region src/circuits/energy-cost/core.ts
+/**
+* Electrical energy as a bill: watts, hours, units, and what the meter actually charges for.
+*
+* This is the one topic in electricity where the answer arrives in the post. Every family argues
+* about the electricity bill, and almost nobody can say which appliance caused it, because the two
+* numbers that matter are multiplied together and people only ever look at one of them. A 2000 W
+* iron used for ten minutes a day costs less than a 60 W bulb left on overnight, and that is
+* genuinely surprising until you have multiplied it out once.
+*
+* ── The unit ────────────────────────────────────────────────────────────────────────────────────
+* The kilowatt-hour is a unit of ENERGY, not of power, and its name is the whole reason students
+* mishandle it: it has a power unit inside it. One kilowatt sustained for one hour is
+*
+*     1 kWh = 1000 W × 3600 s = 3.6 × 10⁶ J
+*
+* so the "unit" on a bill is 3.6 megajoules. Keeping `JOULES_PER_KWH` derived from that product,
+* rather than typed as 3600000, is deliberate: it is the derivation the exam asks for.
+*
+* ── Why the cost model is per-appliance ─────────────────────────────────────────────────────────
+* A single total answers nothing. The question a learner actually has is "which of these is costing
+* me the money", and that needs a share per appliance, which is what `billFor` returns. The shares
+* are what make the surprising comparison visible, and the surprise is the lesson.
+*/
+const nonNegative = (value, what) => {
+	if (!Number.isFinite(value) || value < 0) throw new RangeError(`${what} must be zero or more`);
+	return value;
+};
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive`);
+	return value;
+};
+/** Seconds in an hour, spelled out because the kWh derivation needs it visible. */
+const SECONDS_PER_HOUR = 3600;
+/** One kilowatt-hour in joules: 1000 W sustained for 3600 s. Derived, never typed. */
+const JOULES_PER_KWH = 1e3 * SECONDS_PER_HOUR;
+/** Energy in kilowatt-hours, which is what a meter counts. */
+function kilowattHours(watts, hours) {
+	return nonNegative(watts, "power") / 1e3 * nonNegative(hours, "time");
+}
+/**
+* The bill, per appliance and in total.
+*
+* Shares are computed against the total rather than accumulated, so they sum to exactly one even
+* when individual costs round awkwardly. A bill whose percentages add to 99 would undermine the one
+* thing the figure is for.
+*/
+function billFor(appliances, tariffPerUnit, days = 30) {
+	const tariff = nonNegative(tariffPerUnit, "tariff");
+	const period = positive(days, "days");
+	const seen = /* @__PURE__ */ new Set();
+	const raw = appliances.map((appliance) => {
+		if (seen.has(appliance.id)) throw new RangeError(`duplicate appliance id ${appliance.id}`);
+		seen.add(appliance.id);
+		if (nonNegative(appliance.hoursPerDay, `${appliance.name} hours`) > 24) throw new RangeError(`${appliance.name} cannot run more than 24 hours in a day`);
+		const count = appliance.count ?? 1;
+		if (!Number.isInteger(count) || count < 1) throw new RangeError(`${appliance.name} count must be a whole number of at least one`);
+		const units = kilowattHours(appliance.watts, appliance.hoursPerDay) * count * period;
+		return {
+			appliance,
+			units,
+			cost: units * tariff
+		};
+	});
+	const units = raw.reduce((sum, line) => sum + line.units, 0);
+	return {
+		lines: raw.map((line) => ({
+			...line,
+			share: units > 0 ? line.units / units : 0
+		})),
+		units,
+		cost: units * tariff,
+		days: period
+	};
+}
+/**
+* What swapping one appliance for a more efficient one saves over a period.
+*
+* Returns the money saved, which is the number that decides whether the swap is worth making. The
+* classic case is a 60 W filament lamp for a 13 W compact fluorescent giving the same light.
+*/
+function savingFromSwap(current, replacementWatts, tariffPerUnit, days = 30) {
+	return (current.watts - nonNegative(replacementWatts, "replacement power")) / 1e3 * nonNegative(current.hoursPerDay, "hours") * (current.count ?? 1) * positive(days, "days") * nonNegative(tariffPerUnit, "tariff");
+}
+/** How many days of saving it takes to pay back what the replacement cost to buy. */
+function paybackDays(current, replacementWatts, replacementPrice, tariffPerUnit) {
+	const perDay = savingFromSwap(current, replacementWatts, tariffPerUnit, 1);
+	if (perDay <= 0) return null;
+	return nonNegative(replacementPrice, "replacement price") / perDay;
+}
+
+//#endregion
+export { SECONDS_PER_HOUR, billFor, kilowattHours, paybackDays, savingFromSwap };

package/dist/circuits/energy-cost/preset.mjs

@@ -0,0 +1,278 @@
+'use client';
+
+import { Tex } from "../../core/tex.mjs";
+import { ActivitySelect, Slider } from "../../kit/controls.mjs";
+import { Activity } from "../../kit/activity.mjs";
+import { Field, Stat, StatList } from "../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../kit/authored-activity-runtime.mjs";
+import { Figure, HUE } from "../../kit/figure/figure.mjs";
+import { FigText } from "../../kit/figure/text.mjs";
+import { SegmentBar } from "../../kit/figure/plot.mjs";
+import { energyCostActivity } from "./activity.mjs";
+import { billFor, paybackDays, savingFromSwap } from "./core.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/circuits/energy-cost/preset.tsx
+/**
+* EnergyCostLab: the electricity bill, broken down by what caused it.
+*
+* The figure is a stacked bar of the month's units with one band per appliance, each band as wide
+* as its share. That shape is chosen over a set of separate bars deliberately: the question is not
+* "how much does the fridge use" but "how much of THIS BILL is the fridge", and a share of one
+* whole answers that in a way that side-by-side bars do not.
+*
+* ── The one thing this lab has to get across ────────────────────────────────────────────────────
+* Asked which appliance is expensive, a student names the one with the biggest number printed on
+* it. The iron says 1000 W and the fridge says 150 W. The fridge costs roughly ten times more,
+* because it never switches off. Energy is power multiplied by TIME, and a rating plate gives you
+* only one of those two.
+*
+* So the hours are the control, and the ratings are not. Dragging an appliance's hours moves its
+* band and nothing else, which makes the multiplication visible rather than asserted.
+*
+* The appliances are the ones in an actual Bangladeshi household, and the tariff is in taka per
+* unit, because a bill nobody recognises teaches nothing.
+*/
+const VIEW_WIDTH = 460;
+const BAR_TOP = 54;
+const BAR_HEIGHT = 46;
+/** The household. Ratings are the ones printed on the appliances, not idealised round numbers. */
+const HOUSEHOLD = [
+	{
+		id: "fridge",
+		name: "Refrigerator",
+		watts: 150,
+		hoursPerDay: 24
+	},
+	{
+		id: "fan",
+		name: "Ceiling fan",
+		watts: 75,
+		hoursPerDay: 12,
+		count: 2
+	},
+	{
+		id: "lamps",
+		name: "Filament lamps",
+		watts: 60,
+		hoursPerDay: 6,
+		count: 4
+	},
+	{
+		id: "tv",
+		name: "Television",
+		watts: 90,
+		hoursPerDay: 4
+	},
+	{
+		id: "iron",
+		name: "Iron",
+		watts: 1e3,
+		hoursPerDay: .25
+	}
+];
+const BAND = [
+	HUE[1],
+	HUE[2],
+	HUE[3],
+	HUE.warn,
+	HUE.good
+];
+const taka = (value) => `৳${value.toFixed(0)}`;
+function EnergyCostLab({ tariffPerUnit = 8, days = 30, focusHours, focus = "iron", lockTariff = false, title = "Which appliance is actually running up the bill?", prompt = "The iron is rated 1000 W and the refrigerator 150 W. Predict which costs more each month.", objectives, activity }) {
+	const [focused, setFocused] = useState(focus);
+	const [hours, setHours] = useState(focusHours ?? HOUSEHOLD.find((a) => a.id === focus)?.hoursPerDay ?? 1);
+	const [tariff, setTariff] = useState(tariffPerUnit);
+	const appliances = useMemo(() => HOUSEHOLD.map((a) => a.id === focused ? {
+		...a,
+		hoursPerDay: hours
+	} : a), [focused, hours]);
+	const bill = useMemo(() => billFor(appliances, tariff, days), [
+		appliances,
+		tariff,
+		days
+	]);
+	const ranked = [...bill.lines].sort((a, b) => b.units - a.units);
+	const biggest = ranked[0];
+	const pickFocus = (id) => {
+		setFocused(id);
+		setHours(HOUSEHOLD.find((a) => a.id === id)?.hoursPerDay ?? 1);
+	};
+	const lamps = appliances.find((a) => a.id === "lamps");
+	const swapSaving = savingFromSwap(lamps, 13, tariff, days);
+	const swapPayback = paybackDays(lamps, 13, 900, tariff);
+	/**
+	* `SegmentBar` from the figure kit, not a row of hand-drawn rects.
+	*
+	* The first version of this file drew its own, and re-derived two things the primitive already
+	* had: the rule that a band narrower than about 40 units cannot hold its own label, and a
+	* transition so a band that grows does not jump. `primitives:check` caught it, which is exactly
+	* the class of duplication that gate exists for.
+	*/
+	const bands = /* @__PURE__ */ jsx(SegmentBar, {
+		x: 30,
+		y: BAR_TOP,
+		w: 400,
+		h: BAR_HEIGHT,
+		segments: ranked.map((line, i) => ({
+			frac: line.share,
+			color: BAND[i % BAND.length],
+			label: `${Math.round(line.share * 100)}%`
+		}))
+	});
+	/**
+	* A table, not the kit's `Legend`.
+	*
+	* `Legend` lays entries out as a wrapping horizontal row, which is right for two or three short
+	* names. This is a BILL: every row carries a rating, a unit count and a cost, and those columns
+	* have to line up down the page or the comparison the lab exists for cannot be read. The swatch
+	* is the one mark drawn by hand here, and it is drawn to match `Legend`'s own.
+	*/
+	const legendTop = 130;
+	const rowGap = 21;
+	const legend = ranked.map((line, i) => {
+		const y = legendTop + i * rowGap;
+		const a = line.appliance;
+		const many = (a.count ?? 1) > 1 ? ` ×${a.count}` : "";
+		return /* @__PURE__ */ jsxs("g", { children: [
+			/* @__PURE__ */ jsx("rect", {
+				x: 30,
+				y: y - 8,
+				width: 11,
+				height: 11,
+				rx: 2,
+				fill: BAND[i % BAND.length]
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 48,
+				y: y + 1,
+				size: "label",
+				anchor: "start",
+				tone: a.id === focused ? "ink" : "soft",
+				children: `${a.name}${many}  ${a.watts} W × ${a.hoursPerDay} h`
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 430,
+				y: y + 1,
+				size: "label",
+				anchor: "end",
+				tone: a.id === focused ? "ink" : "soft",
+				children: `${line.units.toFixed(1)} units   ${taka(line.cost)}`
+			})
+		] }, `legend-${a.id}`);
+	});
+	const height = legendTop + ranked.length * rowGap + 16;
+	const scene = /* @__PURE__ */ jsxs(Figure, {
+		viewBox: `0 0 ${VIEW_WIDTH} ${height}`,
+		label: `A ${days} day bill of ${bill.units.toFixed(1)} units costing ${taka(bill.cost)}. The largest share is the ${biggest?.appliance.name ?? "largest appliance"} at ${Math.round((biggest?.share ?? 0) * 100)} percent.`,
+		children: [
+			/* @__PURE__ */ jsx(FigText, {
+				x: 30,
+				y: 28,
+				size: "label",
+				anchor: "start",
+				tone: "soft",
+				children: `${days} days · ${bill.units.toFixed(1)} units · ${taka(bill.cost)}`
+			}),
+			bands,
+			legend
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "Appliance",
+			name: "focus",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "appliance",
+				value: focused,
+				onChange: pickFocus,
+				options: HOUSEHOLD.map((a) => ({
+					value: a.id,
+					label: `${a.name} (${a.watts} W)`
+				}))
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "Hours a day",
+			name: "hours",
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: hours,
+				onChange: setHours,
+				min: 0,
+				max: 24,
+				step: .25,
+				ariaLabel: "hours used per day",
+				valueText: `${hours} h`
+			})
+		}),
+		!lockTariff && /* @__PURE__ */ jsx(Field, {
+			label: "Tariff",
+			name: "tariff",
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: tariff,
+				onChange: setTariff,
+				min: 1,
+				max: 20,
+				step: .5,
+				ariaLabel: "price per unit",
+				valueText: `৳${tariff}/unit`
+			})
+		})
+	] });
+	const focusedLine = bill.lines.find((l) => l.appliance.id === focused);
+	const evidence = /* @__PURE__ */ jsxs(StatList, { children: [
+		/* @__PURE__ */ jsx(Stat, {
+			label: "Monthly bill",
+			value: taka(bill.cost),
+			tone: "good"
+		}),
+		/* @__PURE__ */ jsx(Stat, {
+			label: "Units used",
+			value: bill.units.toFixed(1)
+		}),
+		/* @__PURE__ */ jsx(Stat, {
+			label: focusedLine.appliance.name,
+			value: `${Math.round(focusedLine.share * 100)}% of the bill`
+		})
+	] });
+	return /* @__PURE__ */ jsxs(AuthoredActivityRuntime, {
+		className: "physics-circuits",
+		focusLayout: "immersive",
+		activity: activity ?? energyCostActivity,
+		activityId: "energy-cost",
+		eyebrow: "Electrical energy",
+		title,
+		description: prompt,
+		controls,
+		evidence,
+		observation: biggest ? `${biggest.appliance.name} is ${Math.round(biggest.share * 100)}% of this bill at ${biggest.appliance.watts} W. The iron is rated ${HOUSEHOLD.find((a) => a.id === "iron").watts} W and is nowhere near the top, because a rating plate tells you the power and says nothing about the hours. Energy is the two multiplied together.` : "Nothing is switched on, so nothing is being charged for.",
+		children: [
+			scene,
+			/* @__PURE__ */ jsx(Tex, {
+				tex: `E = Pt = \\frac{${focusedLine.appliance.watts}}{1000} \\times ${focusedLine.appliance.hoursPerDay} \\times ${days} = ${focusedLine.units.toFixed(1)}\\ \\text{units}`,
+				block: true
+			}),
+			/* @__PURE__ */ jsxs(Activity.Disclosure, {
+				label: "Would efficient lamps pay for themselves?",
+				children: [
+					/* @__PURE__ */ jsxs("p", { children: [
+						"Swapping the four 60 W filament lamps for 13 W lamps of the same brightness saves ",
+						taka(swapSaving),
+						" ",
+						"over ",
+						days,
+						" days at ৳",
+						tariff,
+						" a unit."
+					] }),
+					/* @__PURE__ */ jsx("p", { children: swapPayback === null ? "At this tariff the swap saves nothing, so it never pays back." : `If the four lamps cost ৳900, they pay for themselves in about ${Math.round(swapPayback)} days, and everything after that is saved.` }),
+					/* @__PURE__ */ jsx("p", { children: "One unit is one kilowatt-hour, which is 1000 W sustained for 3600 s, so 3.6 × 10⁶ J. The confusing part is that a unit of energy has a power unit inside its name." })
+				]
+			})
+		]
+	});
+}
+
+//#endregion
+export { EnergyCostLab, EnergyCostLab as default };

package/dist/circuits/index.d.mts

@@ -1,21 +1,36 @@
 import { CIRCUIT_NETWORK_ASSET } from "./circuit/asset.mjs";
 import { CircuitComponentSpec, CircuitGoal, CircuitNetworkLab, CircuitNetworkProps, circuitDoc } from "./circuit/preset.mjs";
+import "./circuit/index.mjs";
 import { CircuitLab, CircuitLabProps } from "./circuit-lab.mjs";
 import { CircuitBuilder, CircuitBuilderProps, CircuitComponent } from "./circuit-builder.mjs";
 import { CapacitorLeakLab, CapacitorLeakProps } from "./capacitor-leak/preset.mjs";
+import "./capacitor-leak/index.mjs";
 import { AcDcLab, AcDcProps } from "./ac-dc/preset.mjs";
+import "./ac-dc/index.mjs";
+import { DividerMode, SensorPosition, ldrResistance, potentiometerWiper, solvePotentialDivider, thermistorResistance } from "./potential-divider/core.mjs";
+import { PotentialDividerLab, PotentialDividerProps } from "./potential-divider/preset.mjs";
+import "./potential-divider/index.mjs";
+import { KirchhoffMode, SelectedLoop, evaluateKcl, getLoopElevationProfile, solveTwoLoopCircuit } from "./kirchhoff/core.mjs";
+import { KirchhoffLawsLab, KirchhoffLawsProps } from "./kirchhoff/preset.mjs";
+import "./kirchhoff/index.mjs";
 import { RCChargingLab, RCChargingProps } from "./rc-charging/preset.mjs";
+import "./rc-charging/index.mjs";
 import { DiodeLab, DiodeProps } from "./diode/preset.mjs";
+import "./diode/index.mjs";
 import { TransistorLab, TransistorProps } from "./transistor/preset.mjs";
+import "./transistor/index.mjs";
 import { CmosInverterLab, CmosInverterProps } from "./cmos-gate/inverter.mjs";
 import { RNmosNotLab, RNmosNotProps } from "./cmos-gate/rnmos-not.mjs";
 import { CmosNandLab, CmosNandProps } from "./cmos-gate/nand.mjs";
 import { CmosNorLab, CmosNorProps } from "./cmos-gate/nor.mjs";
+import "./cmos-gate/index.mjs";
 import { BrownoutLab, BrownoutProps } from "./brownout/preset.mjs";
+import "./brownout/index.mjs";
 import { MosfetInsideLab, MosfetInsideProps } from "./semiconductor/mosfet-inside.mjs";
 import { PnJunctionLab, PnJunctionProps } from "./semiconductor/pn-junction.mjs";
 import { SiliconLatticeLab, SiliconLatticeProps } from "./semiconductor/silicon-lattice.mjs";
 import { ConductionLab, ConductionProps } from "./semiconductor/conduction.mjs";
 import { HallEffectLab, HallProps } from "./semiconductor/hall-effect.mjs";
 import { BjtInsideLab, BjtInsideProps } from "./semiconductor/bjt-inside.mjs";
-export { AcDcLab, type AcDcProps, BjtInsideLab, type BjtInsideProps, BrownoutLab, type BrownoutProps, CIRCUIT_NETWORK_ASSET, CapacitorLeakLab, type CapacitorLeakProps, CircuitBuilder, type CircuitBuilderProps, type CircuitComponent, type CircuitComponentSpec, type CircuitGoal, CircuitLab, type CircuitLabProps, CircuitNetworkLab, type CircuitNetworkProps, CmosInverterLab, type CmosInverterProps, CmosNandLab, type CmosNandProps, CmosNorLab, type CmosNorProps, ConductionLab, type ConductionProps, DiodeLab, type DiodeProps, HallEffectLab, type HallProps, MosfetInsideLab, type MosfetInsideProps, PnJunctionLab, type PnJunctionProps, RCChargingLab, type RCChargingProps, RNmosNotLab, type RNmosNotProps, SiliconLatticeLab, type SiliconLatticeProps, TransistorLab, type TransistorProps, circuitDoc };
+import "./semiconductor/index.mjs";
+export { AcDcLab, type AcDcProps, BjtInsideLab, type BjtInsideProps, BrownoutLab, type BrownoutProps, CIRCUIT_NETWORK_ASSET, CapacitorLeakLab, type CapacitorLeakProps, CircuitBuilder, type CircuitBuilderProps, type CircuitComponent, type CircuitComponentSpec, type CircuitGoal, CircuitLab, type CircuitLabProps, CircuitNetworkLab, type CircuitNetworkProps, CmosInverterLab, type CmosInverterProps, CmosNandLab, type CmosNandProps, CmosNorLab, type CmosNorProps, ConductionLab, type ConductionProps, DiodeLab, type DiodeProps, type DividerMode, HallEffectLab, type HallProps, KirchhoffLawsLab, type KirchhoffLawsProps, type KirchhoffMode, MosfetInsideLab, type MosfetInsideProps, PnJunctionLab, type PnJunctionProps, PotentialDividerLab, type PotentialDividerProps, RCChargingLab, type RCChargingProps, RNmosNotLab, type RNmosNotProps, type SelectedLoop, type SensorPosition, SiliconLatticeLab, type SiliconLatticeProps, TransistorLab, type TransistorProps, circuitDoc, evaluateKcl, getLoopElevationProfile, ldrResistance, potentiometerWiper, solvePotentialDivider, solveTwoLoopCircuit, thermistorResistance };

package/dist/circuits/index.mjs

@@ -4,6 +4,10 @@ import { CircuitLab } from "./circuit-lab.mjs";
 import { CircuitBuilder } from "./circuit-builder.mjs";
 import { CapacitorLeakLab } from "./capacitor-leak/preset.mjs";
 import { AcDcLab } from "./ac-dc/preset.mjs";
+import { ldrResistance, potentiometerWiper, solvePotentialDivider, thermistorResistance } from "./potential-divider/core.mjs";
+import { PotentialDividerLab } from "./potential-divider/preset.mjs";
+import { evaluateKcl, getLoopElevationProfile, solveTwoLoopCircuit } from "./kirchhoff/core.mjs";
+import { KirchhoffLawsLab } from "./kirchhoff/preset.mjs";
 import { RCChargingLab } from "./rc-charging/preset.mjs";
 import { DiodeLab } from "./diode/preset.mjs";
 import { TransistorLab } from "./transistor/preset.mjs";
@@ -19,4 +23,4 @@ import { ConductionLab } from "./semiconductor/conduction.mjs";
 import { HallEffectLab } from "./semiconductor/hall-effect.mjs";
 import { BjtInsideLab } from "./semiconductor/bjt-inside.mjs";
 
-export { AcDcLab, BjtInsideLab, BrownoutLab, CIRCUIT_NETWORK_ASSET, CapacitorLeakLab, CircuitBuilder, CircuitLab, CircuitNetworkLab, CmosInverterLab, CmosNandLab, CmosNorLab, ConductionLab, DiodeLab, HallEffectLab, MosfetInsideLab, PnJunctionLab, RCChargingLab, RNmosNotLab, SiliconLatticeLab, TransistorLab, circuitDoc };
+export { AcDcLab, BjtInsideLab, BrownoutLab, CIRCUIT_NETWORK_ASSET, CapacitorLeakLab, CircuitBuilder, CircuitLab, CircuitNetworkLab, CmosInverterLab, CmosNandLab, CmosNorLab, ConductionLab, DiodeLab, HallEffectLab, KirchhoffLawsLab, MosfetInsideLab, PnJunctionLab, PotentialDividerLab, RCChargingLab, RNmosNotLab, SiliconLatticeLab, TransistorLab, circuitDoc, evaluateKcl, getLoopElevationProfile, ldrResistance, potentiometerWiper, solvePotentialDivider, solveTwoLoopCircuit, thermistorResistance };

package/dist/circuits/kirchhoff/core.d.mts

@@ -0,0 +1,70 @@
+//#region src/circuits/kirchhoff/core.d.ts
+/**
+ * @classytic/labs/circuits/kirchhoff/core
+ *
+ * Physics kernel for Kirchhoff's Laws:
+ *   1. Kirchhoff's Current Law (KCL): \sum I_in = \sum I_out (Conservation of Charge at a node)
+ *   2. Kirchhoff's Voltage Law (KVL): \sum E = \sum IR around any closed loop (Conservation of Energy)
+ *
+ * Powered by Modified Nodal Analysis (MNA) from @classytic/stage/circuit for guaranteed physical accuracy.
+ */
+type KirchhoffMode = 'kcl' | 'kvl';
+type SelectedLoop = 'left' | 'right' | 'outer';
+interface KclBranch {
+  id: string;
+  name: string;
+  currentA: number;
+  direction: 'in' | 'out';
+}
+interface KclResult {
+  sumInA: number;
+  sumOutA: number;
+  isBalanced: boolean;
+  deltaA: number;
+}
+declare function evaluateKcl(branches: readonly KclBranch[]): KclResult;
+interface TwoLoopCircuitInput {
+  e1V: number;
+  e2V: number;
+  r1Ohm: number;
+  r2Ohm: number;
+  r3Ohm: number;
+}
+interface TwoLoopCircuitResult {
+  i1A: number;
+  i2A: number;
+  i3A: number;
+  vTopV: number;
+  vR1V: number;
+  vR2V: number;
+  vR3V: number;
+  loopLeftEmfSumV: number;
+  loopLeftDropSumV: number;
+  loopRightEmfSumV: number;
+  loopRightDropSumV: number;
+  loopOuterEmfSumV: number;
+  loopOuterDropSumV: number;
+}
+/**
+ * Solves a standard Cambridge 2-loop circuit:
+ *
+ *        Node 1 (Top Junction)
+ *    ┌───────────┬───────────┐
+ *    │           │           │
+ *   [R1]        [R3]        [R2]
+ *    │           │           │
+ *   (E1)         │          (E2)
+ *    │           │           │
+ *    └───────────┴───────────┘
+ *        Node 0 (Ground / Bottom)
+ */
+declare function solveTwoLoopCircuit(input: TwoLoopCircuitInput): TwoLoopCircuitResult;
+interface ElevationPoint {
+  step: string;
+  voltageV: number;
+  desc: string;
+}
+/** Returns the step-by-step potential rollercoaster profile along a selected loop. */
+declare function getLoopElevationProfile(circuit: TwoLoopCircuitResult, input: TwoLoopCircuitInput, loop: SelectedLoop): ElevationPoint[];
+//#endregion
+export { ElevationPoint, KclBranch, KclResult, KirchhoffMode, SelectedLoop, TwoLoopCircuitInput, TwoLoopCircuitResult, evaluateKcl, getLoopElevationProfile, solveTwoLoopCircuit };