@classytic/stage 0.2.0 → 0.4.0

package/dist/math/poly.mjs

@@ -0,0 +1,273 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { evaluate } from "./ast.mjs";
+import { ONE, ZERO, abs, add as add$1, cx, div, fromPolar, isFiniteC, mul as mul$1, sub } from "./complex.mjs";
+
+//#region src/math/poly.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 poly_exports = /* @__PURE__ */ __exportAll({
+	add: () => add,
+	allRoots: () => allRoots,
+	deflate: () => deflate,
+	degree: () => degree,
+	deriv: () => deriv,
+	evalC: () => evalC,
+	evalPoly: () => evalPoly,
+	factorTex: () => factorTex,
+	fromAst: () => fromAst,
+	mul: () => mul,
+	polyRoots: () => polyRoots,
+	polyTex: () => polyTex,
+	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.
+*
+* Named `polyRoots` because `solve` alone said nothing about which roots of what: labs exported
+* three of them (closed-form polynomial, these numeric ones, and the circuit solver).
+*/
+function polyRoots(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 ? polyRoots(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 = polyRoots(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 { allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, polyRoots, polyTex, poly_exports, solveEquation, trim };

package/dist/math/rearrange.d.mts

@@ -0,0 +1,14 @@
+import { Node } from "./ast.mjs";
+
+//#region src/math/rearrange.d.ts
+/** How many times a variable appears in an expression. */
+declare function occurrences(node: Node, name: string): number;
+/**
+ * Rearrange `left = right` into `target = <expression>`, and return that expression.
+ *
+ * Throws when the target appears in an exponent, inside a function with no inverse here, or more
+ * than once. Each of those is a real limit of isolation rather than a gap to paper over.
+ */
+declare function isolate(left: Node, right: Node, target: string): Node;
+//#endregion
+export { isolate, occurrences };

package/dist/math/rearrange.mjs

@@ -0,0 +1,125 @@
+//#region src/math/rearrange.ts
+/** How many times a variable appears in an expression. */
+function occurrences(node, name) {
+	switch (node.type) {
+		case "var": return node.name === name ? 1 : 0;
+		case "neg": return occurrences(node.arg, name);
+		case "binary": return occurrences(node.left, name) + occurrences(node.right, name);
+		case "call": return node.args.reduce((n, a) => n + occurrences(a, name), 0);
+		default: return 0;
+	}
+}
+const n = (value) => ({
+	type: "num",
+	value
+});
+const b = (op, left, right) => ({
+	type: "binary",
+	op,
+	left,
+	right
+});
+const fn = (name, ...args) => ({
+	type: "call",
+	fn: name,
+	args
+});
+/**
+* Rearrange `left = right` into `target = <expression>`, and return that expression.
+*
+* Throws when the target appears in an exponent, inside a function with no inverse here, or more
+* than once. Each of those is a real limit of isolation rather than a gap to paper over.
+*/
+function isolate(left, right, target) {
+	let lhs = left;
+	let rhs = right;
+	for (let guard = 0; guard < 64; guard++) {
+		if (occurrences(lhs, target) === 0) [lhs, rhs] = [rhs, lhs];
+		if (lhs.type === "var" && lhs.name === target) return rhs;
+		if (lhs.type === "neg") {
+			lhs = lhs.arg;
+			rhs = {
+				type: "neg",
+				arg: rhs
+			};
+			continue;
+		}
+		if (lhs.type === "binary") {
+			const inLeft = occurrences(lhs.left, target) > 0;
+			const keep = inLeft ? lhs.left : lhs.right;
+			const move = inLeft ? lhs.right : lhs.left;
+			switch (lhs.op) {
+				case "+":
+					rhs = b("-", rhs, move);
+					break;
+				case "-":
+					rhs = inLeft ? b("+", rhs, move) : b("-", move, rhs);
+					break;
+				case "*":
+					rhs = b("/", rhs, move);
+					break;
+				case "/":
+					rhs = inLeft ? b("*", rhs, move) : b("/", move, rhs);
+					break;
+				case "^":
+					if (!inLeft) throw new Error(`Cannot solve for "${target}": it appears in an exponent. Declare a second relation.`);
+					rhs = b("^", rhs, b("/", n(1), move));
+					break;
+				default: throw new Error(`Cannot solve for "${target}" through the "${lhs.op}" operator.`);
+			}
+			lhs = keep;
+			continue;
+		}
+		if (lhs.type === "call") {
+			const arg = lhs.args[0];
+			if (!arg) throw new Error(`Cannot solve for "${target}" through ${lhs.fn}()`);
+			switch (lhs.fn) {
+				case "log10":
+				case "log":
+					rhs = b("^", n(10), rhs);
+					break;
+				case "ln":
+					rhs = fn("exp", rhs);
+					break;
+				case "exp":
+					rhs = fn("ln", rhs);
+					break;
+				case "log2":
+					rhs = b("^", n(2), rhs);
+					break;
+				case "sqrt":
+					rhs = b("^", rhs, n(2));
+					break;
+				case "cbrt":
+					rhs = b("^", rhs, n(3));
+					break;
+				case "sin":
+					rhs = fn("asin", rhs);
+					break;
+				case "cos":
+					rhs = fn("acos", rhs);
+					break;
+				case "tan":
+					rhs = fn("atan", rhs);
+					break;
+				case "asin":
+					rhs = fn("sin", rhs);
+					break;
+				case "acos":
+					rhs = fn("cos", rhs);
+					break;
+				case "atan":
+					rhs = fn("tan", rhs);
+					break;
+				default: throw new Error(`Cannot invert ${lhs.fn}() to solve for "${target}".`);
+			}
+			lhs = arg;
+			continue;
+		}
+		throw new Error(`Cannot solve for "${target}" in this equation.`);
+	}
+	throw new Error(`Gave up isolating "${target}" (the equation nests too deeply).`);
+}
+
+//#endregion
+export { isolate, occurrences };

package/dist/math/solve.d.mts

@@ -0,0 +1,21 @@
+import { Node } from "./ast.mjs";
+import { Complex } from "./complex.mjs";
+import { fromAst } from "./poly.mjs";
+
+//#region src/math/solve.d.ts
+/** Coefficients [a0, a1, …] of `node` as a polynomial in `x` (the canonical poly
+ *  engine does the extraction). null if it isn't polynomial in x. */
+declare const polyCoeffs: typeof fromAst;
+interface PolySolution {
+  coeffs: number[];
+  degree: number;
+  roots: Complex[];
+  realRoots: number[];
+  discriminant?: number;
+}
+/** Solve `node` = 0 for x exactly (degree 1 or 2). null if not a usable polynomial. */
+declare function solvePoly(node: Node, x?: string, params?: Record<string, number>): PolySolution | null;
+/** "x = 2 or x = −2" (complex when needed), or "no real solutions" framing. */
+declare function solutionTex(sol: PolySolution, x?: string): string;
+//#endregion
+export { PolySolution, polyCoeffs, solutionTex, solvePoly };

package/dist/math/solve.mjs

@@ -0,0 +1,75 @@
+import { toStr } from "./complex.mjs";
+import { fromAst, trim } from "./poly.mjs";
+
+//#region src/math/solve.ts
+const cleanNum = (n) => {
+	const r = Math.round(n * 1e9) / 1e9;
+	return Object.is(r, -0) ? 0 : r;
+};
+/** Coefficients [a0, a1, …] of `node` as a polynomial in `x` (the canonical poly
+*  engine does the extraction). null if it isn't polynomial in x. */
+const polyCoeffs = fromAst;
+/** Solve `node` = 0 for x exactly (degree 1 or 2). null if not a usable polynomial. */
+function solvePoly(node, x = "x", params = {}) {
+	const raw = polyCoeffs(node, x, params);
+	if (!raw) return null;
+	const coeffs = trim(raw);
+	const degree = coeffs.length - 1;
+	if (degree === 1) {
+		const a0 = coeffs[0], a1 = coeffs[1];
+		const r = cleanNum(-a0 / a1);
+		return {
+			coeffs,
+			degree,
+			roots: [{
+				re: r,
+				im: 0
+			}],
+			realRoots: [r]
+		};
+	}
+	if (degree === 2) {
+		const c0 = coeffs[0], c1 = coeffs[1], c2 = coeffs[2];
+		const disc = c1 * c1 - 4 * c2 * c0;
+		const twoA = 2 * c2;
+		if (disc >= 0) {
+			const s = Math.sqrt(disc);
+			const real = [cleanNum((-c1 - s) / twoA), cleanNum((-c1 + s) / twoA)].sort((u, v) => u - v);
+			return {
+				coeffs,
+				degree,
+				discriminant: disc,
+				roots: real.map((r) => ({
+					re: r,
+					im: 0
+				})),
+				realRoots: real
+			};
+		}
+		const s = Math.sqrt(-disc), re = cleanNum(-c1 / twoA), im = cleanNum(s / twoA);
+		return {
+			coeffs,
+			degree,
+			discriminant: disc,
+			roots: [{
+				re,
+				im: -im
+			}, {
+				re,
+				im
+			}],
+			realRoots: []
+		};
+	}
+	return null;
+}
+/** "x = 2 or x = −2" (complex when needed), or "no real solutions" framing. */
+function solutionTex(sol, x = "x") {
+	if (sol.roots.length === 1) return `${x} = ${toStr(sol.roots[0])}`;
+	const [r1, r2] = sol.roots;
+	if (r1 && r2 && r1.re === r2.re && r1.im === r2.im) return `${x} = ${toStr(r1)} \\text{ (repeated)}`;
+	return `${x} = ${toStr(r1)} \\text{ or } ${x} = ${toStr(r2)}`;
+}
+
+//#endregion
+export { polyCoeffs, solutionTex, solvePoly };

package/dist/networking/addressing.d.mts

@@ -0,0 +1,26 @@
+//#region src/networking/addressing.d.ts
+type DhcpClientState = "new" | "renewing" | "expired";
+interface DhcpLeaseOptions {
+  clientState: DhcpClientState;
+  serverAvailable: boolean;
+  requestedAddress?: string;
+  offeredAddress?: string;
+  leaseSeconds?: number;
+}
+interface DhcpLeaseResult {
+  messages: readonly ("DISCOVER" | "OFFER" | "REQUEST" | "ACK" | "NAK")[];
+  address: string | null;
+  usable: boolean;
+  leaseSeconds: number;
+  nextAction: "use-lease" | "retry-discovery" | "stop-and-discover";
+}
+/** Resolve one DHCP exchange. Rendering and timers belong to the consuming lab. */
+declare function simulateDhcpLease({
+  clientState,
+  serverAvailable,
+  requestedAddress,
+  offeredAddress,
+  leaseSeconds
+}: DhcpLeaseOptions): DhcpLeaseResult;
+//#endregion
+export { DhcpClientState, DhcpLeaseOptions, DhcpLeaseResult, simulateDhcpLease };

package/dist/networking/addressing.mjs

@@ -0,0 +1,33 @@
+//#region src/networking/addressing.ts
+/** Resolve one DHCP exchange. Rendering and timers belong to the consuming lab. */
+function simulateDhcpLease({ clientState, serverAvailable, requestedAddress, offeredAddress = "192.168.1.24", leaseSeconds = 3600 }) {
+	if (!serverAvailable) return {
+		messages: clientState === "renewing" ? ["REQUEST"] : ["DISCOVER"],
+		address: clientState === "renewing" ? requestedAddress ?? null : null,
+		usable: clientState === "renewing" && Boolean(requestedAddress),
+		leaseSeconds: 0,
+		nextAction: clientState === "renewing" ? "stop-and-discover" : "retry-discovery"
+	};
+	if (clientState === "renewing" && requestedAddress) return {
+		messages: ["REQUEST", "ACK"],
+		address: requestedAddress,
+		usable: true,
+		leaseSeconds,
+		nextAction: "use-lease"
+	};
+	return {
+		messages: [
+			"DISCOVER",
+			"OFFER",
+			"REQUEST",
+			"ACK"
+		],
+		address: offeredAddress,
+		usable: true,
+		leaseSeconds,
+		nextAction: "use-lease"
+	};
+}
+
+//#endregion
+export { simulateDhcpLease };

package/dist/networking/cloud/access.d.mts

@@ -0,0 +1,36 @@
+//#region src/networking/cloud/access.d.ts
+type WorkloadKind = "checkout-api" | "report-job" | "backup-job";
+type AccessDesign = "shared-admin-key" | "workload-admin" | "least-privilege";
+type AccessIncident = "normal" | "compromised";
+type CloudResource = "orders" | "payments" | "objects";
+type ResourceAction = "read" | "write" | "delete";
+interface Permission {
+  resource: CloudResource;
+  action: ResourceAction;
+}
+interface ResourceAccess {
+  resource: CloudResource;
+  required: ResourceAction[];
+  granted: ResourceAction[];
+  attempted: ResourceAction[];
+  allowed: ResourceAction[];
+  denied: ResourceAction[];
+}
+interface AccessSnapshot {
+  workload: WorkloadKind;
+  design: AccessDesign;
+  incident: AccessIncident;
+  identity: "shared-key" | "workload-identity";
+  attributable: boolean;
+  requiredPermissions: number;
+  grantedPermissions: number;
+  excessPermissions: number;
+  exposedPermissions: number;
+  taskWorks: boolean;
+  leastPrivilege: boolean;
+  resources: ResourceAccess[];
+  message: string;
+}
+declare function evaluateWorkloadAccess(workload: WorkloadKind, design: AccessDesign, incident: AccessIncident): AccessSnapshot;
+//#endregion
+export { AccessDesign, AccessIncident, AccessSnapshot, CloudResource, Permission, ResourceAccess, ResourceAction, WorkloadKind, evaluateWorkloadAccess };