@classytic/stage 0.2.0 → 0.4.0

package/dist/networking/models/vpn.d.mts

@@ -0,0 +1,66 @@
+//#region src/networking/models/vpn.d.ts
+/**
+ * What a VPN actually hides, from whom, and what it quietly costs.
+ *
+ * This topic is taught almost entirely by advertising, and the advertising is wrong in both
+ * directions. A VPN does not make anyone anonymous, and it also does not hand a provider your
+ * banking password. The truthful version is more interesting than either claim, and it falls out of
+ * one mechanism: the original packet is wrapped inside a new one addressed to the gateway, and the
+ * inside is encrypted. So anybody between you and the gateway can see that you are talking to the
+ * gateway and nothing else, and the gateway can see everything the encryption around it does not
+ * cover.
+ *
+ * The conclusion worth carrying out of the lesson is that a VPN MOVES trust rather than removing
+ * it: whatever your network operator could previously see, the VPN provider now sees instead. That
+ * is sometimes an excellent trade (hostile café Wi-Fi, a censoring network) and sometimes a bad one
+ * (a free provider funded by selling exactly that view).
+ *
+ * The second honest point is that HTTPS and a VPN protect different things, so the interesting
+ * cases are the combinations rather than either alone. And no arrangement of either hides anything
+ * from the site you are actually talking to, because it is the one you are talking to.
+ */
+type ObserverId = "wifi" | "isp" | "gateway" | "website";
+interface Observer {
+  id: ObserverId;
+  name: string;
+  /** For the diagram, where a box is narrower than a sentence. */
+  short: string;
+  /** Where this watcher sits, in the learner's words. */
+  where: string;
+}
+declare const OBSERVERS: Observer[];
+interface Setup {
+  vpn: boolean;
+  https: boolean;
+}
+interface Field {
+  value: string;
+  hidden: boolean;
+}
+interface Sighting {
+  observer: Observer;
+  /** Who this watcher believes is sending. */
+  from: Field;
+  /** Where this watcher believes it is going. */
+  to: Field;
+  contents: Field;
+  verdict: string;
+}
+/** Watchers that exist in this setup. Without a tunnel there is no gateway to watch. */
+declare const observersFor: (setup: Setup) => Observer[];
+declare function observe(id: ObserverId, setup: Setup): Sighting | null;
+/** Every watcher's view of one setup, which is where the pattern shows up. */
+declare const surveyOf: (setup: Setup) => Sighting[];
+/** Watchers who can name the site being visited. The count is the honest summary of a setup. */
+declare const canSeeDestination: (setup: Setup) => ObserverId[];
+/** Watchers who can read what you actually sent. */
+declare const canReadContents: (setup: Setup) => ObserverId[];
+/**
+ * The tunnel's own cost. A VPN wraps a whole packet inside another one, so the outer headers plus
+ * the encryption are pure overhead, and the room left for real data shrinks by the same amount.
+ * WireGuard's 60 bytes is the honest modern figure; older tunnels cost noticeably more.
+ */
+declare const TUNNEL_OVERHEAD_BYTES = 60;
+declare const usableBytes: (mtu: number, setup: Setup) => number;
+//#endregion
+export { Field, OBSERVERS, Observer, ObserverId, Setup, Sighting, TUNNEL_OVERHEAD_BYTES, canReadContents, canSeeDestination, observe, observersFor, surveyOf, usableBytes };

package/dist/networking/models/vpn.mjs

@@ -0,0 +1,125 @@
+//#region src/networking/models/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);
+/**
+* The tunnel's own cost. A VPN wraps a whole packet inside another one, so the outer headers plus
+* the encryption are pure overhead, and the room left for real data shrinks by the same amount.
+* WireGuard's 60 bytes is the honest modern figure; older tunnels cost noticeably more.
+*/
+const TUNNEL_OVERHEAD_BYTES = 60;
+const usableBytes = (mtu, setup) => mtu - (setup.vpn ? 60 : 0);
+
+//#endregion
+export { OBSERVERS, TUNNEL_OVERHEAD_BYTES, canReadContents, canSeeDestination, observe, observersFor, surveyOf, usableBytes };

package/dist/networking/models/wifi-privacy.d.mts

@@ -0,0 +1,82 @@
+//#region src/networking/models/wifi-privacy.d.ts
+/**
+ * What the person at the next table can actually read.
+ *
+ * Chapter 1 established the fact this whole chapter turns on: radio reaches everyone in range,
+ * whether or not they were meant to have it. Nothing about Wi-Fi decides who RECEIVES your signal.
+ * Every laptop in the cafe already has it. The only question ever at issue is who can make sense of
+ * it, and that is decided by encryption in two separate places that protect two different things.
+ *
+ * Students arrive with one of two wrong models. Either "it has a password, so it is private", or
+ * "there is a padlock in the browser, so it is private". Each is half right in a way that leaves a
+ * real hole, and the point of this model is to make both holes visible at once.
+ *
+ * The one that surprises people is the shared password. A cafe password written on a chalkboard is
+ * not a secret, and on WPA2 it is also the material from which every customer's key is derived. Any
+ * other customer who has that password, and who was listening when your device joined, can decrypt
+ * your traffic. The network is encrypted and it is not private FROM the people it is shared with.
+ * WPA3 fixes exactly this, which is the whole reason it exists and is almost never how it is sold.
+ *
+ * The other hole runs the opposite way. HTTPS protects what you sent from everyone, including the
+ * cafe and your provider, and it does not hide WHERE you sent it. The destination is still on the
+ * wire, so anyone who can read the link learns every site you visited even though they see none of
+ * the contents.
+ */
+/** How the radio link itself is protected. */
+type Protection = "open" | "wep" | "wpa2" | "wpa3";
+/** How the conversation with the website is protected, independently of the link. */
+type Transport = "http" | "https";
+/** Who is listening, which decides whether the link's key is available to them. */
+type Listener = "stranger" | "customer";
+interface ProtectionSpec {
+  id: Protection;
+  label: string;
+  note: string;
+}
+declare const PROTECTIONS: Record<Protection, ProtectionSpec>;
+declare const LISTENERS: Record<Listener, {
+  id: Listener;
+  label: string;
+  note: string;
+}>;
+/**
+ * Can this listener decrypt the radio link?
+ *
+ * The WEP row is the one worth reading twice. It is nominally encryption and belongs in the same
+ * column as an open network, because a key that anyone can recover is not a key. Stating that in the
+ * model rather than in a footnote is the difference between a student who avoids WEP and one who
+ * ticks the box marked "encrypted".
+ */
+declare function linkReadable(protection: Protection, listener: Listener): boolean;
+interface Exposure {
+  id: string;
+  /** What is at stake, in the words someone would use about their own life. */
+  label: string;
+  visible: boolean;
+  /** Shown when visible. Entirely fictional, and obviously so. */
+  value: string;
+  /** Why it is or is not readable, which is the part that has to be learned. */
+  why: string;
+}
+/**
+ * Everything a listener learns, most harmless first.
+ *
+ * Ordered that way on purpose. A list that opens with the password makes this look like a lesson
+ * about passwords, and it is not: the top two rows leak on EVERY setting including the best one, and
+ * a student who notices that has understood something about radio that no amount of encryption
+ * changes.
+ */
+declare function whatTheySee(protection: Protection, transport: Transport, listener: Listener): Exposure[];
+interface PrivacyVerdict {
+  /** How many of the five things this listener can read. */
+  exposed: number;
+  total: number;
+  /** The single sentence a learner should take away from this combination. */
+  headline: string;
+  tone: "bad" | "mixed" | "good";
+}
+declare function judgePrivacy(protection: Protection, transport: Transport, listener: Listener): PrivacyVerdict;
+/** The honest summary: which of the two protections fixes which hole. */
+declare const ADVICE: string[];
+//#endregion
+export { ADVICE, Exposure, LISTENERS, Listener, PROTECTIONS, PrivacyVerdict, Protection, ProtectionSpec, Transport, judgePrivacy, linkReadable, whatTheySee };

package/dist/networking/models/wifi-privacy.mjs

@@ -0,0 +1,130 @@
+//#region src/networking/models/wifi-privacy.ts
+const PROTECTIONS = {
+	open: {
+		id: "open",
+		label: "Open, no password",
+		note: "The link carries plain radio that anyone in range can decode with ordinary hardware. Common in cafes, airports and hotels precisely because it is convenient."
+	},
+	wep: {
+		id: "wep",
+		label: "WEP",
+		note: "Encrypted in name only. The key can be recovered from captured traffic in minutes with tools that have existed since 2001, so treat a WEP network as an open one."
+	},
+	wpa2: {
+		id: "wpa2",
+		label: "WPA2, shared password",
+		note: "Genuinely encrypted against outsiders. Every user derives their key from the SAME shared password, so anyone who knows it and captured your device joining can derive your key too."
+	},
+	wpa3: {
+		id: "wpa3",
+		label: "WPA3",
+		note: "Each session negotiates its own key, so knowing the password does not let anyone decrypt anybody else. This is the actual point of WPA3 and it is rarely how it is advertised."
+	}
+};
+const LISTENERS = {
+	stranger: {
+		id: "stranger",
+		label: "Someone in range",
+		note: "A person sitting nearby who never joined the network. They receive every packet regardless, because that is what radio does."
+	},
+	customer: {
+		id: "customer",
+		label: "Another customer",
+		note: "Someone who read the same password off the same chalkboard. They are inside the network, which turns out to matter more than most people expect."
+	}
+};
+/**
+* Can this listener decrypt the radio link?
+*
+* The WEP row is the one worth reading twice. It is nominally encryption and belongs in the same
+* column as an open network, because a key that anyone can recover is not a key. Stating that in the
+* model rather than in a footnote is the difference between a student who avoids WEP and one who
+* ticks the box marked "encrypted".
+*/
+function linkReadable(protection, listener) {
+	if (protection === "open" || protection === "wep") return true;
+	if (protection === "wpa2") return listener === "customer";
+	return false;
+}
+/**
+* Everything a listener learns, most harmless first.
+*
+* Ordered that way on purpose. A list that opens with the password makes this look like a lesson
+* about passwords, and it is not: the top two rows leak on EVERY setting including the best one, and
+* a student who notices that has understood something about radio that no amount of encryption
+* changes.
+*/
+function whatTheySee(protection, transport, listener) {
+	const readable = linkReadable(protection, listener);
+	const contentReadable = readable && transport === "http";
+	return [
+		{
+			id: "presence",
+			label: "That you are here at all",
+			visible: true,
+			value: "a device transmitting, a few metres away",
+			why: "Radio cannot be made private in this respect. Anything that transmits announces that something is transmitting, on every setting there is."
+		},
+		{
+			id: "device",
+			label: "Your device's address",
+			visible: true,
+			value: "a4:83:e7:2c:91:0f",
+			why: "Addresses ride outside the encryption, because the network needs them to deliver anything at all. This is why phones now invent a new one per network."
+		},
+		{
+			id: "site",
+			label: "Which sites you visited",
+			visible: readable,
+			value: "bank.example.com, then clinic.example.org",
+			why: readable ? "The destination has to be readable by whatever carries the packet. HTTPS hides what you sent and not where you sent it." : "The link is encrypted and this listener has no key for it, so even the destinations are hidden."
+		},
+		{
+			id: "page",
+			label: "What was on the page",
+			visible: contentReadable,
+			value: "Account balance, transactions, the lot",
+			why: contentReadable ? "Plain HTTP puts the page on the air as text. Anyone who can read the link can read the page." : readable ? "HTTPS encrypts the page end to end, so reading the link is not enough." : "The link cannot be read, and the page is separately encrypted on top of that."
+		},
+		{
+			id: "credentials",
+			label: "What you typed in",
+			visible: contentReadable,
+			value: "user=you@example.com  password=OpenSesame1",
+			why: contentReadable ? "A form submitted over plain HTTP travels as text, including the password field." : readable ? "HTTPS protects what you submit even when the link around it is wide open." : "Protected twice over: the link is encrypted and so is the conversation inside it."
+		}
+	];
+}
+function judgePrivacy(protection, transport, listener) {
+	const rows = whatTheySee(protection, transport, listener);
+	const exposed = rows.filter((row) => row.visible).length;
+	const readable = linkReadable(protection, listener);
+	let headline;
+	let tone;
+	if (readable && transport === "http") {
+		headline = "Everything, including what you typed. This is a stranger reading over your shoulder.";
+		tone = "bad";
+	} else if (readable) {
+		headline = "Not the contents, but every site you visited. That alone says a great deal about you.";
+		tone = "mixed";
+	} else {
+		headline = "Only that a device is here, and its address. The link and the contents are both closed.";
+		tone = "good";
+	}
+	return {
+		exposed,
+		total: rows.length,
+		headline,
+		tone
+	};
+}
+/** The honest summary: which of the two protections fixes which hole. */
+const ADVICE = [
+	"HTTPS protects what you send from everyone, including the cafe, the network owner and your provider. It does not hide where you sent it.",
+	"A network password protects the link from outsiders. On WPA2 it does not protect you from the other people who have that same password.",
+	"WPA3 gives every session its own key, so a shared password stops being a shared key. This is the hole it was designed to close.",
+	"Nothing hides the fact that a device is transmitting, or the address it transmits with, because the network needs both to work."
+];
+
+//#endregion
+export { ADVICE, LISTENERS, PROTECTIONS, judgePrivacy, linkReadable, whatTheySee };

package/dist/networking/models/wifi.d.mts

@@ -0,0 +1,240 @@
+//#region src/networking/models/wifi.d.ts
+/**
+ * Indoor radio coverage: why the far bedroom is dead, and why moving the router two metres fixes it.
+ *
+ * Wireless is taught as a list of standards and a table of speeds, which produces students who can
+ * state that 5 GHz is faster and cannot explain why their own phone drops to 2.4 GHz in the kitchen.
+ * The thing that decides real coverage is not the standard. It is DISTANCE and WHAT IS IN THE WAY,
+ * and both are geometry, so both can be drawn.
+ *
+ * Two mechanisms, and students need to feel them separately:
+ *
+ *   Spreading. A transmitter radiates into a sphere. Double the distance and the same power is
+ *   spread over four times the area, so the received power falls with the SQUARE of distance even
+ *   with nothing in the way. Indoors it falls faster still, because energy is absorbed rather than
+ *   simply spread, which is what the path-loss exponent below carries.
+ *
+ *   Absorption. Every wall takes a fixed bite out of the signal as it passes through, and the size
+ *   of that bite depends on the material and on the frequency. This is the half that a speed table
+ *   hides completely, and it is the half that decides where a router should sit.
+ *
+ * The frequency trade is the payoff, and it is genuinely counter-intuitive: 5 GHz is the faster band
+ * and the WORSE one. A shorter wave starts about 6 dB down at the same distance and loses roughly
+ * twice as much through every wall it meets. So the honest statement is not "5 GHz is better", it is
+ * "5 GHz is faster where it reaches, and it reaches less far". A learner who has dragged a router
+ * around a floor plan owns that sentence. A learner who read a table does not.
+ *
+ * Everything here is in decibels, because absorption is multiplicative: two brick walls do not
+ * subtract twice, they halve twice. Decibels turn that into addition, which is the entire reason
+ * radio engineering uses them, and it is worth a learner meeting that reason in a place where the
+ * arithmetic is visibly easier rather than in a definition.
+ */
+/** The two bands a home or campus access point actually offers. */
+type Band = "2.4" | "5";
+interface BandSpec {
+  id: Band;
+  label: string;
+  /** Centre frequency in MHz, used for the one-metre reference loss. */
+  megahertz: number;
+  /** Non-overlapping 20 MHz channels. The reason a crowded 2.4 GHz band stays slow. */
+  channels: number;
+  /** Ceiling for a good link on this band, in Mbps, for a typical two-stream client. */
+  peakMbps: number;
+  note: string;
+}
+declare const BANDS: Record<Band, BandSpec>;
+/**
+ * Wall materials, ordered as a learner meets them: the partition you could put a fist through,
+ * up to the lift shaft nothing gets through at all.
+ */
+type WallMaterial = "drywall" | "wood" | "glass" | "brick" | "concrete" | "metal";
+interface MaterialSpec {
+  id: WallMaterial;
+  label: string;
+  /** One-way loss in dB, per band. Typical measured values for a single wall of this kind. */
+  loss: Record<Band, number>;
+  note: string;
+}
+/**
+ * Loss per wall, in dB. These are the numbers a site survey actually uses, rounded to whole
+ * decibels because the spread between real buildings is wider than the rounding.
+ *
+ * The column to read across is the band. Concrete costs 12 dB at 2.4 GHz and 20 dB at 5 GHz: the
+ * SAME wall takes eight extra decibels out of the faster band, which is a further sixfold drop in
+ * power. One interior wall is survivable on either band. Two concrete walls is where 5 GHz stops
+ * being a choice.
+ */
+declare const MATERIALS: Record<WallMaterial, MaterialSpec>;
+/** A wall segment on the plan, in metres. */
+interface Wall {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  material: WallMaterial;
+}
+/** A named rectangular room, in metres, used for per-room verdicts. */
+interface Room {
+  id: string;
+  name: string;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+/**
+ * A place a router could realistically stand, named the way someone would say it out loud.
+ *
+ * Offering named spots rather than a free drag is a teaching decision, not a technical one. A
+ * learner dragging a marker optimises by watching the colour and stops as soon as it turns green,
+ * having formed no reason. Choosing between "the corner where the cable enters" and "the hallway
+ * wall" is a choice between two things you could actually do on a Saturday, and it has to be
+ * justified before the answer appears.
+ */
+interface Spot {
+  id: string;
+  name: string;
+  x: number;
+  y: number;
+}
+interface FloorPlan {
+  id: string;
+  name: string;
+  /** Overall extent in metres, so the drawing and the physics share one coordinate system. */
+  widthM: number;
+  heightM: number;
+  rooms: Room[];
+  walls: Wall[];
+  spots: Spot[];
+  note: string;
+}
+interface Point {
+  x: number;
+  y: number;
+}
+/**
+ * Transmit power of a domestic access point, in dBm. 20 dBm is 100 mW, the legal ceiling in most
+ * places and what essentially every home router emits, which is worth knowing because it means
+ * "buy a more powerful router" is not available as an answer. The only levers are position,
+ * frequency, and a second access point.
+ */
+declare const TX_POWER_DBM = 20;
+/**
+ * How fast power falls with distance indoors.
+ *
+ * In free space the exponent is 2: pure spreading over a sphere. Indoors, 3.0 is the standard
+ * figure for a home or small office, because furniture, floors and people absorb as well as the
+ * geometry spreading. The walls are counted separately and explicitly, so this number represents
+ * everything that is NOT a wall the learner placed.
+ */
+declare const PATH_LOSS_EXPONENT = 3;
+/**
+ * The floor below which a number stops meaning anything, in dBm.
+ *
+ * Thermal noise in a 20 MHz channel sits near -101 dBm, so a receiver cannot distinguish a signal
+ * from the noise it arrives in much below this. An uncapped model happily reports -114 dBm, which
+ * looks precise and is fiction: the honest statement is "below the noise floor", and the lab should
+ * say that rather than print a number a real radio could never measure.
+ */
+declare const NOISE_FLOOR_DBM = -100;
+/**
+ * Loss over the first metre, in dB. This is where frequency enters before any wall is involved:
+ * about 40 dB at 2.4 GHz and 46 dB at 5 GHz. The faster band starts six decibels behind at the
+ * very first metre, having passed through nothing at all.
+ */
+declare function referenceLossDb(band: Band): number;
+/** The walls a straight line from the router to a point passes through. */
+declare function wallsBetween(plan: FloorPlan, from: Point, to: Point): Wall[];
+interface Reading {
+  /** Received power in dBm. Negative, and less negative is better. */
+  rssi: number;
+  distanceM: number;
+  /** Every wall on the straight path, in no particular order. */
+  obstacles: Wall[];
+  /** Total absorption from those walls, in dB. */
+  wallLossDb: number;
+}
+/**
+ * Received signal strength at a point, by the log-distance model with explicit wall terms.
+ *
+ * This treats the signal as travelling in a straight line and ignores reflection, which in a real
+ * flat delivers some signal around a corner that this model calls dead. That simplification is
+ * deliberate and is the right one for teaching: it keeps the cause of every number visible, and a
+ * model that says "a wall costs you this much" is exactly the intuition a learner should leave with.
+ */
+declare function signalAt(plan: FloorPlan, router: Point, point: Point, band: Band): Reading;
+type Grade = "excellent" | "good" | "usable" | "weak" | "dead";
+interface GradeSpec {
+  id: Grade;
+  label: string;
+  /** Lowest RSSI in dBm that still counts as this grade. */
+  floor: number;
+  /** What the learner could actually do standing here. */
+  can: string;
+}
+/**
+ * The grade ladder, in dBm.
+ *
+ * These are the thresholds a real site survey designs against rather than round numbers chosen to
+ * look tidy: -67 dBm is the industry target for voice and video, and -70 is where ordinary data
+ * starts to struggle. Naming what a learner could DO at each level, rather than calling it "3 bars",
+ * is the point. Bars are a made-up scale that differs between handsets; dBm is a measurement.
+ */
+declare const GRADES: GradeSpec[];
+declare function grade(rssi: number): GradeSpec;
+/**
+ * A rough throughput for a reading, in Mbps.
+ *
+ * Real rate selection is a ladder of modulation schemes, and the shape that matters to a learner is
+ * that throughput does not fade gently with distance: it holds up, then falls off a cliff as each
+ * rung becomes unreadable. Interpolating between the grade thresholds reproduces that staircase
+ * feel without pretending to model MCS tables.
+ */
+declare function throughputMbps(rssi: number, band: Band): number;
+interface RoomVerdict {
+  room: Room;
+  /** The weakest sample inside the room: a room is only as good as its worst corner. */
+  rssi: number;
+  grade: GradeSpec;
+  mbps: number;
+  /** Materials responsible for the worst corner, most costly first. */
+  blamed: WallMaterial[];
+}
+/**
+ * Grade every room from its WORST corner rather than its centre.
+ *
+ * Judging a room by its middle is how a coverage plan passes on paper and fails in the building:
+ * the desk is against the far wall, not in the centre of the floor. Reporting the worst sample also
+ * makes the lab honest when a learner parks the router in the hallway and every room reads "usable"
+ * from its midpoint while the bed and the desk do not.
+ */
+declare function roomVerdicts(plan: FloorPlan, router: Point, band: Band): RoomVerdict[];
+/**
+ * RSSI on a regular grid over the whole plan, for the heat map.
+ *
+ * Returned row-major as `[row][col]` with row 0 at the top, matching how the SVG draws it, so the
+ * scene never has to flip an index and quietly mirror the picture.
+ */
+declare function coverageGrid(plan: FloorPlan, router: Point, band: Band, cols: number, rows: number): number[][];
+/** Share of the rooms that reach at least `usable`, which is the number a learner is trying to raise. */
+declare function coverageScore(plan: FloorPlan, router: Point, band: Band): number;
+/**
+ * Floor plans a learner recognises, which is most of the work.
+ *
+ * A generic rectangle labelled "room A / room B" teaches the model and none of the intuition. The
+ * three-bedroom flat below is the ordinary shape of an apartment in Dhaka or Chattogram: brick
+ * partitions, a concrete wet wall around the bathroom, and the router wherever the broadband cable
+ * happened to enter, which is almost never where it should be. A learner who fixes THIS plan can
+ * walk home and fix theirs, and that transfer is the whole reason to draw a room instead of a graph.
+ */
+declare const FLOOR_PLANS: FloorPlan[];
+/**
+ * The best spot on the plan, found by trying a coarse grid of positions.
+ *
+ * Present this only AFTER a learner has committed to a position of their own. Shown first it is an
+ * answer key and they will drag toward it without forming a reason; shown second it is feedback on
+ * a guess they already had to justify, and the gap between the two is the lesson.
+ */
+declare function bestPlacement(plan: FloorPlan, band: Band, step?: number): Point;
+//#endregion
+export { BANDS, Band, BandSpec, FLOOR_PLANS, FloorPlan, GRADES, Grade, GradeSpec, MATERIALS, MaterialSpec, NOISE_FLOOR_DBM, PATH_LOSS_EXPONENT, Point, Reading, Room, RoomVerdict, Spot, TX_POWER_DBM, Wall, WallMaterial, bestPlacement, coverageGrid, coverageScore, grade, referenceLossDb, roomVerdicts, signalAt, throughputMbps, wallsBetween };