@classytic/labs 0.2.0 → 0.3.0

package/dist/networking/vlan.mjs

@@ -0,0 +1,100 @@
+//#region src/networking/vlan.ts
+const isLive = (port) => port.enabled && !!port.device;
+/** Ports in the same VLAN as `portId`, excluding itself. */
+function domainOf(state, portId) {
+	const source = state.ports.find((port) => port.id === portId);
+	if (!source) return [];
+	return state.ports.filter((port) => port.id !== portId && port.vlan === source.vlan && isLive(port)).map((port) => port.id);
+}
+/** A broadcast reaches its own VLAN and stops there. Routing does not change that. */
+function broadcastFrom(state, portId) {
+	const source = state.ports.find((port) => port.id === portId);
+	if (!source || !isLive(source)) return {
+		reached: [],
+		blocked: [],
+		message: `Port ${portId} has no live device to send from.`
+	};
+	const reached = domainOf(state, portId);
+	const blocked = state.ports.filter((port) => port.id !== portId && isLive(port) && port.vlan !== source.vlan).map((port) => port.id);
+	const vlanName = state.vlans.find((vlan) => vlan.id === source.vlan)?.name ?? `VLAN ${source.vlan}`;
+	return {
+		reached,
+		blocked,
+		message: blocked.length ? `The broadcast reaches every live port in ${vlanName} and stops. ${blocked.length} live port${blocked.length > 1 ? "s are" : " is"} in another VLAN and never sees it.` : `The broadcast reaches every live port in ${vlanName}.`
+	};
+}
+/**
+* Directed traffic between two ports. Within a VLAN the switch forwards it. Across VLANs it needs
+* a layer-3 interface, and that interface is where a policy would sit.
+*/
+function sendBetween(state, fromPort, toPort) {
+	const source = state.ports.find((port) => port.id === fromPort);
+	const target = state.ports.find((port) => port.id === toPort);
+	if (!source || !target || !isLive(source) || !isLive(target)) return {
+		delivered: false,
+		viaRouter: false,
+		message: "Both ends need a live device."
+	};
+	if (source.vlan === target.vlan) return {
+		delivered: true,
+		viaRouter: false,
+		message: `Same VLAN, so the switch forwards it directly. Nothing outside the VLAN is involved.`
+	};
+	if (!state.routing) return {
+		delivered: false,
+		viaRouter: false,
+		message: `Different VLANs and no layer-3 interface, so there is no path at all. The switch will not carry it.`
+	};
+	return {
+		delivered: true,
+		viaRouter: true,
+		message: `Different VLANs, so it goes up to the layer-3 interface and back down. Every crossing passes that one point, which is where a rule can be applied.`
+	};
+}
+function setPortVlan(state, portId, vlan) {
+	return {
+		...state,
+		ports: state.ports.map((port) => port.id === portId ? {
+			...port,
+			vlan
+		} : port)
+	};
+}
+const setRouting = (state, routing) => ({
+	...state,
+	routing
+});
+/** How many separate broadcast domains this switch is currently carrying. */
+const domainCount = (state) => new Set(state.ports.filter(isLive).map((port) => port.vlan)).size;
+const NAMES = [
+	"Sales",
+	"Finance",
+	"Reception",
+	"Store",
+	"Server A",
+	"Server B",
+	"Kiosk",
+	"Camera"
+];
+/** Eight ports, the first `connected` holding a device, split evenly across two VLANs. */
+function makeVlanSwitch(connected = 6) {
+	return {
+		vlans: [{
+			id: 10,
+			name: "VLAN 10"
+		}, {
+			id: 20,
+			name: "VLAN 20"
+		}],
+		routing: false,
+		ports: Array.from({ length: 8 }, (_, index) => ({
+			id: index + 1,
+			vlan: index < 4 ? 10 : 20,
+			enabled: true,
+			device: index < connected ? { name: NAMES[index] } : void 0
+		}))
+	};
+}
+
+//#endregion
+export { broadcastFrom, domainCount, isLive, makeVlanSwitch, sendBetween, setPortVlan, setRouting };

package/dist/networking/vpn.mjs

@@ -0,0 +1,118 @@
+//#region src/networking/vpn.ts
+const OBSERVERS = [
+	{
+		id: "wifi",
+		name: "The café Wi-Fi",
+		short: "Café Wi-Fi",
+		where: "anyone else on the same network, including whoever runs it"
+	},
+	{
+		id: "isp",
+		name: "Your internet provider",
+		short: "Your provider",
+		where: "every packet you send crosses their equipment"
+	},
+	{
+		id: "gateway",
+		name: "The VPN provider",
+		short: "VPN provider",
+		where: "the far end of the tunnel, where the wrapping comes off"
+	},
+	{
+		id: "website",
+		name: "The website",
+		short: "The website",
+		where: "the machine you are actually talking to"
+	}
+];
+const YOU = "You";
+const GATEWAY = "VPN gateway";
+const SITE = "example.com";
+const CIPHER = "unreadable";
+/** Watchers that exist in this setup. Without a tunnel there is no gateway to watch. */
+const observersFor = (setup) => OBSERVERS.filter((observer) => observer.id !== "gateway" || setup.vpn);
+function observe(id, setup) {
+	const observer = OBSERVERS.find((item) => item.id === id);
+	if (!observer || id === "gateway" && !setup.vpn) return null;
+	if (id === "website") return {
+		observer,
+		from: {
+			value: setup.vpn ? GATEWAY : YOU,
+			hidden: false
+		},
+		to: {
+			value: SITE,
+			hidden: false
+		},
+		contents: {
+			value: "your request, in full",
+			hidden: false
+		},
+		verdict: setup.vpn ? "Sees a request arriving from the VPN gateway rather than from you, and reads it in full. It has to: it is the one answering." : "Sees your own address and reads the request in full. HTTPS protects it from everyone in between, never from the far end."
+	};
+	if (setup.vpn) {
+		if (id === "gateway") return {
+			observer,
+			from: {
+				value: YOU,
+				hidden: false
+			},
+			to: {
+				value: SITE,
+				hidden: false
+			},
+			contents: setup.https ? {
+				value: CIPHER,
+				hidden: true
+			} : {
+				value: "your request, in full",
+				hidden: false
+			},
+			verdict: setup.https ? "Knows who you are and every site you ask for, but HTTPS still keeps the contents from them. This is the trade: your provider stopped seeing this and they started." : "Knows who you are, every site you ask for, and everything you send. Without HTTPS you have simply changed which company watches you."
+		};
+		return {
+			observer,
+			from: {
+				value: YOU,
+				hidden: false
+			},
+			to: {
+				value: GATEWAY,
+				hidden: false
+			},
+			contents: {
+				value: CIPHER,
+				hidden: true
+			},
+			verdict: "Can tell you are using a VPN and nothing else. Which sites you visit is inside the wrapping, so it is not available here at any price."
+		};
+	}
+	return {
+		observer,
+		from: {
+			value: YOU,
+			hidden: false
+		},
+		to: {
+			value: SITE,
+			hidden: false
+		},
+		contents: setup.https ? {
+			value: CIPHER,
+			hidden: true
+		} : {
+			value: "your request, in full",
+			hidden: false
+		},
+		verdict: setup.https ? "Sees which sites you visit and when, but not what you asked for or what came back." : "Sees which sites you visit and can read every word of it."
+	};
+}
+/** Every watcher's view of one setup, which is where the pattern shows up. */
+const surveyOf = (setup) => observersFor(setup).map((observer) => observe(observer.id, setup)).filter((sighting) => sighting !== null);
+/** Watchers who can name the site being visited. The count is the honest summary of a setup. */
+const canSeeDestination = (setup) => surveyOf(setup).filter((sighting) => !sighting.to.hidden && sighting.to.value === SITE).map((sighting) => sighting.observer.id);
+/** Watchers who can read what you actually sent. */
+const canReadContents = (setup) => surveyOf(setup).filter((sighting) => !sighting.contents.hidden).map((sighting) => sighting.observer.id);
+
+//#endregion
+export { OBSERVERS, canReadContents, canSeeDestination, observe, observersFor };

package/dist/pathways/biology.d.mts

@@ -0,0 +1,6 @@
+import { LabPathway } from "./types.mjs";
+
+//#region src/pathways/biology.d.ts
+declare const cellSystemsPathway: LabPathway;
+//#endregion
+export { cellSystemsPathway };

package/dist/pathways/biology.mjs

@@ -0,0 +1,60 @@
+//#region src/pathways/biology.ts
+const cellSystemsPathway = {
+	id: "biology-cell-systems",
+	title: "Cell systems: boundary, energy, information, and inheritance",
+	description: "Build one connected model of a cell by moving from membrane exchange through ATP supply and protein secretion to chromosome inheritance.",
+	domain: "biology",
+	grades: [
+		"10",
+		"11",
+		"12"
+	],
+	estimatedMinutes: 98,
+	steps: [
+		{
+			id: "membrane-transport",
+			tag: "MembraneTransportLab",
+			title: "Control the boundary",
+			purpose: "Predict passive and active movement from gradients, permeability, proteins, and ATP."
+		},
+		{
+			id: "respiration",
+			tag: "RespirationLab",
+			title: "Turn matter into usable energy",
+			purpose: "Connect glucose and oxygen to respiration products and ATP."
+		},
+		{
+			id: "cell-energy",
+			tag: "CellEnergyLab",
+			title: "Balance the ATP budget",
+			purpose: "Match respiratory supply to cellular work and diagnose limiting inputs."
+		},
+		{
+			id: "central-dogma",
+			tag: "CentralDogmaLab",
+			title: "Turn stored information into protein",
+			purpose: "Trace DNA through mRNA to an amino-acid sequence."
+		},
+		{
+			id: "cell-system",
+			tag: "CellSystemLab",
+			title: "Ship a protein through the cell",
+			purpose: "Follow secretory cargo through organelles and diagnose downstream failures."
+		},
+		{
+			id: "mitosis-explorer",
+			tag: "MitosisExplorerLab",
+			title: "Preserve the genome",
+			purpose: "Track duplicated chromosomes into genetically matching daughter cells."
+		},
+		{
+			id: "meiosis-explorer",
+			tag: "MeiosisExplorerLab",
+			title: "Generate inherited variation",
+			purpose: "Separate homologs and sisters across two divisions while tracking variation."
+		}
+	]
+};
+
+//#endregion
+export { cellSystemsPathway };

package/dist/pathways/calculus.d.mts

@@ -0,0 +1,6 @@
+import { LabPathway } from "./types.mjs";
+
+//#region src/pathways/calculus.d.ts
+declare const calculusPathway: LabPathway;
+//#endregion
+export { calculusPathway };

package/dist/pathways/calculus.mjs

@@ -0,0 +1,123 @@
+//#region src/pathways/calculus.ts
+const calculusPathway = {
+	id: "calculus-foundations",
+	title: "Calculus: from approach to approximation",
+	description: "A coherent visual sequence from limits through derivatives and accumulation to approximation, differential equations, optimization, and solving.",
+	domain: "math",
+	grades: ["11", "12"],
+	estimatedMinutes: 133,
+	steps: [
+		{
+			id: "limit-explorer",
+			tag: "LimitExplorer",
+			title: "Approach and continuity",
+			purpose: "Build the limiting process before introducing instantaneous change.",
+			defaultAttributes: {
+				equation: "(x^2 - 1)/(x - 1)",
+				xRange: [-1, 3],
+				c: 1
+			}
+		},
+		{
+			id: "derivative-explorer",
+			tag: "DerivativeExplorer",
+			title: "Secant becomes tangent",
+			purpose: "Interpret the derivative as a limit and an instantaneous rate.",
+			defaultAttributes: {
+				equation: "0.15*x^3 - x",
+				xRange: [-4, 4],
+				startX: 1
+			}
+		},
+		{
+			id: "integral-explorer",
+			tag: "IntegralExplorer",
+			title: "Rectangles become accumulation",
+			purpose: "Construct signed area through increasingly fine partitions.",
+			defaultAttributes: {
+				equation: "0.4*x^2 + 0.5",
+				xRange: [-1, 4],
+				a: 0,
+				b: 3,
+				n: 8
+			}
+		},
+		{
+			id: "fundamental-theorem",
+			tag: "FundamentalTheorem",
+			title: "Accumulation becomes slope",
+			purpose: "Connect integration and differentiation through synchronized graphs.",
+			defaultAttributes: {
+				equation: "0.5*x^2 - 1",
+				xRange: [-3, 4],
+				anchor: -1,
+				startX: 2
+			}
+		},
+		{
+			id: "taylor-series",
+			tag: "TaylorSeries",
+			title: "Local derivatives become approximation",
+			purpose: "Assemble derivative information into a polynomial and inspect its error.",
+			defaultAttributes: {
+				equation: "sin(x)",
+				xRange: [-6.3, 6.3],
+				center: 0,
+				order: 5
+			}
+		},
+		{
+			id: "differential-equation",
+			tag: "DifferentialEquation",
+			title: "Local rates become trajectories",
+			purpose: "Follow a direction field and compare numerical initial-value solvers.",
+			defaultAttributes: {
+				equation: "x - y",
+				xRange: [-3, 3],
+				yRange: [-3, 3],
+				initial: [0, 1],
+				stepSize: .4
+			}
+		},
+		{
+			id: "phase-portrait",
+			tag: "PhasePortrait",
+			title: "Coupled rates become a flow",
+			purpose: "Read a two-variable system as a vector field and explore its state-space trajectories.",
+			defaultAttributes: {
+				dx: "y",
+				dy: "-x - 0.25*y",
+				xRange: [-4, 4],
+				yRange: [-4, 4],
+				initial: [3, 0]
+			}
+		},
+		{
+			id: "gradient-descent",
+			tag: "GradientDescent",
+			title: "Gradients drive optimization",
+			purpose: "Use multivariable derivatives to minimize a loss surface.",
+			defaultAttributes: {
+				equation: "x^2 + 2*y^2",
+				range: [-3, 3],
+				start: [2.4, 1.8],
+				learningRate: .1
+			}
+		},
+		{
+			id: "newton-method",
+			tag: "NewtonMethod",
+			title: "Tangents solve equations",
+			purpose: "Turn local linearization into a guarded numerical root solver.",
+			defaultAttributes: {
+				equation: "x^3 - x - 2",
+				xRange: [-3, 3],
+				startX: 1.8,
+				maxSteps: 12
+			}
+		}
+	]
+};
+
+//#endregion
+export { calculusPathway };

package/dist/pathways/chemistry.d.mts

@@ -0,0 +1,8 @@
+import { LabPathway } from "./types.mjs";
+
+//#region src/pathways/chemistry.d.ts
+/** A model-building sequence rather than a catalog dump. Each activity changes
+ * representation only after the previous one supplies the needed concept. */
+declare const chemistryFoundationsPathway: LabPathway;
+//#endregion
+export { chemistryFoundationsPathway };

package/dist/pathways/chemistry.mjs

@@ -0,0 +1,87 @@
+//#region src/pathways/chemistry.ts
+/** A model-building sequence rather than a catalog dump. Each activity changes
+* representation only after the previous one supplies the needed concept. */
+const chemistryFoundationsPathway = {
+	id: "chemistry-from-atoms-to-amounts",
+	title: "Chemistry: from atomic models to measurable reactions",
+	description: "Move from atomic structure and periodic evidence through probability orbitals, three-dimensional bonding, reactions, quantities, solutions, and acid-base measurement.",
+	domain: "chem",
+	grades: [
+		"10",
+		"11",
+		"12"
+	],
+	estimatedMinutes: 101,
+	steps: [
+		{
+			id: "bohr-atom",
+			tag: "BohrAtom",
+			title: "Shells establish atomic structure",
+			purpose: "Use a deliberately limited shell model to connect proton number, electrons, and broad periodic organization.",
+			defaultAttributes: { protons: 8 }
+		},
+		{
+			id: "periodic-trends",
+			tag: "PeriodicTrends",
+			title: "The table becomes evidence",
+			purpose: "Read atomic radius, ionisation energy, and electronegativity as recurring evidence rather than facts to memorise."
+		},
+		{
+			id: "atomic-orbital",
+			tag: "AtomicOrbitalLab",
+			title: "Probability replaces electron paths",
+			purpose: "Upgrade from shells to orbital probability, phase, and nodes without treating orbitals as containers.",
+			defaultAttributes: {
+				orbital: "2p-z",
+				view: "cloud"
+			}
+		},
+		{
+			id: "molecular-geometry",
+			tag: "MolecularGeometryLab",
+			title: "Electron domains become molecular shape",
+			purpose: "Connect directional bonding models, lone pairs, three-dimensional shape, and polarity.",
+			defaultAttributes: {
+				molecule: "h2o",
+				showLonePairs: true,
+				showDipoles: true,
+				showHybridOrbitals: true
+			}
+		},
+		{
+			id: "reaction-lab",
+			tag: "ReactionLab",
+			title: "Collisions rearrange bonds",
+			purpose: "Move from static molecular structure to collision, bond rearrangement, and temperature-dependent reaction behavior."
+		},
+		{
+			id: "stoichiometry",
+			tag: "Stoichiometry",
+			title: "A balanced equation becomes a quantity model",
+			purpose: "Use coefficients as ratios to identify limiting reagent, product yield, and excess reactant."
+		},
+		{
+			id: "solution-box",
+			tag: "SolutionBox",
+			title: "Amount and volume become concentration",
+			purpose: "Link particle amount, solution volume, and concentration before using concentration in an experiment."
+		},
+		{
+			id: "titration",
+			tag: "Titration",
+			title: "Concentration becomes experimental evidence",
+			purpose: "Use a measured volume, pH curve, equivalence point, and indicator interval to reason about an unknown acid.",
+			defaultAttributes: {
+				analyte: "weak-acid",
+				concAcid: .1,
+				volAcidMl: 25,
+				concBase: .1,
+				pKa: 4.76,
+				indicator: "phenolphthalein"
+			}
+		}
+	]
+};
+
+//#endregion
+export { chemistryFoundationsPathway };

package/dist/pathways/digital-logic.d.mts

@@ -0,0 +1,21 @@
+import { LabPathway } from "./types.mjs";
+
+//#region src/pathways/digital-logic.d.ts
+/**
+ * A first course in digital logic design, built as ONE continuous argument: a switch can
+ * decide, decided things can be combined, combined things can remember, and something that
+ * remembers can follow a plan. That is a computer.
+ *
+ * The order is the standard syllabus (number systems, Boolean algebra, minimisation,
+ * combinational blocks, latches and flip-flops, registers and counters, state machines),
+ * so it maps onto a Digital Logic Design course such as CSE 231 and its equivalents. The
+ * framing is deliberately not a syllabus: each chapter answers a question a student would
+ * actually ask.
+ *
+ * Steps marked `planned` are designed but unbuilt. The pivot from combinational to
+ * sequential is the whole point of the course, and it is also where the library currently
+ * stops, so the backlog is concentrated there on purpose.
+ */
+declare const digitalLogicPathway: LabPathway;
+//#endregion
+export { digitalLogicPathway };