@johnhenry/math 0.0.0

package/README.md

@@ -0,0 +1,165 @@
+# @johnhenry/math
+
+**Advanced college-level mathematics for TypeScript** — a modern, fully-typed,
+test-covered port of the Mallory ActionScript 3 library (a project worked on,
+on and off, since 2004), published to npm as `@johnhenry/math`.
+
+Complex numbers, linear algebra over arbitrary algebraic structures,
+combinatorics and number theory, an expression evaluator, and renderer-agnostic
+graphing geometry — all rewritten in modern TypeScript with `node:test`
+(example-based and, for algebraic laws, property-based via `fast-check`).
+
+```ts
+import { ComplexNumber, Structure, Vector, StringEvaluator } from "@johnhenry/math";
+
+ComplexNumber.E.power(new ComplexNumber(0, Math.PI)); // ≈ -1  (Euler)
+Structure.realField().determinant(/* 3×3 matrix, as Vector<Vector<number>> */);
+StringEvaluator.evaluate("sin(pi/2) + 2^3", StringEvaluator.mathEnvironment()); // 9
+```
+
+## Install & use
+
+Requires Node.js ≥ 22.6 (the test suite runs `.ts` directly via Node's built-in
+type stripping).
+
+```bash
+npm install @johnhenry/math
+```
+
+To work on the library itself from within this monorepo:
+
+```bash
+npm install
+npm test           # run the node:test suite (against src/)
+npm run typecheck  # tsc --noEmit
+npm run check      # Biome lint + format check
+npm run check:fix  # apply Biome fixes
+npm run build      # emit ./dist (ESM + .d.ts)
+npm run test:build # build, then smoke-test the emitted package
+npm run docs       # generate the API reference into docs/api (TypeDoc)
+```
+
+Continuous integration (`.github/workflows/ci.yml`) runs typecheck → lint →
+tests → build → dist smoke test → docs build on Node 22 and 24.
+
+**Documentation:**
+
+- **[Cookbook](docs/COOKBOOK.md)** — task-oriented recipes across every
+  domain (linear algebra, symbolic calculus, number theory, group theory,
+  FFT, geometry, graphs, and more), each one verified against the test suite.
+- **API reference** — generated with [TypeDoc](https://typedoc.org) from
+  the source JSDoc; run `npm run docs` and open `docs/api/index.html`.
+
+## Modules
+
+| Area | Modules |
+|------|---------|
+| Foundations | `Vector`, `ComplexNumber` (arithmetic, trig, logs as fluent instance methods), `Type` |
+| Real & complex analysis | `RealMath` (plain scalar functions, not a class), `ComplexMath` (complex vectors + probability helpers), `Statistics` (descriptive stats on `number[]`) |
+| Linear algebra | `VectorUtils`, generic linear algebra in `Structure`, numerical decompositions in `MatrixMath` |
+| Algebraic structures | `Structure` — groups/rings/fields; do linear algebra over e.g. GF(7) |
+| Number theory & combinatorics | `Permutation`, `Cycle` |
+| Geometry | `Polygon`, `GraphUtils`, `Graph3DUtils` (emit paths/meshes as plain data) |
+| Expressions | `Environment`, `Expression`, `StringEvaluator` |
+| Misc | `Utilities`, `Logic`, `IntUtils`, `SpecialOperator` |
+
+## About the port
+
+This is a faithful port that **fixes bugs rather than carrying them over**, and
+takes advantage of modern JavaScript/TypeScript: ES classes, generics, iterators,
+`Array` subclassing, tagged unions, and `.ts`-native execution. Every module was
+translated **test-first**.
+
+A sampling of the ~40 bugs found and fixed while translating:
+
+- **`RealMath.subtract` returned `a * b`.** (Yes, really.)
+- **Order statistics were broken:** `sort` used the default *lexicographic* sort,
+  so `minimum`/`maximum`/`median` were wrong for numbers.
+- **`ComplexMath.divide`** compared `alpha.ivalue` (lowercase `v`, always
+  `undefined`), so all eight directed-infinity results were dead code.
+- **`ComplexMath.normalDistribution`** reciprocated the whole expression, putting
+  the exponential in the denominator (wrong sign) — the normal PDF was inverted.
+- **`solveN`** wasn't Newton's method — it assumed a derivative of 1 and diverged;
+  now a real numeric Newton–Raphson.
+- **`integrateN`** sampled at `2·x + interval`; **`differentiateN`** was a forward
+  difference despite claiming to be symmetric.
+- **`invertMatrix`** had no pivoting (divide-by-zero on a zero pivot); now uses
+  partial pivoting (and a zero-pivot row swap in `Structure`, for finite fields).
+- **`crossProduct`** read index 3 for the z-component and used truthiness tests
+  that dropped zero components; **`powerMatrix`** never actually multiplied.
+- **`Vector.setElement`** infinitely recursed on a falsy slot.
+- **`ComplexNumber` string parsing** crashed on non-matches and couldn't
+  round-trip negative imaginary parts; it also swallowed every `*`, so `"4*2"`
+  parsed as `42`.
+- **`StringEvaluator`** was uniformly right-associative (`10-2-3 → 11`); now
+  left-associative for `+ - * / %` and right-associative for `^`.
+- **`Polynomial.multiply`** referenced a non-existent `dimension.value`;
+  **`Polynomial.antiderivative`** dropped its highest-degree term.
+- **`IntegerMath.modulus`** recursed one step at a time (stack overflow);
+  `primeFactors` infinite-looped on `0` and negatives.
+- **`Structure`**'s matrix section was non-functional (static/instance confusion,
+  undefined references) and is reconstructed as working generic linear algebra.
+- `IntUtils` spelled "forty" and "ninety" as "fourty" and "ninty".
+
+Where the original genuinely had *no* verifiable intended behavior — the Flash
+3D ribbon geometry in `Graph3DUtils` — the math is ported verbatim with an
+explicit note rather than "fixed" by guesswork. The Flash rendering utilities
+(`GraphUtils`/`Graph3DUtils`) now return renderer-agnostic geometry (2D paths,
+3D meshes) instead of Flash display objects.
+
+## Beyond the original
+
+A completeness pass added the missing counterparts and a few natural supplements
+the AS3 library never had:
+
+- **`ComplexNumber`**: `fromPolar`, `fromVector`, `fromXML` (inverses of
+  `magnitude`/`angle`, `toVector`, `toXML`).
+- **`Vector`**: `fromXML`, `fromString` (best-effort inverses of `toXML`/`toString`).
+- **`PolynomialRing`**: `evaluate` (Horner), `add`/`subtract`, `divide`/`mod`/`divmod`
+  (long division), `derivative`/`antiderivative` (generalized to any `Structure`,
+  not just reals), and the real-number-only `parsePolynomial`/`polynomialToString`
+  helpers (inverses of each other).
+- **`Polygon`**: `centroid`, `contains` (point-in-polygon), `isConvex`, `isSimple`.
+- **`Statistics`**: `populationVariance` / `populationStandardDeviation`
+  alongside the sample versions.
+- **`Structure` presets**: `Structure.realField()`, `complexField()`,
+  `integersModulo(n)` (a field when `n` is prime), and `booleanRing()` — so you
+  can do linear algebra over these without wiring up operations by hand:
+
+  ```ts
+  const gf7 = Structure.integersModulo(7);
+  gf7.invertMatrix(/* a matrix over GF(7) */); // Gauss-Jordan over the finite field
+  ```
+
+## Expanded mathematics
+
+Well beyond the original ActionScript scope, the library now spans:
+
+| Area | Module(s) | Highlights |
+|------|-----------|------------|
+| Numerical linear algebra | `MatrixMath` | LU, QR, Cholesky, symmetric eigen (Jacobi), SVD; `solve`, RREF, rank, null space, least squares, pseudo-inverse, norms, condition number |
+| Symbolic calculus | `Symbolic` | expression parser (41 unary elementary functions incl. inverse-trig, reciprocal-trig, hyperbolic/inverse-hyperbolic, `abs`/`log10`/`log2`/`cbrt`/`floor`/`ceil`/`round`/`sign`/`trunc`, and `expm1`/`log1p`/`sigmoid`/`erf`/`relu`, with `arcsin`/`logistic`-style aliases and `\|x\|` bar syntax, plus N-ary `atan2`/`hypot`/`min`/`max`/`gcd`/`lcm`, `log(base, x)`/`clamp(x, lo, hi)`, and `piecewise(cond, expr, ..., otherwise)` with `<`/`<=`/`>`/`>=`/`==`/`!=` comparisons), symbolic differentiation (incl. the multivariate chain rule for the N-ary functions and branch-wise piecewise differentiation) with a u-substitution fallback for `integrate`, algebraic simplification with like-term collection and constant-folding, elementary integration (incl. by-parts, arctan/arcsin forms, and u-substitution), `integrateDefinite` (closed-form first, adaptive-quadrature fallback), `sumSeries` (finite/infinite, closed-form geometric recognition + numeric fallback), Taylor series, `expand`/`substitute`, polynomial `solve`/`factor`, linear `solveSystem`, L'Hopital `limit` (incl. limits at infinity), LaTeX round-trip (`toLatex`/`fromLatex`, incl. `\operatorname{...}`, bracket notation for `abs`/`floor`/`ceil`/`cbrt`, and `\begin{cases}` for piecewise), `evaluateExact` (exact `Rational` evaluation), `evaluateOverStructure` (folds an `Expr` through an arbitrary `Structure`'s own algebra, e.g. for plotting over Z/7Z), and `freeVariables`/`assertVariables` (auto-detect an expression's variables, or opt into strict mode and throw `UndeclaredVariableError` instead of silently resolving an undeclared one to `NaN`) |
+| Number types | `Rational`, `Quaternion`, `DualNumber`, `Interval` | exact bigint rationals, 3D-rotation quaternions, forward-mode autodiff, rigorous interval arithmetic — each also a `Structure` preset |
+| 4D geometric algebra | `Vec4`, `Bivector4`, `Rotor4`, `GeometricAlgebra4` | a genuine fourth *spatial* dimension (not time): 4D vectors, 6-component bivectors (the 2-planes of 4D), and rotors that generalize `Quaternion` to 4D — including 4D-only **double rotations** (simultaneous, independent rotation in two orthogonal planes at once); built on an internal Cl(4,0) blade engine for correctness (verified against `Quaternion` on their shared 3D subspace). `GeometricAlgebra4` also has the `commutatorProduct` and `leftContraction` operations n-dimensional rigid-body dynamics needs (generalized Euler's equation, point velocity). `Rotor4.factor()`/`renormalize()` implement Perwass-style rotor factorization — the proper fix for numerical drift on a double rotation, where naive magnitude normalization silently produces an invalid rotor (verified against 200+ random plane orientations/angles, including the isoclinic and right-isoclinic degenerate cases) |
+| Number theory | `NumberTheory` | `bigint` modPow, extended GCD, CRT, Miller–Rabin, Pollard-rho factorization, Legendre/Jacobi |
+| Group theory | `GroupTheory` | Cayley tables, axiom checks, element order, generated subgroups, cosets, Lagrange, orbits, Sₙ/Zₙ |
+| Numerical methods | `Numerical` | bisection/secant/Newton/Brent; Simpson, adaptive Simpson, Gauss–Legendre; Euler & RK4 ODE solvers |
+| Probability & special functions | `SpecialFunctions`, `Distributions` | gamma/beta/erf, incomplete gamma/beta; normal/exponential/uniform/gamma/χ²/t/binomial/Poisson; t-tests, χ² GoF, CIs |
+| Signal processing | `FFT` | radix-2 FFT/IFFT, DFT, FFT convolution |
+| Computational geometry | `Geometry`, `Transform2D` | convex hull, predicates, point-in-polygon, 2D affine transforms |
+| Graph theory | `Graph` | BFS/DFS, Dijkstra, Kruskal MST, topological sort, components, Floyd–Warshall |
+| Counting mathematics | `Combinatorics` | `bigint` factorials, nCk/nPk, multinomial coefficients, Catalan/Stirling/Bell numbers, integer partitions, derangements |
+| Arbitrary precision | `Decimal` | `bigint`-backed decimal arithmetic — exact add/subtract/multiply, configurable-precision division; also a `Structure` preset |
+| Abstract algebra | `PolynomialRing` | polynomials over any `Structure` (finite fields, rationals, ...) — long division, monic GCD, Horner evaluation, derivative/antiderivative |
+| Multivariable calculus | `VectorCalculus` | gradient, directional derivative, Jacobian, divergence, curl, Hessian (via `DualNumber` autodiff), plus an exact symbolic gradient |
+
+Many of these interlock: `GroupTheory` runs over any `Structure` (including
+`integersModulo`); `Graph.floydWarshall` emits matrices for `MatrixMath`;
+`DualNumber` gives exact derivatives, which both `Structure.dualNumbers()` and
+`VectorCalculus` build on; `PolynomialRing` composes with any `Structure`
+preset (including the new `Decimal`-backed `decimalField()`); and
+`SpecialFunctions` gives the `Distributions` CDFs exact closed forms.
+
+## License
+
+MIT

package/dist/Bivector4.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Bivector4 — an oriented 2-plane in 4D space, i.e. an element of grade 2 in
+ * Cl(4,0). Basis: `e12, e13, e14, e23, e24, e34` (6 components — in general nD
+ * there are `n(n-1)/2` independent 2-planes: 1 in 2D, 3 in 3D, 6 in 4D).
+ *
+ * In 3D, angular velocity/momentum/torque are conventionally written as
+ * *vectors* via the cross product, but that only works because 3D vectors
+ * happen to have the same dimension (3) as 3D bivectors — a coincidence
+ * unique to 3D. In 4D (and in general) these quantities are properly
+ * bivectors, not vectors: see {@link Rotor4} for how a bivector generates a
+ * rotation, and the physics package for angular velocity/momentum as
+ * Bivector4.
+ */
+export declare class Bivector4 {
+    /** e12 component — the xy rotation plane. */
+    readonly xy: number;
+    /** e13 component — the xz rotation plane. */
+    readonly xz: number;
+    /** e14 component — the xw rotation plane. */
+    readonly xw: number;
+    /** e23 component — the yz rotation plane. */
+    readonly yz: number;
+    /** e24 component — the yw rotation plane. */
+    readonly yw: number;
+    /** e34 component — the zw rotation plane. */
+    readonly zw: number;
+    static readonly Zero: Bivector4;
+    constructor(xy?: number, xz?: number, xw?: number, yz?: number, yw?: number, zw?: number);
+    add(b: Bivector4): Bivector4;
+    subtract(b: Bivector4): Bivector4;
+    scale(s: number): Bivector4;
+    negate(): Bivector4;
+    /** Component-wise inner product (the basis bivectors e12..e34 are mutually orthonormal, so this is just the Euclidean dot product of components). */
+    dot(b: Bivector4): number;
+    get magnitude(): number;
+    get magnitudeSquared(): number;
+    normalize(): Bivector4;
+    /**
+     * True when this bivector is *simple* (a.k.a. a blade): it represents
+     * rotation in a single 2-plane, like every 3D bivector always does. A 4D
+     * bivector is simple iff its self-wedge `B ∧ B` vanishes (equivalently,
+     * `B * B` — the geometric product with itself — has no pseudoscalar part).
+     * Non-simple ("compound") bivectors are the ones responsible for 4D's
+     * double rotations — see {@link Rotor4}.
+     */
+    isSimple(epsilon?: number): boolean;
+    equals(b: Bivector4, epsilon?: number): boolean;
+    toArray(): [number, number, number, number, number, number];
+    static fromArray(a: readonly [number, number, number, number, number, number]): Bivector4;
+    toString(): string;
+}
+//# sourceMappingURL=Bivector4.d.ts.map

package/dist/Bivector4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bivector4.d.ts","sourceRoot":"","sources":["../src/Bivector4.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,SAAS;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,MAAM,CAAC,QAAQ,CAAC,IAAI,YAAmC;gBAE3C,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,EAAE,SAAI;IAS1D,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS;IAW5B,QAAQ,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS;IAWjC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS;IAI3B,MAAM,IAAI,SAAS;IAInB,qJAAqJ;IACrJ,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM;IAIzB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,gBAAgB,IAAI,MAAM,CAE7B;IAED,SAAS,IAAI,SAAS;IAMtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,SAAO,GAAG,OAAO;IAQjC,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,SAAI,GAAG,OAAO;IAqB1C,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAI3D,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAIzF,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/Bivector4.js

@@ -0,0 +1,105 @@
+/**
+ * Bivector4 — an oriented 2-plane in 4D space, i.e. an element of grade 2 in
+ * Cl(4,0). Basis: `e12, e13, e14, e23, e24, e34` (6 components — in general nD
+ * there are `n(n-1)/2` independent 2-planes: 1 in 2D, 3 in 3D, 6 in 4D).
+ *
+ * In 3D, angular velocity/momentum/torque are conventionally written as
+ * *vectors* via the cross product, but that only works because 3D vectors
+ * happen to have the same dimension (3) as 3D bivectors — a coincidence
+ * unique to 3D. In 4D (and in general) these quantities are properly
+ * bivectors, not vectors: see {@link Rotor4} for how a bivector generates a
+ * rotation, and the physics package for angular velocity/momentum as
+ * Bivector4.
+ */
+export class Bivector4 {
+    /** e12 component — the xy rotation plane. */
+    xy;
+    /** e13 component — the xz rotation plane. */
+    xz;
+    /** e14 component — the xw rotation plane. */
+    xw;
+    /** e23 component — the yz rotation plane. */
+    yz;
+    /** e24 component — the yw rotation plane. */
+    yw;
+    /** e34 component — the zw rotation plane. */
+    zw;
+    static Zero = new Bivector4(0, 0, 0, 0, 0, 0);
+    constructor(xy = 0, xz = 0, xw = 0, yz = 0, yw = 0, zw = 0) {
+        this.xy = xy;
+        this.xz = xz;
+        this.xw = xw;
+        this.yz = yz;
+        this.yw = yw;
+        this.zw = zw;
+    }
+    add(b) {
+        return new Bivector4(this.xy + b.xy, this.xz + b.xz, this.xw + b.xw, this.yz + b.yz, this.yw + b.yw, this.zw + b.zw);
+    }
+    subtract(b) {
+        return new Bivector4(this.xy - b.xy, this.xz - b.xz, this.xw - b.xw, this.yz - b.yz, this.yw - b.yw, this.zw - b.zw);
+    }
+    scale(s) {
+        return new Bivector4(this.xy * s, this.xz * s, this.xw * s, this.yz * s, this.yw * s, this.zw * s);
+    }
+    negate() {
+        return this.scale(-1);
+    }
+    /** Component-wise inner product (the basis bivectors e12..e34 are mutually orthonormal, so this is just the Euclidean dot product of components). */
+    dot(b) {
+        return this.xy * b.xy + this.xz * b.xz + this.xw * b.xw + this.yz * b.yz + this.yw * b.yw + this.zw * b.zw;
+    }
+    get magnitude() {
+        return Math.sqrt(this.dot(this));
+    }
+    get magnitudeSquared() {
+        return this.dot(this);
+    }
+    normalize() {
+        const m = this.magnitude;
+        if (m === 0)
+            throw new Error("Cannot normalize the zero bivector.");
+        return this.scale(1 / m);
+    }
+    /**
+     * True when this bivector is *simple* (a.k.a. a blade): it represents
+     * rotation in a single 2-plane, like every 3D bivector always does. A 4D
+     * bivector is simple iff its self-wedge `B ∧ B` vanishes (equivalently,
+     * `B * B` — the geometric product with itself — has no pseudoscalar part).
+     * Non-simple ("compound") bivectors are the ones responsible for 4D's
+     * double rotations — see {@link Rotor4}.
+     */
+    isSimple(epsilon = 1e-9) {
+        // B ∧ B for a bivector reduces to twice the Pfaffian-like pairing of
+        // opposite basis planes: (xy*zw - xz*yw + xw*yz), matching the
+        // pseudoscalar component produced by the geometric product B*B.
+        const pfaffian = this.xy * this.zw - this.xz * this.yw + this.xw * this.yz;
+        return Math.abs(pfaffian) <= epsilon;
+    }
+    equals(b, epsilon = 0) {
+        if (epsilon === 0) {
+            return (this.xy === b.xy &&
+                this.xz === b.xz &&
+                this.xw === b.xw &&
+                this.yz === b.yz &&
+                this.yw === b.yw &&
+                this.zw === b.zw);
+        }
+        return (Math.abs(this.xy - b.xy) <= epsilon &&
+            Math.abs(this.xz - b.xz) <= epsilon &&
+            Math.abs(this.xw - b.xw) <= epsilon &&
+            Math.abs(this.yz - b.yz) <= epsilon &&
+            Math.abs(this.yw - b.yw) <= epsilon &&
+            Math.abs(this.zw - b.zw) <= epsilon);
+    }
+    toArray() {
+        return [this.xy, this.xz, this.xw, this.yz, this.yw, this.zw];
+    }
+    static fromArray(a) {
+        return new Bivector4(a[0], a[1], a[2], a[3], a[4], a[5]);
+    }
+    toString() {
+        return `${this.xy}e12 + ${this.xz}e13 + ${this.xw}e14 + ${this.yz}e23 + ${this.yw}e24 + ${this.zw}e34`;
+    }
+}
+//# sourceMappingURL=Bivector4.js.map

package/dist/Bivector4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bivector4.js","sourceRoot":"","sources":["../src/Bivector4.ts"],"names":[],"mappings":"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"}

package/dist/CellGraph.d.ts

@@ -0,0 +1,259 @@
+/**
+ * CellGraph — a reactive, pull-based dependency graph. Cells hold typed
+ * values (numbers, points, curves, whatever) rather than flattened
+ * primitives; a derived cell's `compute` reads other cells via `graph.get`,
+ * and the graph records the resulting edges automatically (no manual tag
+ * declarations, unlike mcp-query's cache).
+ *
+ * Writes (`set`) mark transitive dependents dirty and bump their version
+ * counters immediately — cheap, no recompute. Recomputation happens lazily,
+ * the next time a dirty cell is `get`, and a structural-equality check skips
+ * the version bump (and further propagation) when a recompute produces a
+ * value that's deep-equal to what was already cached, so unaffected
+ * downstream consumers don't re-render.
+ *
+ * Promoted here from johnhenry/mallory (originally `src/lib/cell-
+ * graph.ts`, powering every panel there via `useCell`/`useSyncExternalStore`)
+ * once johnhenry/math-grapher became a second consumer of a frozen
+ * vendored copy — two consumers is this monorepo's own extract-to-a-package
+ * trigger. See johnhenry/math#56. UI-framework-agnostic and dependency-
+ * free by design: nothing here references React or any host application.
+ */
+type Listener = () => void;
+type ComputeFn<T> = () => T;
+export type CellRole = "free" | "dependent" | "unknown";
+export declare class CircularDependencyError extends Error {
+    constructor(path: string[]);
+}
+export declare class CellGraph {
+    private cells;
+    private listeners;
+    private globalListeners;
+    private writeListeners;
+    private stack;
+    private emitting;
+    /**
+     * Nesting depth of the current "logical write" -- incremented around the
+     * body of every top-level mutating entry point ({@link set}, {@link
+     * define}, {@link delete}) and decremented in a `finally` when it returns.
+     * A single `set()` on a root of a diamond-shaped dependency graph cascades
+     * through `propagateDirty` and calls `emit()` once per cell it reaches
+     * (root, then each newly-dirtied dependent) -- all of those belong to the
+     * SAME logical write and must produce exactly one `subscribeAll`
+     * notification, not one per cell. While this is above zero, a request to
+     * notify global listeners (see {@link scheduleGlobalNotify}) is deferred
+     * instead of firing immediately; it only actually fires once depth
+     * unwinds back to zero, i.e. once the outermost `set`/`define`/`delete`
+     * call (including any cells it transitively dirtied) has fully finished.
+     */
+    private globalNotifyDepth;
+    /** Set by {@link scheduleGlobalNotify} while `globalNotifyDepth > 0`, so the deferred notification isn't lost once depth returns to zero. */
+    private globalNotifyPending;
+    /**
+     * Guards the global-listener-invocation loop itself against being
+     * re-entered while it's already running -- e.g. a global listener that
+     * synchronously calls `set()` on a DIFFERENT cell from inside its own
+     * callback. Unlike the shared boolean this replaces, a reentrant request
+     * that arrives while this is `true` is NOT dropped: it re-arms {@link
+     * globalNotifyPending}, which is drained (fired again) right after the
+     * in-progress loop finishes -- see {@link flushGlobalNotify}. This is what
+     * keeps a reentrant write to a different cell from being silently
+     * swallowed (issue #234), while still bounding recursion depth to one
+     * extra level per reentrant write, the same way `emitting` bounds it for
+     * same-id reentrancy on local listeners.
+     */
+    private notifyingGlobalListeners;
+    /**
+     * Write a raw source-of-truth value (e.g. a slider drag or text input).
+     * Structurally, a cell written via `set` (no `compute` fn) is what makes
+     * it "free" -- see {@link role}.
+     *
+     * @param options.auxiliary Marks this cell hidden-by-default in an
+     * Algebra-view-style listing (see {@link list}) -- e.g. an internal
+     * sampling parameter that isn't itself meaningful to show the user,
+     * distinct from a top-level named object. Only applied when the cell
+     * doesn't already exist, or is transitioning from a compute-backed
+     * (dependent) cell to a free one; an existing free cell's auxiliary flag
+     * is left as originally set.
+     */
+    set<T>(id: string, value: T, options?: {
+        auxiliary?: boolean;
+    }): void;
+    /**
+     * Subscribe to raw `set()` writes -- id plus the new value -- across
+     * every cell in the graph (issue #47's live-collaboration groundwork).
+     * Deliberately narrower than `subscribeAll`: it fires ONLY for an actual
+     * `set()` call with a real (structurally-different) value, never for a
+     * `define()`-driven recompute cascade. That's the exact shape a
+     * broadcast-to-other-peers use case needs -- each peer re-derives its
+     * own dependent cells locally once a base write arrives over the wire
+     * and gets applied via `set()` there too, so only the raw user-initiated
+     * writes need to cross the network, not every recomputed cell downstream
+     * of them.
+     */
+    subscribeWrites(fn: (id: string, value: unknown) => void): () => void;
+    private emitWrite;
+    /**
+     * Define (or redefine) a derived cell computed from other cells.
+     * Structurally, a cell written via `define` (has a `compute` fn) is what
+     * makes it "dependent" -- see {@link role}.
+     *
+     * @param options.auxiliary See {@link set}'s equivalent option; applied
+     * the same way (only on first definition, or a transition from free to
+     * dependent).
+     */
+    define<T>(id: string, compute: ComputeFn<T>, options?: {
+        auxiliary?: boolean;
+    }): void;
+    private defineImpl;
+    /**
+     * Whether `id` is "free" (writable directly via `set`, no `compute` fn --
+     * e.g. a slider or text input), "dependent" (computed via `define` from
+     * other cells), or "unknown" (`id` has never been `set`/`define`d, only
+     * read, or doesn't exist at all).
+     */
+    role(id: string): CellRole;
+    /** Whether `id` was marked `auxiliary` (hidden-by-default in an Algebra-view-style listing) -- see {@link set}/{@link define}. */
+    isAuxiliary(id: string): boolean;
+    /**
+     * Every cell currently in the graph, with its role and auxiliary flag --
+     * the basis for an Algebra-view-style listing (GeoGebra's free/dependent/
+     * auxiliary object model). Includes cells with no value yet (role
+     * "unknown") since a caller may still want to know such an id exists
+     * (e.g. was read but never written).
+     */
+    list(): Array<{
+        id: string;
+        role: CellRole;
+        auxiliary: boolean;
+        hasValue: boolean;
+    }>;
+    /** Read a cell's current value, recomputing if stale. Auto-tracks dependency edges. */
+    get<T>(id: string): T;
+    private recomputeAndEmit;
+    /** The value useSyncExternalStore observes for this cell. */
+    getVersion(id: string): number;
+    /** Subscribe to changes on one cell. Returns an unsubscribe function. */
+    subscribe(id: string, fn: Listener): () => void;
+    /** Subscribe to changes on any cell (e.g. to drive a canvas render loop). */
+    subscribeAll(fn: Listener): () => void;
+    /**
+     * Subscribe to changes on a fixed, known set of specific cells -- e.g.
+     * every cell a serialized URL fragment reads. Narrower than
+     * `subscribeAll`: `fn` fires only for a write on one of `ids`, not for
+     * literally any cell in the graph (issue #235 -- several panels' URL-sync
+     * effects used `subscribeAll` for exactly this "a handful of specific
+     * cells" shape, so they also fired on unrelated high-frequency writes
+     * elsewhere in the same graph -- an RAF-driven playback clock, a live
+     * drag preview, a per-epoch training metric -- that the listener's own
+     * output never actually depended on). Just sugar over one `subscribe`
+     * call per id; not appropriate when the relevant id set is itself dynamic
+     * (e.g. "every currently-visible row's cells", where the row list can
+     * grow/shrink) -- that shape still needs `subscribeAll` (ideally
+     * debounced) or per-id `subscribe` calls re-issued as the id set changes.
+     */
+    subscribeMany(ids: string[], fn: Listener): () => void;
+    has(id: string): boolean;
+    /**
+     * Whether `id` has a real value yet, as opposed to merely existing as an
+     * empty record (`has()` returns true for a cell the instant anything reads
+     * it via `get`, even before it's ever been `set` or `define`d -- not a
+     * reliable "should I seed this?" check from a post-render effect that runs
+     * after a sibling compute has already read-and-thus-created it).
+     */
+    hasValue(id: string): boolean;
+    /**
+     * Remove a cell entirely. Former *dependents* are marked dirty and
+     * notified (same as a `set()` would), so a compute that read the deleted
+     * cell re-runs and can fall back to whatever "this cell doesn't exist"
+     * means for it -- without this, a dependent kept its stale cached value
+     * forever, AND (because its dependency edges only rebuild during a
+     * recompute that never came) writes to its other dependencies stopped
+     * reaching it too. The notification happens *after* the cell is gone, so
+     * the reentrant recompute a listener may trigger sees the post-delete
+     * world: a `get()` on the deleted id re-creates an empty record
+     * (`hasValue: false`), exactly the "never existed" semantics callers
+     * like ExpressionRow's params compute already handle.
+     */
+    delete(id: string): void;
+    private ensure;
+    private propagateDirty;
+    /**
+     * Notify `id`'s listeners that it may have changed. Guarded against
+     * reentrancy per-id: a `useSyncExternalStore` listener synchronously
+     * calls `getSnapshot` (React's own tearing check) as soon as it's
+     * notified, which re-enters `get()` and, on a real recompute, calls back
+     * into `emit(id)` for the very same id before this call has returned.
+     * Without the guard that nested call re-invokes every listener again
+     * (including the one currently on the stack), which re-triggers the same
+     * reentrant read, forever -- an unbounded synchronous storm that pins the
+     * CPU and eventually OOMs the JS heap. It's always safe to drop the
+     * nested notification: any consumer notified mid-flight still reads the
+     * freshest value the next time it calls `get()`, so no update is lost by
+     * collapsing repeat notifications for the same id into one.
+     *
+     * The global (`subscribeAll`) notification is requested here but not
+     * fired directly -- see {@link scheduleGlobalNotify}: a single logical
+     * write (e.g. one `set()` on the root of a diamond-shaped dependency
+     * graph) calls `emit()` once per cell it transitively dirties, but must
+     * still only produce ONE `subscribeAll` notification (issue #234).
+     */
+    private emit;
+    /**
+     * Run `fn` as one "logical write" for the purposes of global-listener
+     * batching -- see {@link globalNotifyDepth}. Reentrant calls (e.g. a
+     * `subscribe()` listener triggered mid-cascade that synchronously calls
+     * `get()`, which recomputes and dirties further cells) nest transparently:
+     * only the outermost call's `finally` can bring the depth back to zero and
+     * trigger the deferred flush.
+     */
+    private runBatched;
+    /**
+     * Run `fn`, a sequence of otherwise-independent `set`/`define`/`delete`
+     * calls, as a SINGLE logical write for `subscribeAll` purposes (see
+     * {@link runBatched}/{@link scheduleGlobalNotify}). Without this, a
+     * multi-step mutation like a clear-then-replay (#374/#375) fires a
+     * `subscribeAll` notification after each individual call, so a listener
+     * that reads back across multiple cells (e.g. a canvas redraw walking an
+     * object-list cell and dereferencing each entry's point cells) can
+     * observe a transient state mid-sequence -- e.g. an id still listed in
+     * one cell whose corresponding point cell has already been deleted by an
+     * earlier call in the same `fn`. Wrapping the whole sequence here defers
+     * every `subscribeAll` notification until `fn` fully returns, so
+     * listeners only ever see the state before or after, never in between.
+     */
+    transaction<T>(fn: () => T): T;
+    /**
+     * Request a `subscribeAll` notification. While a logical write is still
+     * in progress ({@link globalNotifyDepth} > 0), the request is only
+     * recorded ({@link globalNotifyPending}) -- {@link runBatched} flushes it
+     * once that write (including everything it cascaded into) fully unwinds.
+     * Outside of any write (e.g. a standalone `get()` that lazily recomputes a
+     * dirty cell with no `set`/`define`/`delete` on the stack), there's no
+     * outer call to flush later, so it fires immediately.
+     */
+    private scheduleGlobalNotify;
+    /**
+     * Actually invoke every `subscribeAll` listener, once, for the batch of
+     * cell changes accumulated since the last flush.
+     *
+     * Guarded against reentering the listener-invocation loop itself --
+     * `notifyingGlobalListeners`, scoped to "is a global-listener loop
+     * currently on the stack" rather than per-cell-id, because by this point
+     * the notification is no longer about any single cell; it's "this batch
+     * of writes changed something." A listener that synchronously starts a
+     * NEW logical write (e.g. `set()` on a different cell) re-arms {@link
+     * globalNotifyPending} instead of recursing into a second, nested
+     * invocation of every listener -- that pending flag is drained in the
+     * `while` loop below once the in-progress loop returns, so that second
+     * write's notification still fires (once), it's just deferred to right
+     * after the first finishes rather than dropped. This is what fixes issue
+     * #234's bug 2: the previous shared `notifyingGlobal` boolean guard
+     * skipped (silently discarded) exactly this case instead of deferring it.
+     */
+    private flushGlobalNotify;
+}
+/** Deep structural equality, used to skip redraws when a recompute is a no-op. */
+export declare function structuralEqual(a: unknown, b: unknown): boolean;
+export {};
+//# sourceMappingURL=CellGraph.d.ts.map

package/dist/CellGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CellGraph.d.ts","sourceRoot":"","sources":["../src/CellGraph.ts"],"names":[],"mappings":"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"}