@classytic/labs 0.3.0 → 0.4.0

package/dist/math/complex/core.mjs

@@ -1,239 +0,0 @@
-import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
-
-//#region src/math/complex/core.ts
-var core_exports = /* @__PURE__ */ __exportAll({
-	DEG2RAD: () => DEG2RAD,
-	I: () => I,
-	MAX_POW: () => MAX_POW,
-	MAX_ROOTS: () => 360,
-	ONE: () => ONE,
-	RAD2DEG: () => RAD2DEG,
-	TWO_PI: () => TWO_PI,
-	ZERO: () => ZERO,
-	abs: () => abs,
-	add: () => add,
-	arg: () => arg,
-	argDeg: () => argDeg,
-	conj: () => conj,
-	cx: () => cx,
-	div: () => div,
-	eq: () => eq,
-	fromPolar: () => fromPolar,
-	iPow: () => iPow,
-	isFiniteC: () => isFiniteC,
-	mul: () => mul,
-	neg: () => neg,
-	nthRoots: () => nthRoots,
-	omega: () => omega,
-	powInt: () => powInt,
-	rootsOfUnity: () => rootsOfUnity,
-	scale: () => scale,
-	sub: () => sub,
-	toPolar: () => toPolar,
-	toStr: () => toStr,
-	toTex: () => toTex
-});
-const TWO_PI = Math.PI * 2;
-const RAD2DEG = 180 / Math.PI;
-const DEG2RAD = Math.PI / 180;
-/** Hard caps so an authored value can never blow memory or hang a loop. */
-const MAX_POW = 1024;
-const MAX_ROOTS = 360;
-const cx = (re, im = 0) => ({
-	re,
-	im
-});
-const ZERO = {
-	re: 0,
-	im: 0
-};
-const ONE = {
-	re: 1,
-	im: 0
-};
-const I = {
-	re: 0,
-	im: 1
-};
-const isFiniteC = (z) => Number.isFinite(z.re) && Number.isFinite(z.im);
-const add = (a, b) => ({
-	re: a.re + b.re,
-	im: a.im + b.im
-});
-const sub = (a, b) => ({
-	re: a.re - b.re,
-	im: a.im - b.im
-});
-const neg = (a) => ({
-	re: -a.re,
-	im: -a.im
-});
-const conj = (a) => ({
-	re: a.re,
-	im: -a.im
-});
-const scale = (a, k) => ({
-	re: a.re * k,
-	im: a.im * k
-});
-/** (a+bi)(c+di) = (ac − bd) + (ad + bc)i. */
-const mul = (a, b) => ({
-	re: a.re * b.re - a.im * b.im,
-	im: a.re * b.im + a.im * b.re
-});
-/**
-* Complex division via Smith's algorithm: divide through by the LARGER of the
-* denominator's components so the intermediate ratio stays in [−1, 1] (no
-* overflow when |b| is huge, no underflow when tiny). Returns an ∞/NaN complex
-* for a (near-)zero denominator rather than throwing.
-*/
-function div(a, b) {
-	const { re: c, im: d } = b;
-	if (c === 0 && d === 0) return {
-		re: a.re / 0,
-		im: a.im / 0
-	};
-	if (Math.abs(c) >= Math.abs(d)) {
-		const r = d / c, den = c + d * r;
-		return {
-			re: (a.re + a.im * r) / den,
-			im: (a.im - a.re * r) / den
-		};
-	}
-	const r = c / d, den = c * r + d;
-	return {
-		re: (a.re * r + a.im) / den,
-		im: (a.im * r - a.re) / den
-	};
-}
-/** Modulus |z| = √(re² + im²), via hypot so large components don't overflow. */
-const abs = (z) => Math.hypot(z.re, z.im);
-/** Argument arg(z) in RADIANS, in (−π, π]. arg(0) = 0 by convention. */
-const arg = (z) => z.re === 0 && z.im === 0 ? 0 : Math.atan2(z.im, z.re);
-/** Argument in DEGREES, in (−180, 180]. */
-const argDeg = (z) => arg(z) * RAD2DEG;
-/** Polar → rectangular: r·e^{iθ} = r(cosθ + i sinθ), θ in radians. */
-const fromPolar = (r, theta) => ({
-	re: r * Math.cos(theta),
-	im: r * Math.sin(theta)
-});
-/** Rectangular → polar { r, theta(rad) }. */
-const toPolar = (z) => ({
-	r: abs(z),
-	theta: arg(z)
-});
-/**
-* iⁿ for any integer n, EXACTLY (no De Moivre float drift): the 4-cycle
-* 1, i, −1, −i. Negative n handled by the (n mod 4 + 4) mod 4 normalisation.
-*/
-function iPow(n) {
-	if (!Number.isInteger(n)) return {
-		re: NaN,
-		im: NaN
-	};
-	switch ((n % 4 + 4) % 4) {
-		case 0: return {
-			re: 1,
-			im: 0
-		};
-		case 1: return {
-			re: 0,
-			im: 1
-		};
-		case 2: return {
-			re: -1,
-			im: 0
-		};
-		default: return {
-			re: 0,
-			im: -1
-		};
-	}
-}
-/**
-* zⁿ for an INTEGER n via exponentiation-by-squaring (negative n inverts).
-* |n| is capped at MAX_POW; an overflowing magnitude returns an explicit ∞
-* complex (finite check) instead of looping into garbage.
-*/
-function powInt(z, n) {
-	if (!Number.isInteger(n)) return {
-		re: NaN,
-		im: NaN
-	};
-	if (Math.abs(n) > 1024) return {
-		re: Infinity,
-		im: Infinity
-	};
-	if (n === 0) return { ...ONE };
-	let base = n < 0 ? div(ONE, z) : z;
-	let e = Math.abs(n);
-	let acc = { ...ONE };
-	while (e > 0) {
-		if (e & 1) acc = mul(acc, base);
-		e >>= 1;
-		if (e > 0) base = mul(base, base);
-		if (!isFiniteC(acc)) return {
-			re: Infinity,
-			im: Infinity
-		};
-	}
-	return acc;
-}
-/** Clamp an nth-root count to a safe, sane range [1, MAX_ROOTS]. */
-const safeN = (n) => Number.isInteger(n) && n >= 1 ? Math.min(n, 360) : 1;
-/**
-* The n nth-roots of UNITY: e^{2πik/n}, k = 0…n−1 (so ω = roots[1] is the
-* primitive root). For n = 2 → {1, −1}; n = 3 → {1, ω, ω²}; n = 4 → {1, i, −1, −i}.
-* n is clamped to [1, MAX_ROOTS]. The k = n/2 (real −1) and k = 0 (real 1) entries
-* are snapped to exact values so labels read cleanly.
-*/
-function rootsOfUnity(n) {
-	const m = safeN(n);
-	return Array.from({ length: m }, (_, k) => {
-		if (k === 0) return {
-			re: 1,
-			im: 0
-		};
-		if (m % 2 === 0 && k === m / 2) return {
-			re: -1,
-			im: 0
-		};
-		return fromPolar(1, TWO_PI * k / m);
-	});
-}
-/** The n nth-roots of any z: |z|^{1/n} · e^{i(arg z + 2πk)/n}, k = 0…n−1. */
-function nthRoots(z, n) {
-	const m = safeN(n);
-	const { r, theta } = toPolar(z);
-	const root = Math.pow(r, 1 / m);
-	return Array.from({ length: m }, (_, k) => fromPolar(root, (theta + TWO_PI * k) / m));
-}
-/** The primitive nth root of unity ω (default the CUBE root, n = 3): e^{2πi/n}.
-*  For n = 3: ω = −½ + (√3/2)i, with ω³ = 1 and 1 + ω + ω² = 0. */
-const omega = (n = 3) => fromPolar(1, TWO_PI / safeN(n));
-/** Equal within a tolerance (default 1e-9), on both components. */
-const eq = (a, b, eps = 1e-9) => Math.abs(a.re - b.re) <= eps && Math.abs(a.im - b.im) <= eps;
-const numStr = (n, dp) => {
-	if (!Number.isFinite(n)) return n > 0 ? "∞" : "−∞";
-	const r = Math.round(n * 10 ** dp) / 10 ** dp;
-	return Object.is(r, -0) ? "0" : String(r).replace(/^-/, "−");
-};
-/** Plain string, e.g. "3 − 2i", "i", "−1", "0", "2i". */
-function toStr(z, dp = 2) {
-	if (!isFiniteC(z)) return "∞";
-	const re = Math.round(z.re * 10 ** dp) / 10 ** dp;
-	const im = Math.round(z.im * 10 ** dp) / 10 ** dp;
-	if (im === 0) return numStr(re, dp);
-	const imPart = im === 1 ? "i" : im === -1 ? "−i" : `${numStr(Math.abs(im), dp)}i`;
-	if (re === 0) return im < 0 && im !== -1 ? `−${imPart}` : im === -1 ? "−i" : imPart;
-	const sign = im < 0 ? "−" : "+";
-	const mag = Math.abs(im) === 1 ? "i" : `${numStr(Math.abs(im), dp)}i`;
-	return `${numStr(re, dp)} ${sign} ${mag}`;
-}
-/** LaTeX form for <Tex> (uses real minus signs, "i"). */
-function toTex(z, dp = 2) {
-	return toStr(z, dp).replace(/−/g, "-");
-}
-
-//#endregion
-export { I, ONE, ZERO, abs, add, arg, argDeg, core_exports, cx, div, eq, fromPolar, iPow, isFiniteC, mul, powInt, rootsOfUnity, sub, toStr, toTex };

package/dist/math/poly/core.d.mts

@@ -1,50 +0,0 @@
-import { Complex } from "../complex/core.mjs";
-import { Node } from "@classytic/stage";
-
-//#region src/math/poly/core.d.ts
-declare namespace core_d_exports {
-  export { Poly, PolyRoots, add, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };
-}
-type Poly = number[];
-declare const trim: (p: Poly) => Poly;
-declare const degree: (p: Poly) => number;
-/** Horner evaluation (real). */
-declare function evalPoly(p: Poly, x: number): number;
-/** Horner evaluation (complex). */
-declare function evalC(p: Poly, z: Complex): Complex;
-/** Derivative polynomial. */
-declare const deriv: (p: Poly) => Poly;
-declare function add(a: Poly, b: Poly): Poly;
-declare function mul(a: Poly, b: Poly): Poly;
-/** Synthetic division of p by (x − r); returns the quotient (assumes r is a root,
- *  i.e. drops the remainder). The "divide out a found factor" step. */
-declare function deflate(p: Poly, r: number): Poly;
-/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
-declare function polyTex(p0: Poly, x?: string): string;
-/** Coefficients of `node` as a polynomial in `x` (other vars from `params`), or
- *  null if it isn't a polynomial in x (sin(x), 1/x, fractional power, …). */
-declare function fromAst(node: Node, x?: string, params?: Record<string, number>): Poly | null;
-/**
- * All complex roots of `p` via Durand–Kerner simultaneous iteration (then snapped).
- * For a degree-n polynomial returns n roots; real roots come back with im = 0.
- */
-declare function allRoots(p0: Poly): Complex[];
-interface PolyRoots {
-  poly: Poly;
-  degree: number;
-  roots: Complex[];
-  realRoots: number[];
-}
-/** Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate. */
-declare function solve(p0: Poly): PolyRoots | null;
-/** Solve an expression-AST equation `expr = 0` for x, any degree. null if not a
- *  polynomial in x. (Linear/quadratic also flow through here, exactly.) */
-declare function solveEquation(node: Node, x?: string, params?: Record<string, number>): PolyRoots | null;
-/**
- * Factored form of the polynomial over the reals: leading coefficient × linear
- * factors (real roots, with multiplicity) × irreducible quadratics (complex
- * conjugate pairs). e.g. x³−6x²+11x−6 → "(x − 1)(x − 2)(x − 3)".
- */
-declare function factorTex(p0: Poly, x?: string): string;
-//#endregion
-export { Poly, PolyRoots, add, allRoots, core_d_exports, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };

package/dist/math/poly/core.mjs

@@ -1,268 +0,0 @@
-import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
-import { ONE, ZERO, abs, add as add$1, cx, div, fromPolar, isFiniteC, mul as mul$1, sub } from "../complex/core.mjs";
-import { evaluate } from "@classytic/stage";
-
-//#region src/math/poly/core.ts
-/**
-* Polynomial core, the canonical single-variable polynomial engine. The clean,
-* focused alternative to bolting on a heavy general CAS (Algebrite / nerdamer):
-* for the polynomial algebra school actually needs — expand, evaluate,
-* differentiate, FACTOR, and SOLVE any degree — a normalised coefficient form
-* makes everything fall out.
-*
-*   • a Poly is just `number[]` ascending: [a0, a1, …, an] = a0 + a1 x + … + an xⁿ.
-*   • roots of ANY degree via DURAND–KERNER (Weierstrass) simultaneous iteration,
-*     reusing the complex kernel — all n complex roots at once, then snapped to
-*     exact rationals where they're clearly nice (so 2, ½, −3 print exact, not
-*     1.9999999).
-*   • factored form is read straight off the cleaned roots (real → (x−r);
-*     complex pair → an irreducible real quadratic).
-*
-* Numerically safe: Durand–Kerner is capped at MAX_ITER and falls back gracefully;
-* coefficient arrays are trimmed; no overflow paths (the complex kernel guards div).
-*/
-var core_exports = /* @__PURE__ */ __exportAll({
-	add: () => add,
-	allRoots: () => allRoots,
-	deflate: () => deflate,
-	degree: () => degree,
-	deriv: () => deriv,
-	evalC: () => evalC,
-	evalPoly: () => evalPoly,
-	factorTex: () => factorTex,
-	fromAst: () => fromAst,
-	mul: () => mul,
-	polyTex: () => polyTex,
-	solve: () => solve,
-	solveEquation: () => solveEquation,
-	trim: () => trim
-});
-const EPS = 1e-9;
-const MAX_ITER = 300;
-const MAX_DEG = 8;
-const trim = (p) => {
-	let n = p.length;
-	while (n > 1 && Math.abs(p[n - 1]) < 1e-12) n--;
-	return p.slice(0, n);
-};
-const degree = (p) => trim(p).length - 1;
-/** Horner evaluation (real). */
-function evalPoly(p, x) {
-	let s = 0;
-	for (let i = p.length - 1; i >= 0; i--) s = s * x + (p[i] ?? 0);
-	return s;
-}
-/** Horner evaluation (complex). */
-function evalC(p, z) {
-	let s = ZERO;
-	for (let i = p.length - 1; i >= 0; i--) s = add$1(mul$1(s, z), cx(p[i] ?? 0));
-	return s;
-}
-/** Derivative polynomial. */
-const deriv = (p) => trim(p.slice(1).map((c, i) => c * (i + 1)));
-function add(a, b) {
-	const n = Math.max(a.length, b.length), o = [];
-	for (let i = 0; i < n; i++) o.push((a[i] ?? 0) + (b[i] ?? 0));
-	return trim(o);
-}
-function mul(a, b) {
-	const o = new Array(a.length + b.length - 1).fill(0);
-	for (let i = 0; i < a.length; i++) for (let j = 0; j < b.length; j++) o[i + j] += a[i] * b[j];
-	return trim(o);
-}
-/** Synthetic division of p by (x − r); returns the quotient (assumes r is a root,
-*  i.e. drops the remainder). The "divide out a found factor" step. */
-function deflate(p, r) {
-	const n = p.length - 1;
-	if (n < 1) return [0];
-	const q = new Array(n).fill(0);
-	q[n - 1] = p[n];
-	for (let k = n - 2; k >= 0; k--) q[k] = p[k + 1] + r * q[k + 1];
-	return trim(q);
-}
-const tnum = (n) => {
-	const r = Math.round(n * 1e6) / 1e6;
-	return (Object.is(r, -0) ? 0 : r).toString();
-};
-/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
-function polyTex(p0, x = "x") {
-	const p = trim(p0);
-	let out = "";
-	for (let d = p.length - 1; d >= 0; d--) {
-		const c = p[d];
-		if (c === 0) continue;
-		const mag = Math.abs(c);
-		const t = `${d === 0 ? tnum(mag) : mag === 1 ? "" : tnum(mag)}${d === 0 ? "" : d === 1 ? x : `${x}^{${d}}`}`;
-		out += out === "" ? c < 0 ? `-${t}` : t : c < 0 ? ` - ${t}` : ` + ${t}`;
-	}
-	return out || "0";
-}
-function hasVar(node, x) {
-	switch (node.type) {
-		case "var": return node.name === x;
-		case "neg": return hasVar(node.arg, x);
-		case "binary": return hasVar(node.left, x) || hasVar(node.right, x);
-		case "call": return node.args.some((a) => hasVar(a, x));
-		default: return false;
-	}
-}
-/** Coefficients of `node` as a polynomial in `x` (other vars from `params`), or
-*  null if it isn't a polynomial in x (sin(x), 1/x, fractional power, …). */
-function fromAst(node, x = "x", params = {}) {
-	if (!hasVar(node, x)) {
-		const v = evaluate(node, params);
-		return Number.isFinite(v) ? [v] : null;
-	}
-	switch (node.type) {
-		case "var": return [0, 1];
-		case "neg": {
-			const c = fromAst(node.arg, x, params);
-			return c && c.map((k) => -k);
-		}
-		case "binary": {
-			const { op, left, right } = node;
-			const L = fromAst(left, x, params);
-			if (!L) return null;
-			if (op === "+") {
-				const R = fromAst(right, x, params);
-				return R && add(L, R);
-			}
-			if (op === "-") {
-				const R = fromAst(right, x, params);
-				return R && add(L, R.map((k) => -k));
-			}
-			if (op === "*") {
-				const R = fromAst(right, x, params);
-				return R && mul(L, R);
-			}
-			if (op === "/") {
-				if (hasVar(right, x)) return null;
-				const d = evaluate(right, params);
-				return Number.isFinite(d) && d !== 0 ? L.map((k) => k / d) : null;
-			}
-			if (op === "^") {
-				if (hasVar(right, x)) return null;
-				const n = evaluate(right, params);
-				if (!Number.isInteger(n) || n < 0 || n > MAX_DEG) return null;
-				let acc = [1];
-				for (let i = 0; i < n; i++) acc = mul(acc, L);
-				return acc;
-			}
-			return null;
-		}
-		default: return null;
-	}
-}
-/** Snap a near-rational real to its exact value (denominators 1..12), else itself. */
-function snapReal(r) {
-	for (const d of [
-		1,
-		2,
-		3,
-		4,
-		5,
-		6,
-		8,
-		10,
-		12
-	]) {
-		const n = Math.round(r * d);
-		if (Math.abs(r * d - n) < 1e-7) {
-			const v = n / d;
-			return Object.is(v, -0) ? 0 : v;
-		}
-	}
-	return Math.round(r * 1e9) / 1e9;
-}
-const snap = (z) => Math.abs(z.im) < 1e-7 ? {
-	re: snapReal(z.re),
-	im: 0
-} : {
-	re: snapReal(z.re),
-	im: snapReal(z.im)
-};
-/**
-* All complex roots of `p` via Durand–Kerner simultaneous iteration (then snapped).
-* For a degree-n polynomial returns n roots; real roots come back with im = 0.
-*/
-function allRoots(p0) {
-	const p = trim(p0);
-	const n = p.length - 1;
-	if (n <= 0) return [];
-	const lead = p[n];
-	const m = p.map((c) => c / lead);
-	let z = Array.from({ length: n }, (_, k) => fromPolar(1 + .1 * k / n, 2 * Math.PI * k / n + .6));
-	for (let it = 0; it < MAX_ITER; it++) {
-		let maxDelta = 0;
-		z = z.map((zi, i) => {
-			let denom = ONE;
-			for (let j = 0; j < n; j++) if (j !== i) denom = mul$1(denom, sub(zi, z[j]));
-			const corr = div(evalC(m, zi), denom);
-			if (!isFiniteC(corr)) return zi;
-			maxDelta = Math.max(maxDelta, abs(corr));
-			return sub(zi, corr);
-		});
-		if (maxDelta < EPS) break;
-	}
-	const roots = z.map(snap);
-	roots.sort((a, b) => a.im === 0 && b.im === 0 ? a.re - b.re : a.im === 0 ? -1 : b.im === 0 ? 1 : a.re - b.re || a.im - b.im);
-	return roots;
-}
-/** Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate. */
-function solve(p0) {
-	const p = trim(p0);
-	const d = p.length - 1;
-	if (d < 1) return null;
-	const roots = allRoots(p);
-	return {
-		poly: p,
-		degree: d,
-		roots,
-		realRoots: roots.filter((r) => r.im === 0).map((r) => r.re)
-	};
-}
-/** Solve an expression-AST equation `expr = 0` for x, any degree. null if not a
-*  polynomial in x. (Linear/quadratic also flow through here, exactly.) */
-function solveEquation(node, x = "x", params = {}) {
-	const p = fromAst(node, x, params);
-	return p ? solve(p) : null;
-}
-const fnum = (n) => {
-	const r = Math.round(n * 1e6) / 1e6;
-	return (Object.is(r, -0) ? 0 : r).toString().replace(/^-/, "−");
-};
-/** "(x − r)" with the sign tucked in, and "(x − 0)" → "x". */
-const linTex = (r, x) => r === 0 ? x : `(${x} ${r < 0 ? "+" : "−"} ${fnum(Math.abs(r))})`;
-/**
-* Factored form of the polynomial over the reals: leading coefficient × linear
-* factors (real roots, with multiplicity) × irreducible quadratics (complex
-* conjugate pairs). e.g. x³−6x²+11x−6 → "(x − 1)(x − 2)(x − 3)".
-*/
-function factorTex(p0, x = "x") {
-	const p = trim(p0);
-	const lead = p[p.length - 1] ?? 1;
-	const sol = solve(p);
-	if (!sol) return fnum(p[0] ?? 0);
-	const used = new Array(sol.roots.length).fill(false);
-	const parts = [];
-	for (let i = 0; i < sol.roots.length; i++) {
-		if (used[i]) continue;
-		const z = sol.roots[i];
-		if (z.im === 0) {
-			used[i] = true;
-			parts.push(linTex(z.re, x));
-			continue;
-		}
-		used[i] = true;
-		const j = sol.roots.findIndex((w, k) => !used[k] && Math.abs(w.re - z.re) < 1e-6 && Math.abs(w.im + z.im) < 1e-6);
-		if (j >= 0) used[j] = true;
-		const b2 = z.re * z.re + z.im * z.im, two = 2 * z.re;
-		const mid = Math.abs(two) < 1e-9 ? "" : ` ${two < 0 ? "+" : "−"} ${fnum(Math.abs(two))}${x}`;
-		parts.push(`(${x}^2${mid} ${b2 < 0 ? "−" : "+"} ${fnum(Math.abs(b2))})`);
-	}
-	const lc = Math.abs(lead - 1) < 1e-9 ? "" : `${fnum(lead)}\\,`;
-	return parts.length ? `${lc}${parts.join("")}` : fnum(lead);
-}
-
-//#endregion
-export { core_exports, deflate, degree, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };

package/dist/networking/contract.d.mts

@@ -1,136 +0,0 @@
-import { ReactNode } from "react";
-
-//#region src/networking/contract.d.ts
-type NetworkDeviceKind = 'client' | 'server' | 'switch' | 'router' | 'access-point' | 'firewall' | 'load-balancer' | 'dns' | 'broker' | 'cloud';
-interface NetworkInterface {
-  id: string;
-  label?: string;
-  mac?: string;
-  addresses?: string[];
-}
-interface NetworkDevice {
-  id: string;
-  kind: NetworkDeviceKind;
-  label: string;
-  at: {
-    x: number;
-    y: number;
-  };
-  interfaces: NetworkInterface[];
-  services?: {
-    kind: 'dhcp' | 'dns' | 'http' | 'https' | 'ftp' | 'websocket';
-    port?: number;
-    label?: string;
-  }[];
-}
-interface NetworkEndpoint {
-  deviceId: string;
-  interfaceId: string;
-}
-interface NetworkLink {
-  id: string;
-  a: NetworkEndpoint;
-  b: NetworkEndpoint;
-  label?: string;
-  cost?: number;
-  latencyMs?: number;
-  bandwidthMbps?: number;
-  loss?: number;
-  mtu?: number;
-  state?: 'up' | 'down';
-}
-interface NetworkRoute {
-  id: string;
-  deviceId: string;
-  prefix: string;
-  via?: string;
-  interfaceId: string;
-  metric?: number;
-}
-interface NetworkDoc {
-  schemaVersion: 1;
-  type: 'network';
-  devices: NetworkDevice[];
-  links: NetworkLink[];
-  routes?: NetworkRoute[];
-  title?: string;
-}
-type PacketLayerKind = 'application' | 'transport' | 'network' | 'data-link' | 'physical';
-interface PacketLayer {
-  kind: PacketLayerKind;
-  protocol: string;
-  summary: string;
-  fields?: Record<string, string | number>;
-}
-interface NetworkPacket {
-  id: string;
-  from: string;
-  to: string;
-  bytes: number;
-  layers: PacketLayer[];
-}
-type NetworkEvent = {
-  type: 'packet-created';
-  at: string;
-  packet: NetworkPacket;
-  message: string;
-} | {
-  type: 'arp-requested';
-  at: string;
-  target: string;
-  message: string;
-} | {
-  type: 'arp-resolved';
-  at: string;
-  target: string;
-  message: string;
-} | {
-  type: 'route-selected';
-  at: string;
-  next: string;
-  prefix?: string;
-  message: string;
-} | {
-  type: 'frame-sent';
-  at: string;
-  linkId: string;
-  next: string;
-  packet: NetworkPacket;
-  message: string;
-} | {
-  type: 'frame-received';
-  at: string;
-  linkId: string;
-  from: string;
-  packet: NetworkPacket;
-  message: string;
-} | {
-  type: 'packet-dropped';
-  at: string;
-  reason: 'unreachable' | 'link-down' | 'loss' | 'mtu';
-  message: string;
-} | {
-  type: 'packet-delivered';
-  at: string;
-  packet: NetworkPacket;
-  message: string;
-};
-interface NetworkTrace {
-  delivered: boolean;
-  path: string[];
-  totalLatencyMs: number;
-  events: NetworkEvent[];
-}
-interface NetworkDeviceGlyphProps {
-  device: NetworkDevice;
-  active?: boolean;
-  selected?: boolean;
-  onSelect?: () => void;
-}
-interface NetworkDeviceDef {
-  kind: NetworkDeviceKind;
-  label: string;
-  render: (props: NetworkDeviceGlyphProps) => ReactNode;
-}
-//#endregion
-export { NetworkDevice, NetworkDeviceDef, NetworkDeviceKind, NetworkDoc, NetworkEndpoint, NetworkEvent, NetworkInterface, NetworkLink, NetworkPacket, NetworkRoute, NetworkTrace, PacketLayer, PacketLayerKind };