@classytic/stage 0.2.0 → 0.4.0

package/dist/networking/models/spectrum.mjs

@@ -0,0 +1,235 @@
+import { SPEED_OF_LIGHT } from "../../core/constants.mjs";
+
+//#region src/networking/models/spectrum.ts
+/**
+* The invisible spectrum: why a remote control needs to be pointed and Wi-Fi does not.
+*
+* Radio, microwave, infrared and light are one thing, and are almost always taught as four. A
+* student learns that Wi-Fi is "radio waves", that a remote uses "infrared", that 5G is "faster",
+* and nothing connects those three facts, so none of them predicts anything. They are the same
+* phenomenon at different frequencies, and almost every practical difference between them follows
+* from one number.
+*
+* The number is the wavelength, and the reason it decides everything is SIZE. A wave interacts with
+* an object according to how the object compares to its own wavelength. An FM broadcast is three
+* metres long and treats a person as though they were not there. Wi-Fi is twelve centimetres and
+* treats a brick wall as an obstacle it loses some energy to. A 5G millimetre wave is a centimetre
+* and is stopped by a hand, a leaf, or coated window glass. Infrared is a thousandth of a
+* millimetre and is stopped by anything at all, which is why the remote has to see the television.
+*
+* So this table exists to be sorted and compared rather than recited. The derived quantities are
+* computed from the frequency instead of stored, because the whole claim of the lesson is that they
+* FOLLOW from it: change the frequency and the wavelength, the antenna and the ability to cross a
+* wall all move together, and a learner who has watched them move together owns the relationship.
+*
+* It also settles the single most common misconception about Wi-Fi in one line. A microwave oven
+* runs at 2.45 GHz and a Wi-Fi router runs at 2.437 GHz. They are the same band. The oven is not
+* interfering with the network by coincidence or by poor design: it is shouting on the channel.
+*/
+/**
+* Speed of light in a vacuum, m/s. The one constant the whole table is derived
+* from, and re-exported rather than re-declared: it was a fourth independent
+* copy of a number that is EXACT by definition of the metre.
+*/
+const C = SPEED_OF_LIGHT;
+/**
+* Real centre frequencies, in the order a learner should meet them: longest wave first, because the
+* story is what happens as the wave gets shorter.
+*/
+const SPECTRUM = [
+	{
+		id: "am",
+		label: "AM radio",
+		hz: 1e6,
+		use: "Medium-wave broadcast",
+		penetration: "through-anything",
+		compare: "three football pitches end to end",
+		compareM: 300,
+		note: "A 300 m wave bends around hills and buildings as though they were pebbles, which is why one transmitter can cover a region and why AM still works in a valley."
+	},
+	{
+		id: "fm",
+		label: "FM radio",
+		hz: 1e8,
+		use: "VHF broadcast",
+		penetration: "through-anything",
+		compare: "a small car",
+		compareM: 3,
+		note: "Still long enough to ignore a person entirely. Notice the aerial on an older car: it is a metre or so, which is not decoration."
+	},
+	{
+		id: "tv",
+		label: "UHF television",
+		hz: 6e8,
+		use: "Terrestrial TV, and the low 4G bands beside it",
+		penetration: "through-walls",
+		compare: "a forearm",
+		compareM: .5,
+		note: "The band mobile operators fought hardest for, because at this wavelength one tower covers a large area and still reaches indoors."
+	},
+	{
+		id: "cell-low",
+		label: "4G / 5G low band",
+		hz: 8e8,
+		use: "Wide-area mobile coverage",
+		penetration: "through-walls",
+		compare: "a forearm",
+		compareM: .4,
+		note: "This is the band that gives a rural village a signal at all. It carries less data than the high bands and reaches many times further."
+	},
+	{
+		id: "cell-mid",
+		label: "4G / 5G mid band",
+		hz: 21e8,
+		use: "The usual city mobile band",
+		penetration: "through-one-wall",
+		compare: "the width of a hand",
+		compareM: .1,
+		note: "The working compromise: enough capacity for a crowded city, enough reach to serve it from a practical number of towers."
+	},
+	{
+		id: "wifi24",
+		label: "Wi-Fi 2.4 GHz",
+		hz: 2437e6,
+		use: "The long-range Wi-Fi band",
+		penetration: "through-one-wall",
+		compare: "the width of a hand",
+		compareM: .1,
+		note: "Only three non-overlapping channels, shared with every neighbour, every Bluetooth device, and the oven below."
+	},
+	{
+		id: "oven",
+		label: "Microwave oven",
+		hz: 245e7,
+		use: "Heating water in food",
+		penetration: "through-one-wall",
+		compare: "the width of a hand",
+		compareM: .1,
+		note: "The same band as Wi-Fi, which is the whole explanation for why a running oven slows the network. It is not interference by accident: it is a kilowatt transmitting on your channel behind a metal screen."
+	},
+	{
+		id: "wifi5",
+		label: "Wi-Fi 5 GHz",
+		hz: 518e7,
+		use: "The fast Wi-Fi band",
+		penetration: "through-one-wall",
+		compare: "a thumb",
+		compareM: .06,
+		note: "Far more channels and far more speed, and it pays for both in range. A shorter wave is absorbed harder by every wall it meets."
+	},
+	{
+		id: "satellite",
+		label: "Satellite Ku band",
+		hz: 12e9,
+		use: "Television and internet from orbit",
+		penetration: "blocked",
+		compare: "a walnut",
+		compareM: .025,
+		note: "Needs a clear view of the sky, and heavy rain absorbs it. This is what a dish is for: at this wavelength a reflector that size makes a very narrow beam."
+	},
+	{
+		id: "mmwave",
+		label: "5G millimetre wave",
+		hz: 28e9,
+		use: "Very high capacity over very short range",
+		penetration: "blocked",
+		compare: "a fingernail",
+		compareM: .012,
+		note: "Enormous capacity, and a hand over the phone can interrupt it. Deployed on stadium and street-corner scales rather than as coverage, which is why most people never meet it despite the advertising."
+	},
+	{
+		id: "infrared",
+		label: "Infrared remote",
+		hz: 319e12,
+		use: "Television and air-conditioner remotes",
+		penetration: "line-of-sight",
+		compare: "a bacterium",
+		compareM: 1e-6,
+		note: "A thousandth of a millimetre. It cannot pass a wall, a sofa, or your hand, which is why a remote must be pointed and Wi-Fi never is. Bouncing it off a white wall works, and off a dark curtain does not."
+	},
+	{
+		id: "visible",
+		label: "Visible light",
+		hz: 54e13,
+		use: "Seeing, and fibre optics just beyond it",
+		penetration: "line-of-sight",
+		compare: "a bacterium",
+		compareM: 1e-6,
+		note: "The same phenomenon, a little further along. The only reason this band feels different is that you have a detector for it in your head."
+	}
+];
+/** Wavelength in metres. Everything visual about a band comes from this one division. */
+const wavelengthM = (hz) => C / hz;
+/**
+* Quarter-wave antenna length in metres, the classic first-order rule.
+*
+* It is worth computing rather than asserting, because it explains hardware a learner has already
+* seen and never questioned: the metre-long whip on an old car radio, the few centimetres inside a
+* phone, and the fact that a 5G millimetre-wave antenna is small enough to put dozens on one chip.
+*/
+const quarterWaveM = (hz) => wavelengthM(hz) / 4;
+/** A length in the largest unit that keeps it readable, which is how a person would say it. */
+function humanLength(metres) {
+	if (metres >= 1e3) return `${(metres / 1e3).toFixed(metres / 1e3 < 10 ? 1 : 0)} km`;
+	if (metres >= 1) return `${metres < 10 ? metres.toFixed(1) : metres.toFixed(0)} m`;
+	if (metres >= .01) return `${(metres * 100).toFixed(metres * 100 < 10 ? 1 : 0)} cm`;
+	if (metres >= .001) return `${(metres * 1e3).toFixed(1)} mm`;
+	if (metres >= 1e-6) return `${(metres * 1e6).toFixed(2)} µm`;
+	return `${(metres * 1e9).toFixed(0)} nm`;
+}
+/** A frequency in the unit it is normally quoted in. */
+function humanFrequency(hz) {
+	if (hz >= 0xe8d4a51000) return `${(hz / 0xe8d4a51000).toFixed(0)} THz`;
+	if (hz >= 1e9) return `${(hz / 1e9).toFixed(hz / 1e9 < 10 ? 2 : 0)} GHz`;
+	if (hz >= 1e6) return `${(hz / 1e6).toFixed(0)} MHz`;
+	return `${(hz / 1e3).toFixed(0)} kHz`;
+}
+const PENETRATION = {
+	"through-anything": {
+		id: "through-anything",
+		label: "Passes almost everything",
+		stoppedBy: "Very little. It bends around hills and buildings."
+	},
+	"through-walls": {
+		id: "through-walls",
+		label: "Passes several walls",
+		stoppedBy: "Thick concrete and steel, eventually."
+	},
+	"through-one-wall": {
+		id: "through-one-wall",
+		label: "Passes a wall, weakened",
+		stoppedBy: "Each wall takes a bite. Two concrete walls is usually the end of it."
+	},
+	blocked: {
+		id: "blocked",
+		label: "Stopped by almost anything",
+		stoppedBy: "A wall, a window, a leaf, a hand."
+	},
+	"line-of-sight": {
+		id: "line-of-sight",
+		label: "Needs to see the receiver",
+		stoppedBy: "Anything opaque, including a sheet of paper."
+	}
+};
+/**
+* Position on a logarithmic axis from 0 (left) to 1 (right).
+*
+* The axis has to be logarithmic because the table spans nine orders of magnitude: on a linear
+* scale every radio band would pile into the first pixel and the lesson would be invisible. Worth
+* saying to a learner rather than hiding, since "the axis multiplies instead of adding" is itself
+* one of the more useful things this figure can teach.
+*/
+function logPosition(hz, fromHz = 1e5, toHz = 0x38d7ea4c68000) {
+	const span = Math.log10(toHz) - Math.log10(fromHz);
+	return Math.min(1, Math.max(0, (Math.log10(hz) - Math.log10(fromHz)) / span));
+}
+/** The decade ticks an axis should carry between two frequencies. */
+function decades(fromHz = 1e5, toHz = 0x38d7ea4c68000) {
+	const ticks = [];
+	for (let power = Math.ceil(Math.log10(fromHz)); power <= Math.log10(toHz); power++) ticks.push(10 ** power);
+	return ticks;
+}
+const bandById = (id) => SPECTRUM.find((band) => band.id === id) ?? SPECTRUM[0];
+
+//#endregion
+export { C, PENETRATION, SPECTRUM, bandById, decades, humanFrequency, humanLength, logPosition, quarterWaveM, wavelengthM };

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

@@ -0,0 +1,80 @@
+//#region src/networking/models/switch.d.ts
+/**
+ * What a switch actually does, which is smaller and stranger than most courses admit.
+ *
+ * A switch is not told where anything is. It starts knowing nothing, and it learns by watching
+ * the SOURCE address of every frame that arrives: "that device is reachable through port 3,
+ * because a frame from it just came in on port 3". Until it has learned a destination it floods,
+ * sending the frame everywhere except back the way it came.
+ *
+ * That is the whole mechanism, and it produces the behaviour students are usually asked to
+ * memorise instead: the first frame to a new device goes everywhere, the second goes to one port,
+ * and a switch with an empty table behaves exactly like the hub it replaced.
+ */
+interface SwitchDevice {
+  name: string;
+  mac: string;
+}
+interface SwitchPort {
+  /** 1-based, as printed on real hardware. */
+  id: number;
+  /** A disabled port is administratively down: no link, no traffic, no learning. */
+  enabled: boolean;
+  device?: SwitchDevice;
+}
+interface MacEntry {
+  mac: string;
+  port: number;
+}
+interface SwitchState {
+  ports: SwitchPort[];
+  /** The forwarding table, learned entirely from traffic. */
+  table: MacEntry[];
+}
+type SwitchEvent = {
+  type: "ingress";
+  port: number;
+  srcMac: string;
+  dstMac: string;
+  message: string;
+} | {
+  type: "learn";
+  mac: string;
+  port: number;
+  relearned: boolean;
+  message: string;
+} | {
+  type: "flood";
+  ports: number[];
+  message: string;
+} | {
+  type: "forward";
+  port: number;
+  message: string;
+} | {
+  type: "drop";
+  reason: "port-down" | "no-link" | "same-port";
+  message: string;
+};
+interface FrameResult {
+  events: SwitchEvent[];
+  next: SwitchState;
+  /** Ports the frame actually left by. Empty when it was dropped. */
+  delivered: number[];
+  flooded: boolean;
+}
+declare const linkUp: (port: SwitchPort) => boolean;
+/**
+ * Send one frame in through `fromPort` and resolve what the switch does with it.
+ *
+ * Pure: returns the next state rather than mutating, so a lesson can step forward and back.
+ */
+declare function sendFrame(state: SwitchState, fromPort: number, dstMac: string): FrameResult;
+/** Toggle a port up or down. A port going down forgets what was learned through it. */
+declare function setPortEnabled(state: SwitchState, portId: number, enabled: boolean): SwitchState;
+/** Clear the forwarding table, which returns the switch to the day it was unboxed. */
+declare const clearTable: (state: SwitchState) => SwitchState;
+/** A switch with `size` ports, the first `connected` of them holding a device. */
+declare function makeSwitch(size?: number, connected?: number): SwitchState;
+//#endregion
+export { FrameResult, MacEntry, SwitchDevice, SwitchEvent, SwitchPort, SwitchState, clearTable, linkUp, makeSwitch, sendFrame, setPortEnabled };

package/dist/networking/models/switch.mjs

@@ -0,0 +1,155 @@
+//#region src/networking/models/switch.ts
+const linkUp = (port) => port.enabled && !!port.device;
+const portOf = (state, mac) => state.table.find((entry) => entry.mac === mac)?.port;
+const deviceName = (state, mac) => state.ports.find((port) => port.device?.mac === mac)?.device?.name ?? mac;
+/**
+* Send one frame in through `fromPort` and resolve what the switch does with it.
+*
+* Pure: returns the next state rather than mutating, so a lesson can step forward and back.
+*/
+function sendFrame(state, fromPort, dstMac) {
+	const events = [];
+	const ingress = state.ports.find((port) => port.id === fromPort);
+	const srcMac = ingress?.device?.mac ?? "";
+	if (!ingress || !ingress.enabled) {
+		events.push({
+			type: "drop",
+			reason: "port-down",
+			message: `Port ${fromPort} is disabled, so nothing can enter through it.`
+		});
+		return {
+			events,
+			next: state,
+			delivered: [],
+			flooded: false
+		};
+	}
+	if (!ingress.device) {
+		events.push({
+			type: "drop",
+			reason: "no-link",
+			message: `Port ${fromPort} has nothing plugged into it.`
+		});
+		return {
+			events,
+			next: state,
+			delivered: [],
+			flooded: false
+		};
+	}
+	events.push({
+		type: "ingress",
+		port: fromPort,
+		srcMac,
+		dstMac,
+		message: `A frame from ${ingress.device.name} arrives on port ${fromPort}, addressed to ${deviceName(state, dstMac)}.`
+	});
+	const known = state.table.find((entry) => entry.mac === srcMac);
+	const relearned = !!known && known.port !== fromPort;
+	const table = [...state.table.filter((entry) => entry.mac !== srcMac), {
+		mac: srcMac,
+		port: fromPort
+	}].sort((a, b) => a.port - b.port || a.mac.localeCompare(b.mac));
+	if (!known || relearned) events.push({
+		type: "learn",
+		mac: srcMac,
+		port: fromPort,
+		relearned,
+		message: relearned ? `${ingress.device.name} has moved. The table now says port ${fromPort}.` : `Learned: ${ingress.device.name} is reachable through port ${fromPort}.`
+	});
+	const next = {
+		ports: state.ports,
+		table
+	};
+	const target = portOf(next, dstMac);
+	if (target === fromPort) {
+		events.push({
+			type: "drop",
+			reason: "same-port",
+			message: `The destination is on the port the frame arrived from, so the switch does not send it back out.`
+		});
+		return {
+			events,
+			next,
+			delivered: [],
+			flooded: false
+		};
+	}
+	if (target !== void 0 && linkUp(state.ports.find((port) => port.id === target))) {
+		events.push({
+			type: "forward",
+			port: target,
+			message: `The table knows this address, so the frame goes out of port ${target} only. No other device sees it.`
+		});
+		return {
+			events,
+			next,
+			delivered: [target],
+			flooded: false
+		};
+	}
+	const flooded = next.ports.filter((port) => port.id !== fromPort && linkUp(port)).map((port) => port.id);
+	events.push({
+		type: "flood",
+		ports: flooded,
+		message: flooded.length ? `This address is not in the table, so the switch floods: out of every connected port except ${fromPort}.` : `This address is not in the table, and no other port has a link, so there is nowhere to flood.`
+	});
+	return {
+		events,
+		next,
+		delivered: flooded,
+		flooded: true
+	};
+}
+/** Toggle a port up or down. A port going down forgets what was learned through it. */
+function setPortEnabled(state, portId, enabled) {
+	return {
+		ports: state.ports.map((port) => port.id === portId ? {
+			...port,
+			enabled
+		} : port),
+		table: enabled ? state.table : state.table.filter((entry) => entry.port !== portId)
+	};
+}
+/** Clear the forwarding table, which returns the switch to the day it was unboxed. */
+const clearTable = (state) => ({
+	ports: state.ports,
+	table: []
+});
+const MACS = [
+	"AA:01",
+	"BB:02",
+	"CC:03",
+	"DD:04",
+	"EE:05",
+	"FF:06",
+	"11:07",
+	"22:08"
+];
+const NAMES = [
+	"Laptop",
+	"Desktop",
+	"Printer",
+	"Server",
+	"Phone",
+	"Camera",
+	"NAS",
+	"TV"
+];
+/** A switch with `size` ports, the first `connected` of them holding a device. */
+function makeSwitch(size = 8, connected = 4) {
+	return {
+		ports: Array.from({ length: size }, (_, index) => ({
+			id: index + 1,
+			enabled: true,
+			device: index < connected ? {
+				name: NAMES[index],
+				mac: MACS[index]
+			} : void 0
+		})),
+		table: []
+	};
+}
+
+//#endregion
+export { clearTable, linkUp, makeSwitch, sendFrame, setPortEnabled };

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

@@ -0,0 +1,62 @@
+//#region src/networking/models/vlan.d.ts
+/**
+ * VLANs: one physical switch behaving as several separate ones.
+ *
+ * The idea students are given is "a VLAN is a virtual LAN", which explains nothing. The idea that
+ * works is narrower and testable: a VLAN is a BROADCAST DOMAIN. A frame sent to everyone reaches
+ * every port in its own VLAN and no others, even though all of them are in the same box on the
+ * same power supply.
+ *
+ * The second half is the part usually left out, and it is the interesting one. If VLANs are truly
+ * isolated at layer 2, how does anything ever cross between them? It cannot, until something that
+ * works at layer 3 is added, and then every crossing goes through that thing. Which is exactly why
+ * putting two departments on separate VLANs gives you a place to enforce a policy between them.
+ */
+interface Vlan {
+  id: number;
+  name: string;
+}
+interface VlanPort {
+  id: number;
+  /** The VLAN this access port belongs to. */
+  vlan: number;
+  enabled: boolean;
+  device?: {
+    name: string;
+  };
+}
+interface VlanState {
+  vlans: Vlan[];
+  ports: VlanPort[];
+  /** A layer-3 interface that can route between VLANs. Off by default, which is the point. */
+  routing: boolean;
+}
+declare const isLive: (port: VlanPort) => boolean;
+/** Ports in the same VLAN as `portId`, excluding itself. */
+declare function domainOf(state: VlanState, portId: number): number[];
+interface BroadcastResult {
+  reached: number[];
+  /** Live ports that did NOT receive it, because they are in another VLAN. */
+  blocked: number[];
+  message: string;
+}
+/** A broadcast reaches its own VLAN and stops there. Routing does not change that. */
+declare function broadcastFrom(state: VlanState, portId: number): BroadcastResult;
+interface DeliveryResult {
+  delivered: boolean;
+  viaRouter: boolean;
+  message: string;
+}
+/**
+ * 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.
+ */
+declare function sendBetween(state: VlanState, fromPort: number, toPort: number): DeliveryResult;
+declare function setPortVlan(state: VlanState, portId: number, vlan: number): VlanState;
+declare const setRouting: (state: VlanState, routing: boolean) => VlanState;
+/** How many separate broadcast domains this switch is currently carrying. */
+declare const domainCount: (state: VlanState) => number;
+/** Eight ports, the first `connected` holding a device, split evenly across two VLANs. */
+declare function makeVlanSwitch(connected?: number): VlanState;
+//#endregion
+export { BroadcastResult, DeliveryResult, Vlan, VlanPort, VlanState, broadcastFrom, domainCount, domainOf, isLive, makeVlanSwitch, sendBetween, setPortVlan, setRouting };

package/dist/networking/models/vlan.mjs

@@ -0,0 +1,100 @@
+//#region src/networking/models/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, domainOf, isLive, makeVlanSwitch, sendBetween, setPortVlan, setRouting };