@justinelliottcobb/amari-wasm 0.19.1 → 0.22.0

package/amari_wasm.js

@@ -838,13 +838,31 @@ function getArrayF32FromWasm0(ptr, len) {
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 function __wbg_adapter_30(arg0, arg1, arg2) {
-    wasm.closure71_externref_shim(arg0, arg1, arg2);
+    wasm.closure77_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_965(arg0, arg1, arg2, arg3) {
-    wasm.closure65_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_1132(arg0, arg1, arg2, arg3) {
+    wasm.closure71_externref_shim(arg0, arg1, arg2, arg3);
 }
 
+/**
+ * Tie-handling policy for branch-sensitive dual-number min/max operations.
+ * @enum {0 | 1 | 2}
+ */
+export const WasmBranchPolicy = Object.freeze({
+    /**
+     * Preserve the left operand derivative on ties.
+     */
+    Left: 0, "0": "Left",
+    /**
+     * Preserve the right operand derivative on ties.
+     */
+    Right: 1, "1": "Right",
+    /**
+     * Average derivatives on ties.
+     */
+    Average: 2, "2": "Average",
+});
 /**
  * Integration methods available in WASM
  * @enum {0 | 1 | 2 | 3 | 4}
@@ -3030,6 +3048,28 @@ export class TropicalBatch {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_tropicalbatch_free(ptr, 0);
     }
+    /**
+     * Fold values with tropical addition (`max`).
+     * @param {Float64Array} values
+     * @returns {number}
+     */
+    static foldOplus(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tropicalbatch_batchTropicalAdd(ptr0, len0);
+        return ret;
+    }
+    /**
+     * Fold values with tropical multiplication (`+`).
+     * @param {Float64Array} values
+     * @returns {number}
+     */
+    static foldOtimes(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tropicalbatch_foldOtimes(ptr0, len0);
+        return ret;
+    }
     /**
      * Convert array of log probabilities to tropical numbers and find maximum
      * @param {Float64Array} log_probs
@@ -4237,6 +4277,372 @@ export class WasmCapability {
     }
 }
 
+const WasmCgtArenaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcgtarena_free(ptr >>> 0, 1));
+/**
+ * Arena-backed short combinatorial game engine for WebAssembly.
+ */
+export class WasmCgtArena {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCgtArenaFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcgtarena_free(ptr, 0);
+    }
+    /**
+     * Return whether two games are equivalent.
+     * @param {WasmGameId} lhs
+     * @param {WasmGameId} rhs
+     * @returns {boolean}
+     */
+    equivalent(lhs, rhs) {
+        _assertClass(lhs, WasmGameId);
+        _assertClass(rhs, WasmGameId);
+        const ret = wasm.wasmcgtarena_equivalent(this.__wbg_ptr, lhs.__wbg_ptr, rhs.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return whether a game is numeric.
+     * @param {WasmGameId} game
+     * @returns {boolean}
+     */
+    isNumeric(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_isNumeric(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Number of interned arena nodes.
+     * @returns {number}
+     */
+    nodeCount() {
+        const ret = wasm.wasmcgtarena_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Format a game as recursive cut notation.
+     * @param {WasmGameId} game
+     * @returns {string}
+     */
+    formatGame(game) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(game, WasmGameId);
+            const ret = wasm.wasmcgtarena_formatGame(this.__wbg_ptr, game.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Return whether a game is impartial.
+     * @param {WasmGameId} game
+     * @returns {boolean}
+     */
+    isImpartial(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_isImpartial(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Format a game's canonical representative.
+     * @param {WasmGameId} game
+     * @returns {string}
+     */
+    formatCanonicalGame(game) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(game, WasmGameId);
+            const ret = wasm.wasmcgtarena_formatCanonicalGame(this.__wbg_ptr, game.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Add two short games.
+     * @param {WasmGameId} lhs
+     * @param {WasmGameId} rhs
+     * @returns {WasmGameId}
+     */
+    add(lhs, rhs) {
+        _assertClass(lhs, WasmGameId);
+        _assertClass(rhs, WasmGameId);
+        const ret = wasm.wasmcgtarena_add(this.__wbg_ptr, lhs.__wbg_ptr, rhs.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Build a one-left, one-right cut `{left | right}`.
+     * @param {WasmGameId} left
+     * @param {WasmGameId} right
+     * @returns {WasmGameId}
+     */
+    cut(left, right) {
+        _assertClass(left, WasmGameId);
+        _assertClass(right, WasmGameId);
+        const ret = wasm.wasmcgtarena_cut(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Negate a short game.
+     * @param {WasmGameId} game
+     * @returns {WasmGameId}
+     */
+    neg(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_neg(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Create an empty arena with the zero game interned lazily.
+     */
+    constructor() {
+        const ret = wasm.wasmcgtarena_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmCgtArenaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return the game `1 = {0 | }`.
+     * @returns {WasmGameId}
+     */
+    one() {
+        const ret = wasm.wasmcgtarena_one(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Subtract two short games.
+     * @param {WasmGameId} lhs
+     * @param {WasmGameId} rhs
+     * @returns {WasmGameId}
+     */
+    sub(lhs, rhs) {
+        _assertClass(lhs, WasmGameId);
+        _assertClass(rhs, WasmGameId);
+        const ret = wasm.wasmcgtarena_sub(this.__wbg_ptr, lhs.__wbg_ptr, rhs.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Return the star game `{0 | 0}`.
+     * @returns {WasmGameId}
+     */
+    star() {
+        const ret = wasm.wasmcgtarena_star(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Return the zero game `{ | }`.
+     * @returns {WasmGameId}
+     */
+    zero() {
+        const ret = wasm.wasmcgtarena_zero(this.__wbg_ptr);
+        return WasmGameId.__wrap(ret);
+    }
+    /**
+     * Compute the Grundy nimber of an impartial game.
+     * @param {WasmGameId} game
+     * @returns {number}
+     */
+    grundy(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_grundy(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Compare two games in the partizan order.
+     * @param {WasmGameId} lhs
+     * @param {WasmGameId} rhs
+     * @returns {string}
+     */
+    compare(lhs, rhs) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(lhs, WasmGameId);
+            _assertClass(rhs, WasmGameId);
+            const ret = wasm.wasmcgtarena_compare(this.__wbg_ptr, lhs.__wbg_ptr, rhs.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Inspect canonical, numeric, impartial, outcome, and size metadata.
+     * @param {WasmGameId} game
+     * @returns {WasmGameInspection}
+     */
+    inspect(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_inspect(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameInspection.__wrap(ret[0]);
+    }
+    /**
+     * Return the normal-play outcome class.
+     * @param {WasmGameId} game
+     * @returns {string}
+     */
+    outcome(game) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(game, WasmGameId);
+            const ret = wasm.wasmcgtarena_outcome(this.__wbg_ptr, game.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Return the game's birthday.
+     * @param {WasmGameId} game
+     * @returns {number}
+     */
+    birthday(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_birthday(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Build a one-left-option game `{left | }`.
+     * @param {WasmGameId} left
+     * @returns {WasmGameId}
+     */
+    leftCut(left) {
+        _assertClass(left, WasmGameId);
+        const ret = wasm.wasmcgtarena_leftCut(this.__wbg_ptr, left.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Build a Nim heap of the requested size.
+     * @param {number} size
+     * @returns {WasmGameId}
+     */
+    nimHeap(size) {
+        const ret = wasm.wasmcgtarena_nimHeap(this.__wbg_ptr, size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Canonicalize a game and return the canonical representative handle.
+     * @param {WasmGameId} game
+     * @returns {WasmGameId}
+     */
+    canonical(game) {
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmcgtarena_canonical(this.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Return the game `-1 = {| 0}`.
+     * @returns {WasmGameId}
+     */
+    minusOne() {
+        const ret = wasm.wasmcgtarena_minusOne(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Build a one-right-option game `{ | right}`.
+     * @param {WasmGameId} right
+     * @returns {WasmGameId}
+     */
+    rightCut(right) {
+        _assertClass(right, WasmGameId);
+        const ret = wasm.wasmcgtarena_rightCut(this.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+}
+
 const WasmChowClassFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmchowclass_free(ptr >>> 0, 1));
@@ -4651,6 +5057,28 @@ export class WasmDualNumber {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmdualnumber_free(ptr, 0);
     }
+    /**
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmDualNumber}
+     */
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmDualNumber);
+        const ret = wasm.wasmdualnumber_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmDualNumber.__wrap(ret);
+    }
+    /**
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmDualNumber}
+     */
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmDualNumber);
+        const ret = wasm.wasmdualnumber_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmDualNumber.__wrap(ret);
+    }
     /**
      * Natural logarithm
      * @returns {WasmDualNumber}
@@ -5002,76 +5430,291 @@ export class WasmDuallyFlatManifold {
     }
 }
 
-const WasmEquivariantLocalizerFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmDyadicFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmequivariantlocalizer_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmdyadic_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for equivariant localization on Grassmannians
+ * Exact dyadic rational `numerator / 2^exponent` for short surreal values.
  */
-export class WasmEquivariantLocalizer {
+export class WasmDyadic {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmEquivariantLocalizer.prototype);
+        const obj = Object.create(WasmDyadic.prototype);
         obj.__wbg_ptr = ptr;
-        WasmEquivariantLocalizerFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmDyadicFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmEquivariantLocalizerFinalization.unregister(this);
+        WasmDyadicFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmequivariantlocalizer_free(ptr, 0);
+        wasm.__wbg_wasmdyadic_free(ptr, 0);
     }
     /**
-     * Create a localizer with custom torus weights
-     * @param {number} k
-     * @param {number} n
-     * @param {WasmTorusWeights} weights
-     * @returns {WasmEquivariantLocalizer}
+     * Checked division; fails if the quotient leaves the dyadic layer.
+     * @param {WasmDyadic} rhs
+     * @returns {WasmDyadic}
      */
-    static withWeights(k, n, weights) {
-        _assertClass(weights, WasmTorusWeights);
-        const ret = wasm.wasmequivariantlocalizer_withWeights(k, n, weights.__wbg_ptr);
+    checkedDiv(rhs) {
+        _assertClass(rhs, WasmDyadic);
+        const ret = wasm.wasmdyadic_checkedDiv(this.__wbg_ptr, rhs.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmEquivariantLocalizer.__wrap(ret[0]);
+        return WasmDyadic.__wrap(ret[0]);
     }
     /**
-     * Number of torus fixed points (= C(n, k))
-     * @returns {number}
+     * Return whether the dyadic is negative.
+     * @returns {boolean}
      */
-    fixedPointCount() {
-        const ret = wasm.wasmequivariantlocalizer_fixedPointCount(this.__wbg_ptr);
-        return ret >>> 0;
+    isNegative() {
+        const ret = wasm.wasmdyadic_isNegative(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Compute localized intersection of Schubert classes
-     * @param {WasmSchubertClass[]} classes
-     * @returns {number}
+     * Return whether the dyadic is positive.
+     * @returns {boolean}
      */
-    localizedIntersection(classes) {
-        const ptr0 = passArrayJsValueToWasm0(classes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmequivariantlocalizer_localizedIntersection(this.__wbg_ptr, ptr0, len0);
-        return ret;
+    isPositive() {
+        const ret = wasm.wasmdyadic_isPositive(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Create a localizer for Gr(k, n) with standard weights
-     * @param {number} k
-     * @param {number} n
+     * Create a dyadic integer.
+     * @param {number} value
+     * @returns {WasmDyadic}
      */
-    constructor(k, n) {
-        const ret = wasm.wasmequivariantlocalizer_new(k, n);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    static fromInteger(value) {
+        const ret = wasm.wasmdyadic_fromInteger(value);
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Numerator as a base-10 string.
+     * @returns {string}
+     */
+    numeratorString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmdyadic_numeratorString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Checked reciprocal within the dyadic short-surreal layer.
+     * @returns {WasmDyadic}
+     */
+    checkedReciprocal() {
+        const ret = wasm.wasmdyadic_checkedReciprocal(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDyadic.__wrap(ret[0]);
+    }
+    /**
+     * Absolute value.
+     * @returns {WasmDyadic}
+     */
+    abs() {
+        const ret = wasm.wasmdyadic_abs(this.__wbg_ptr);
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Add two dyadics exactly.
+     * @param {WasmDyadic} rhs
+     * @returns {WasmDyadic}
+     */
+    add(rhs) {
+        _assertClass(rhs, WasmDyadic);
+        const ret = wasm.wasmdyadic_add(this.__wbg_ptr, rhs.__wbg_ptr);
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Multiply two dyadics exactly.
+     * @param {WasmDyadic} rhs
+     * @returns {WasmDyadic}
+     */
+    mul(rhs) {
+        _assertClass(rhs, WasmDyadic);
+        const ret = wasm.wasmdyadic_mul(this.__wbg_ptr, rhs.__wbg_ptr);
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Negate the dyadic.
+     * @returns {WasmDyadic}
+     */
+    neg() {
+        const ret = wasm.wasmdyadic_neg(this.__wbg_ptr);
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Create and normalize a dyadic rational `numerator / 2^exponent`.
+     * @param {number} numerator
+     * @param {number} exponent
+     */
+    constructor(numerator, exponent) {
+        const ret = wasm.wasmdyadic_new(numerator, exponent);
+        this.__wbg_ptr = ret >>> 0;
+        WasmDyadicFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return one.
+     * @returns {WasmDyadic}
+     */
+    static one() {
+        const ret = wasm.wasmdyadic_one();
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Subtract two dyadics exactly.
+     * @param {WasmDyadic} rhs
+     * @returns {WasmDyadic}
+     */
+    sub(rhs) {
+        _assertClass(rhs, WasmDyadic);
+        const ret = wasm.wasmdyadic_sub(this.__wbg_ptr, rhs.__wbg_ptr);
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Return the sign as `negative`, `zero`, or `positive`.
+     * @returns {string}
+     */
+    sign() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmdyadic_sign(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Return zero.
+     * @returns {WasmDyadic}
+     */
+    static zero() {
+        const ret = wasm.wasmdyadic_zero();
+        return WasmDyadic.__wrap(ret);
+    }
+    /**
+     * Format as an integer or rational string.
+     * @returns {string}
+     */
+    format() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmdyadic_format(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Return whether the dyadic is zero.
+     * @returns {boolean}
+     */
+    isZero() {
+        const ret = wasm.wasmdyadic_isZero(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Power-of-two denominator exponent.
+     * @returns {number}
+     */
+    exponent() {
+        const ret = wasm.wasmbinaryhologram_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
+const WasmEquivariantLocalizerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmequivariantlocalizer_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for equivariant localization on Grassmannians
+ */
+export class WasmEquivariantLocalizer {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmEquivariantLocalizer.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmEquivariantLocalizerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmEquivariantLocalizerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmequivariantlocalizer_free(ptr, 0);
+    }
+    /**
+     * Create a localizer with custom torus weights
+     * @param {number} k
+     * @param {number} n
+     * @param {WasmTorusWeights} weights
+     * @returns {WasmEquivariantLocalizer}
+     */
+    static withWeights(k, n, weights) {
+        _assertClass(weights, WasmTorusWeights);
+        const ret = wasm.wasmequivariantlocalizer_withWeights(k, n, weights.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmEquivariantLocalizer.__wrap(ret[0]);
+    }
+    /**
+     * Number of torus fixed points (= C(n, k))
+     * @returns {number}
+     */
+    fixedPointCount() {
+        const ret = wasm.wasmequivariantlocalizer_fixedPointCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Compute localized intersection of Schubert classes
+     * @param {WasmSchubertClass[]} classes
+     * @returns {number}
+     */
+    localizedIntersection(classes) {
+        const ptr0 = passArrayJsValueToWasm0(classes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmequivariantlocalizer_localizedIntersection(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Create a localizer for Gr(k, n) with standard weights
+     * @param {number} k
+     * @param {number} n
+     */
+    constructor(k, n) {
+        const ret = wasm.wasmequivariantlocalizer_new(k, n);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
         WasmEquivariantLocalizerFinalization.register(this, this.__wbg_ptr, this);
@@ -5902,105 +6545,269 @@ export class WasmGF2Vector {
     }
 }
 
-const WasmGaussianMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmGameIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgaussianmultivector_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgameid_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for Gaussian distribution on Cl(3,0,0) multivector space
- *
- * A Gaussian distribution over 8-dimensional multivector space with
- * configurable mean and per-component standard deviation.
+ * Opaque handle for a short combinatorial game stored in a `WasmCgtArena`.
  */
-export class WasmGaussianMultivector {
+export class WasmGameId {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmGaussianMultivector.prototype);
+        const obj = Object.create(WasmGameId.prototype);
         obj.__wbg_ptr = ptr;
-        WasmGaussianMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmGameIdFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmGaussianMultivectorFinalization.unregister(this);
+        WasmGameIdFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmgaussianmultivector_free(ptr, 0);
+        wasm.__wbg_wasmgameid_free(ptr, 0);
     }
     /**
-     * Get the standard deviations
-     *
-     * Returns 8 values
-     * @returns {Float64Array}
+     * Returns whether two game handles point at the same arena-local game.
+     * @param {WasmGameId} other
+     * @returns {boolean}
      */
-    getStdDevs() {
-        const ret = wasm.wasmgaussianmultivector_getStdDevs(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    same(other) {
+        _assertClass(other, WasmGameId);
+        const ret = wasm.wasmgameid_same(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
     }
-    /**
-     * Get the variance (square of std devs)
-     *
-     * Returns 8 values
-     * @returns {Float64Array}
-     */
-    getVariance() {
-        const ret = wasm.wasmgaussianmultivector_getVariance(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+}
+
+const WasmGameInspectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgameinspection_free(ptr >>> 0, 1));
+/**
+ * Inspection summary for a short combinatorial game.
+ */
+export class WasmGameInspection {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGameInspection.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGameInspectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGameInspectionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgameinspection_free(ptr, 0);
     }
     /**
-     * Draw multiple samples from this distribution
-     *
-     * Returns flat array of coefficients: num_samples * 8
-     * @param {number} num_samples
-     * @returns {Float64Array}
+     * Whether the game is numeric.
+     * @returns {boolean}
      */
-    sampleBatch(num_samples) {
-        const ret = wasm.wasmgaussianmultivector_sampleBatch(this.__wbg_ptr, num_samples);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    isNumeric() {
+        const ret = wasm.wasmgameinspection_isNumeric(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Get the full covariance matrix (flattened, row-major)
-     *
-     * Returns 64 values (8x8 matrix)
-     * @returns {Float64Array}
+     * Whether the game is partizan.
+     * @returns {boolean}
      */
-    getCovariance() {
-        const ret = wasm.wasmgaussianmultivector_getCovariance(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    isPartizan() {
+        const ret = wasm.wasmgameinspection_isPartizan(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * Create a Gaussian with specified mean and standard deviation
-     *
-     * # Arguments
-     * * `mean` - 8 coefficients for the mean multivector
-     * * `std_dev` - 8 coefficients for per-coefficient standard deviation
-     * @param {Float64Array} mean
-     * @param {Float64Array} std_dev
-     * @returns {WasmGaussianMultivector}
+     * Whether the game already is its canonical representative.
+     * @returns {boolean}
      */
-    static withParameters(mean, std_dev) {
-        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(std_dev, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmgaussianmultivector_withParameters(ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmGaussianMultivector.__wrap(ret[0]);
+    isCanonical() {
+        const ret = wasm.wasmgameinspection_isCanonical(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether the game is impartial.
+     * @returns {boolean}
+     */
+    isImpartial() {
+        const ret = wasm.wasmgameinspection_isImpartial(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Canonical structural form as recursive cut notation.
+     * @returns {string}
+     */
+    canonicalForm() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmgameinspection_canonicalForm(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Whether the game is non-numeric.
+     * @returns {boolean}
+     */
+    isNonNumeric() {
+        const ret = wasm.wasmgameinspection_isNonNumeric(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Number of reachable arena nodes in the game DAG.
+     * @returns {number}
+     */
+    reachableNodeCount() {
+        const ret = wasm.wasmgameinspection_reachableNodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Normal-play outcome class.
+     * @returns {string}
+     */
+    outcome() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmgameinspection_outcome(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Birthday of the inspected game.
+     * @returns {number}
+     */
+    birthday() {
+        const ret = wasm.wasmgameinspection_birthday(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Canonical representative handle.
+     * @returns {WasmGameId}
+     */
+    canonical() {
+        const ret = wasm.wasmgameinspection_canonical(this.__wbg_ptr);
+        return WasmGameId.__wrap(ret);
+    }
+}
+
+const WasmGaussianMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgaussianmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Gaussian distribution on Cl(3,0,0) multivector space
+ *
+ * A Gaussian distribution over 8-dimensional multivector space with
+ * configurable mean and per-component standard deviation.
+ */
+export class WasmGaussianMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGaussianMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGaussianMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGaussianMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgaussianmultivector_free(ptr, 0);
+    }
+    /**
+     * Get the standard deviations
+     *
+     * Returns 8 values
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmgaussianmultivector_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the variance (square of std devs)
+     *
+     * Returns 8 values
+     * @returns {Float64Array}
+     */
+    getVariance() {
+        const ret = wasm.wasmgaussianmultivector_getVariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Draw multiple samples from this distribution
+     *
+     * Returns flat array of coefficients: num_samples * 8
+     * @param {number} num_samples
+     * @returns {Float64Array}
+     */
+    sampleBatch(num_samples) {
+        const ret = wasm.wasmgaussianmultivector_sampleBatch(this.__wbg_ptr, num_samples);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the full covariance matrix (flattened, row-major)
+     *
+     * Returns 64 values (8x8 matrix)
+     * @returns {Float64Array}
+     */
+    getCovariance() {
+        const ret = wasm.wasmgaussianmultivector_getCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a Gaussian with specified mean and standard deviation
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean multivector
+     * * `std_dev` - 8 coefficients for per-coefficient standard deviation
+     * @param {Float64Array} mean
+     * @param {Float64Array} std_dev
+     * @returns {WasmGaussianMultivector}
+     */
+    static withParameters(mean, std_dev) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(std_dev, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgaussianmultivector_withParameters(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGaussianMultivector.__wrap(ret[0]);
     }
     /**
      * Create a Gaussian concentrated on a specific grade
@@ -8574,6 +9381,34 @@ export class WasmMultiDualNumber {
         const ret = wasm.wasmmultidualnumber_getNumVars(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmMultiDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmMultiDualNumber}
+     */
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmMultiDualNumber);
+        const ret = wasm.wasmmultidualnumber_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultiDualNumber.__wrap(ret[0]);
+    }
+    /**
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmMultiDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmMultiDualNumber}
+     */
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmMultiDualNumber);
+        const ret = wasm.wasmmultidualnumber_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultiDualNumber.__wrap(ret[0]);
+    }
     /**
      * Addition
      * @param {WasmMultiDualNumber} other
@@ -8653,6 +9488,17 @@ export class WasmMultiDualNumber {
         const ret = wasm.wasmmultidualnumber_variable(value, num_vars, var_index);
         return WasmMultiDualNumber.__wrap(ret);
     }
+    /**
+     * Create one basis-seeded variable per input coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
+     */
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmultidualnumber_variables(ptr0, len0);
+        return ret;
+    }
 }
 
 const WasmMultiObjectiveOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -9816,7 +10662,7 @@ export class WasmOpticalRotorField {
      * @returns {number}
      */
     get width() {
-        const ret = wasm.wasmopticalrotorfield_width(this.__wbg_ptr);
+        const ret = wasm.wasmgameinspection_reachableNodeCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -9998,513 +10844,1002 @@ export class WasmOptimizationUtils {
     }
 }
 
-const WasmParametricDensityFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmOrdinalFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmparametricdensity_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmordinal_free(ptr >>> 0, 1));
 /**
- * Parametric probability density families
+ * Arena-bound handle for an ordinal below ε₀.
  */
-export class WasmParametricDensity {
+export class WasmOrdinal {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmParametricDensity.prototype);
+        const obj = Object.create(WasmOrdinal.prototype);
         obj.__wbg_ptr = ptr;
-        WasmParametricDensityFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmOrdinalFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmParametricDensityFinalization.unregister(this);
+        WasmOrdinalFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmparametricdensity_free(ptr, 0);
+        wasm.__wbg_wasmordinal_free(ptr, 0);
     }
     /**
-     * Create an Exponential density Exp(λ)
-     * @returns {WasmParametricDensity}
+     * Raw arena-local ordinal index.
+     * @returns {number}
      */
-    static exponential() {
-        const ret = wasm.wasmparametricdensity_exponential();
-        return WasmParametricDensity.__wrap(ret);
+    getIndex() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
+const WasmOrdinalArenaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmordinalarena_free(ptr >>> 0, 1));
+/**
+ * Arena-backed store for canonical ordinals below ε₀.
+ */
+export class WasmOrdinalArena {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOrdinalArenaFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmordinalarena_free(ptr, 0);
     }
     /**
-     * Compute log-density log p(x|θ)
-     * @param {number} x
-     * @param {Float64Array} params
+     * Number of interned ordinal nodes.
      * @returns {number}
      */
-    logDensity(x, params) {
-        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_logDensity(this.__wbg_ptr, x, ptr0, len0);
+    nodeCount() {
+        const ret = wasm.wasmordinalarena_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of CNF terms.
+     * @param {WasmOrdinal} ordinal
+     * @returns {number}
+     */
+    termCount(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_termCount(this.__wbg_ptr, ordinal.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return ret[0] >>> 0;
     }
     /**
-     * Compute Fisher information matrix from data samples
-     * @param {Float64Array} data
-     * @param {Float64Array} params
-     * @returns {Float64Array}
+     * Select the best of two weights using semiring-style `max`.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
      */
-    fisherInformation(data, params) {
-        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_fisherInformation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    bestWeight2(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_bestWeight2(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Create a Cauchy density Cauchy(x₀, γ)
-     * @returns {WasmParametricDensity}
+     * Select the best of three weights using semiring-style `max`.
+     * @param {WasmOrdinalWeight} first
+     * @param {WasmOrdinalWeight} second
+     * @param {WasmOrdinalWeight} third
+     * @returns {WasmOrdinalWeight}
      */
-    static cauchy() {
-        const ret = wasm.wasmparametricdensity_cauchy();
-        return WasmParametricDensity.__wrap(ret);
+    bestWeight3(first, second, third) {
+        _assertClass(first, WasmOrdinalWeight);
+        _assertClass(second, WasmOrdinalWeight);
+        _assertClass(third, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_bestWeight3(this.__wbg_ptr, first.__wbg_ptr, second.__wbg_ptr, third.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Create a Laplace density Laplace(μ, b)
-     * @returns {WasmParametricDensity}
+     * Finite value when the ordinal is finite.
+     * @param {WasmOrdinal} ordinal
+     * @returns {number | undefined}
      */
-    static laplace() {
-        const ret = wasm.wasmparametricdensity_laplace();
-        return WasmParametricDensity.__wrap(ret);
-    }
+    finiteValue(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_finiteValue(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
     /**
-     * Evaluate density at point x with parameters
-     *
-     * # Arguments
-     * * `x` - Point to evaluate
-     * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
-     * @param {number} x
-     * @param {Float64Array} params
+     * Return true if this is a successor ordinal.
+     * @param {WasmOrdinal} ordinal
+     * @returns {boolean}
+     */
+    isSuccessor(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_isSuccessor(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Semiring-style additive combination (`max`) for ordinal weights.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
+     */
+    oplusWeight(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_oplusWeight(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
+    }
+    /**
+     * Format an ordinal weight.
+     * @param {WasmOrdinalWeight} weight
+     * @returns {string}
+     */
+    formatWeight(weight) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(weight, WasmOrdinalWeight);
+            const ret = wasm.wasmordinalarena_formatWeight(this.__wbg_ptr, weight.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Semiring-style multiplicative composition (ordinal addition) for weights.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
+     */
+    otimesWeight(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_otimesWeight(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
+    }
+    /**
+     * Compare two weights: -1 for less, 0 for equal, 1 for greater.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
      * @returns {number}
      */
-    evaluate(x, params) {
-        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_evaluate(this.__wbg_ptr, x, ptr0, len0);
+    compareWeight(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_compareWeight(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0];
     }
     /**
-     * Create a Gaussian density N(μ, σ²)
-     * @returns {WasmParametricDensity}
+     * Format an ordinal in Cantor normal form.
+     * @param {WasmOrdinal} ordinal
+     * @returns {string}
      */
-    static gaussian() {
-        const ret = wasm.wasmparametricdensity_gaussian();
-        return WasmParametricDensity.__wrap(ret);
+    formatOrdinal(ordinal) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(ordinal, WasmOrdinal);
+            const ret = wasm.wasmordinalarena_formatOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
     /**
-     * Compute numerical gradient ∇_θ p(x|θ)
-     * @param {number} x
-     * @param {Float64Array} params
-     * @returns {Float64Array}
+     * Compose two weights using ordinal addition with bottom annihilation.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
      */
-    gradient(x, params) {
-        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_gradient(this.__wbg_ptr, x, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    composeWeight2(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_composeWeight2(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
-}
-
-const WasmPartitionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpartition_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for partitions used in Schubert calculus and LR coefficients
- */
-export class WasmPartition {
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof WasmPartition)) {
-            return 0;
+    /**
+     * Compose three weights using ordinal addition with bottom annihilation.
+     * @param {WasmOrdinalWeight} first
+     * @param {WasmOrdinalWeight} second
+     * @param {WasmOrdinalWeight} third
+     * @returns {WasmOrdinalWeight}
+     */
+    composeWeight3(first, second, third) {
+        _assertClass(first, WasmOrdinalWeight);
+        _assertClass(second, WasmOrdinalWeight);
+        _assertClass(third, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_composeWeight3(this.__wbg_ptr, first.__wbg_ptr, second.__wbg_ptr, third.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        return jsValue.__destroy_into_raw();
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmPartitionFinalization.unregister(this);
-        return ptr;
+    /**
+     * Build a JavaScript object with ordinal inspection metadata.
+     * @param {WasmOrdinal} ordinal
+     * @returns {any}
+     */
+    inspectOrdinal(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_inspectOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpartition_free(ptr, 0);
+    /**
+     * Return true if the ordinal is zero.
+     * @param {WasmOrdinal} ordinal
+     * @returns {boolean}
+     */
+    isZeroOrdinal(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_isZeroOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
     }
     /**
-     * Get the length (number of non-zero parts) of this partition
-     * @returns {number}
+     * Construct a weight from an ordinal.
+     * @param {WasmOrdinal} ordinal
+     * @returns {WasmOrdinalWeight}
      */
-    getLength() {
-        const ret = wasm.wasmopticalrotorfield_length(this.__wbg_ptr);
-        return ret >>> 0;
+    weightFromOrdinal(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_weightFromOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+        return WasmOrdinalWeight.__wrap(ret);
     }
     /**
-     * Check if this partition fits in a k × (n-k) box (for Grassmannian)
-     * @param {number} k
-     * @param {number} n
-     * @returns {boolean}
+     * Ordinal addition.
+     * @param {WasmOrdinal} left
+     * @param {WasmOrdinal} right
+     * @returns {WasmOrdinal}
      */
-    fitsInBox(k, n) {
-        const ret = wasm.wasmpartition_fitsInBox(this.__wbg_ptr, k, n);
-        return ret !== 0;
+    add(left, right) {
+        _assertClass(left, WasmOrdinal);
+        _assertClass(right, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_add(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinal.__wrap(ret[0]);
     }
     /**
-     * Create a new partition from an array of parts
-     * @param {Uint32Array} parts
+     * Create an ordinal arena containing zero.
      */
-    constructor(parts) {
-        const ptr0 = passArray32ToWasm0(parts, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmpartition_new(ptr0, len0);
+    constructor() {
+        const ret = wasm.wasmordinalarena_new();
         this.__wbg_ptr = ret >>> 0;
-        WasmPartitionFinalization.register(this, this.__wbg_ptr, this);
+        WasmOrdinalArenaFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Check if this partition contains another (for skew shapes)
-     * @param {WasmPartition} other
-     * @returns {boolean}
+     * Finite ordinal one.
+     * @returns {WasmOrdinal}
      */
-    contains(other) {
-        _assertClass(other, WasmPartition);
-        const ret = wasm.wasmpartition_contains(this.__wbg_ptr, other.__wbg_ptr);
-        return ret !== 0;
+    one() {
+        const ret = wasm.wasmordinalarena_one(this.__wbg_ptr);
+        return WasmOrdinal.__wrap(ret);
     }
     /**
-     * Get the size (sum of parts) of this partition
+     * Structural kind: zero, finite, successor, or limit.
+     * @param {WasmOrdinal} ordinal
+     * @returns {string}
+     */
+    kind(ordinal) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(ordinal, WasmOrdinal);
+            const ret = wasm.wasmordinalarena_kind(this.__wbg_ptr, ordinal.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Canonical zero ordinal.
+     * @returns {WasmOrdinal}
+     */
+    zero() {
+        const ret = wasm.wasmordinalarena_zero(this.__wbg_ptr);
+        return WasmOrdinal.__wrap(ret);
+    }
+    /**
+     * The ordinal ω.
+     * @returns {WasmOrdinal}
+     */
+    omega() {
+        const ret = wasm.wasmordinalarena_omega(this.__wbg_ptr);
+        return WasmOrdinal.__wrap(ret);
+    }
+    /**
+     * Finite natural ordinal `n`.
+     * @param {number} n
+     * @returns {WasmOrdinal}
+     */
+    finite(n) {
+        const ret = wasm.wasmordinalarena_finite(this.__wbg_ptr, n);
+        return WasmOrdinal.__wrap(ret);
+    }
+    /**
+     * Compare two ordinals: -1 for less, 0 for equal, 1 for greater.
+     * @param {WasmOrdinal} left
+     * @param {WasmOrdinal} right
      * @returns {number}
      */
-    getSize() {
-        const ret = wasm.wasmpartition_getSize(this.__wbg_ptr);
-        return ret >>> 0;
+    compare(left, right) {
+        _assertClass(left, WasmOrdinal);
+        _assertClass(right, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_compare(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Check if this partition is valid (weakly decreasing, positive parts)
+     * Return true if this is a nonzero limit ordinal.
+     * @param {WasmOrdinal} ordinal
      * @returns {boolean}
      */
-    isValid() {
-        const ret = wasm.wasmpartition_isValid(this.__wbg_ptr);
-        return ret !== 0;
+    isLimit(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_isLimit(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
     }
     /**
-     * Get the parts of this partition
-     * @returns {Uint32Array}
+     * Leading-exponent valuation of a weight, if any.
+     * @param {WasmOrdinalWeight} weight
+     * @returns {number | undefined}
      */
-    getParts() {
-        const ret = wasm.wasmpartition_getParts(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    valuation(weight) {
+        _assertClass(weight, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_valuation(this.__wbg_ptr, weight.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0x100000001 ? undefined : ret[0];
     }
 }
 
-const WasmPersistentHomologyFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmOrdinalWeightFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpersistenthomology_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmordinalweight_free(ptr >>> 0, 1));
 /**
- * Result of persistent homology computation.
+ * Bottom-extended ordinal optimization weight.
  */
-export class WasmPersistentHomology {
+export class WasmOrdinalWeight {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmPersistentHomology.prototype);
+        const obj = Object.create(WasmOrdinalWeight.prototype);
         obj.__wbg_ptr = ptr;
-        WasmPersistentHomologyFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmOrdinalWeightFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmPersistentHomologyFinalization.unregister(this);
+        WasmOrdinalWeightFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpersistenthomology_free(ptr, 0);
+        wasm.__wbg_wasmordinalweight_free(ptr, 0);
     }
     /**
-     * Get the persistence diagram as an array of [dimension, birth, death] triples.
-     * @returns {Float64Array}
+     * Arena-local ordinal index when this weight wraps an ordinal.
+     * @returns {number | undefined}
      */
-    getDiagram() {
-        const ret = wasm.wasmpersistenthomology_getDiagram(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    ordinalIndex() {
+        const ret = wasm.wasmordinalweight_ordinalIndex(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
     }
     /**
-     * Get the number of intervals in dimension k.
-     * @param {number} dim
-     * @returns {number}
+     * Construct the semiring one element, i.e. ordinal zero.
+     * @returns {WasmOrdinalWeight}
      */
-    intervalCount(dim) {
-        const ret = wasm.wasmpersistenthomology_intervalCount(this.__wbg_ptr, dim);
-        return ret >>> 0;
+    static one() {
+        const ret = wasm.wasmordinalweight_one();
+        return WasmOrdinalWeight.__wrap(ret);
     }
     /**
-     * Compute persistent homology from a filtration.
-     * @param {WasmFiltration} filtration
-     * @returns {WasmPersistentHomology}
+     * Alias for the semiring zero element.
+     * @returns {WasmOrdinalWeight}
      */
-    static compute(filtration) {
-        _assertClass(filtration, WasmFiltration);
-        const ret = wasm.wasmpersistenthomology_compute(filtration.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmPersistentHomology.__wrap(ret[0]);
+    static zero() {
+        const ret = wasm.wasmordinalweight_bottom();
+        return WasmOrdinalWeight.__wrap(ret);
     }
     /**
-     * Get the Betti numbers at a specific filtration time.
-     * @param {number} time
-     * @returns {Uint32Array}
+     * Construct the bottom element.
+     * @returns {WasmOrdinalWeight}
      */
-    bettiAt(time) {
-        const ret = wasm.wasmpersistenthomology_bettiAt(this.__wbg_ptr, time);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    static bottom() {
+        const ret = wasm.wasmordinalweight_bottom();
+        return WasmOrdinalWeight.__wrap(ret);
+    }
+    /**
+     * Whether this weight is bottom.
+     * @returns {boolean}
+     */
+    isBottom() {
+        const ret = wasm.wasmordinalweight_isBottom(this.__wbg_ptr);
+        return ret !== 0;
     }
 }
 
-const WasmProbFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmParametricDensityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprob_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmparametricdensity_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for probabilistic values
- *
- * Wraps an f64 value with associated probability metadata.
- * Supports mapping, composition, and probability tracking.
+ * Parametric probability density families
  */
-export class WasmProb {
+export class WasmParametricDensity {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmProb.prototype);
+        const obj = Object.create(WasmParametricDensity.prototype);
         obj.__wbg_ptr = ptr;
-        WasmProbFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmParametricDensityFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmProbFinalization.unregister(this);
+        WasmParametricDensityFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmprob_free(ptr, 0);
+        wasm.__wbg_wasmparametricdensity_free(ptr, 0);
     }
     /**
-     * Get the probability associated with this value
-     * @returns {number}
+     * Create an Exponential density Exp(λ)
+     * @returns {WasmParametricDensity}
      */
-    probability() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
+    static exponential() {
+        const ret = wasm.wasmparametricdensity_exponential();
+        return WasmParametricDensity.__wrap(ret);
     }
     /**
-     * Create a value with specified probability
-     *
-     * Probability must be in [0, 1].
-     * @param {number} probability
-     * @param {number} value
-     * @returns {WasmProb}
+     * Compute log-density log p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {number}
      */
-    static withProbability(probability, value) {
-        const ret = wasm.wasmprob_withProbability(probability, value);
+    logDensity(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_logDensity(this.__wbg_ptr, x, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmProb.__wrap(ret[0]);
+        return ret[0];
     }
     /**
-     * Map the value by multiplying with a factor, preserving probability
-     * @param {number} factor
-     * @returns {WasmProb}
+     * Compute Fisher information matrix from data samples
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {Float64Array}
      */
-    map(factor) {
-        const ret = wasm.wasmprob_map(this.__wbg_ptr, factor);
-        return WasmProb.__wrap(ret);
+    fisherInformation(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_fisherInformation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
     }
     /**
-     * Create a certain value (probability = 1.0)
-     * @param {number} value
+     * Create a Cauchy density Cauchy(x₀, γ)
+     * @returns {WasmParametricDensity}
      */
-    constructor(value) {
-        const ret = wasm.wasmdualnumber_variable(value);
-        this.__wbg_ptr = ret >>> 0;
-        WasmProbFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static cauchy() {
+        const ret = wasm.wasmparametricdensity_cauchy();
+        return WasmParametricDensity.__wrap(ret);
     }
     /**
-     * Get the wrapped value
-     * @returns {number}
+     * Create a Laplace density Laplace(μ, b)
+     * @returns {WasmParametricDensity}
      */
-    value() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
-        return ret;
+    static laplace() {
+        const ret = wasm.wasmparametricdensity_laplace();
+        return WasmParametricDensity.__wrap(ret);
     }
     /**
-     * Sample this probabilistic value
+     * Evaluate density at point x with parameters
      *
-     * Returns the value with probability p, or NaN otherwise.
+     * # Arguments
+     * * `x` - Point to evaluate
+     * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
+     * @param {number} x
+     * @param {Float64Array} params
      * @returns {number}
      */
-    sample() {
-        const ret = wasm.wasmprob_sample(this.__wbg_ptr);
-        return ret;
+    evaluate(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_evaluate(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Combine with another probabilistic value (independent)
-     *
-     * Multiplies probabilities and values together.
-     * @param {number} other_probability
-     * @param {number} other_value
-     * @returns {WasmProb}
+     * Create a Gaussian density N(μ, σ²)
+     * @returns {WasmParametricDensity}
      */
-    andThen(other_probability, other_value) {
-        const ret = wasm.wasmprob_andThen(this.__wbg_ptr, other_probability, other_value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    static gaussian() {
+        const ret = wasm.wasmparametricdensity_gaussian();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Compute numerical gradient ∇_θ p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    gradient(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_gradient(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
-        return WasmProb.__wrap(ret[0]);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
 
-const WasmProbabilityMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmPartitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprobabilitymeasure_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpartition_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for probability measures
- *
- * A probability measure assigns total measure 1 to the entire space.
+ * WASM wrapper for partitions used in Schubert calculus and LR coefficients
  */
-export class WasmProbabilityMeasure {
+export class WasmPartition {
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmProbabilityMeasure.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmProbabilityMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof WasmPartition)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmProbabilityMeasureFinalization.unregister(this);
+        WasmPartitionFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmprobabilitymeasure_free(ptr, 0);
+        wasm.__wbg_wasmpartition_free(ptr, 0);
     }
     /**
-     * Get a description of this probability measure
-     * @returns {string}
+     * Get the length (number of non-zero parts) of this partition
+     * @returns {number}
      */
-    getDescription() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmprobabilitymeasure_getDescription(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
+    getLength() {
+        const ret = wasm.wasmopticalrotorfield_length(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Compute P(X ∈ [a, b]) for uniform distribution
-     * @param {number} a
-     * @param {number} b
-     * @param {number} lower
-     * @param {number} upper
-     * @returns {number}
+     * Check if this partition fits in a k × (n-k) box (for Grassmannian)
+     * @param {number} k
+     * @param {number} n
+     * @returns {boolean}
      */
-    probabilityInterval(a, b, lower, upper) {
-        const ret = wasm.wasmprobabilitymeasure_probabilityInterval(this.__wbg_ptr, a, b, lower, upper);
-        return ret;
+    fitsInBox(k, n) {
+        const ret = wasm.wasmpartition_fitsInBox(this.__wbg_ptr, k, n);
+        return ret !== 0;
     }
     /**
-     * Create a new uniform probability measure on [0, 1]
+     * Create a new partition from an array of parts
+     * @param {Uint32Array} parts
      */
-    constructor() {
-        const ret = wasm.wasmprobabilitymeasure_new();
+    constructor(parts) {
+        const ptr0 = passArray32ToWasm0(parts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpartition_new(ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
-        WasmProbabilityMeasureFinalization.register(this, this.__wbg_ptr, this);
+        WasmPartitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Create a uniform probability measure on [a, b]
-     * @param {number} a
-     * @param {number} b
-     * @returns {WasmProbabilityMeasure}
+     * Check if this partition contains another (for skew shapes)
+     * @param {WasmPartition} other
+     * @returns {boolean}
      */
-    static uniform(a, b) {
-        const ret = wasm.wasmprobabilitymeasure_uniform(a, b);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmProbabilityMeasure.__wrap(ret[0]);
+    contains(other) {
+        _assertClass(other, WasmPartition);
+        const ret = wasm.wasmpartition_contains(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the size (sum of parts) of this partition
+     * @returns {number}
+     */
+    getSize() {
+        const ret = wasm.wasmpartition_getSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Check if this partition is valid (weakly decreasing, positive parts)
+     * @returns {boolean}
+     */
+    isValid() {
+        const ret = wasm.wasmpartition_isValid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the parts of this partition
+     * @returns {Uint32Array}
+     */
+    getParts() {
+        const ret = wasm.wasmpartition_getParts(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
 }
 
-const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmPersistentHomologyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpersistenthomology_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for projective spaces
+ * Result of persistent homology computation.
  */
-export class WasmProjectiveSpace {
+export class WasmPersistentHomology {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPersistentHomology.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPersistentHomologyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmProjectiveSpaceFinalization.unregister(this);
+        WasmPersistentHomologyFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmprojectivespace_free(ptr, 0);
+        wasm.__wbg_wasmpersistenthomology_free(ptr, 0);
     }
     /**
-     * Get the dimension of this projective space
-     * @returns {number}
+     * Get the persistence diagram as an array of [dimension, birth, death] triples.
+     * @returns {Float64Array}
+     */
+    getDiagram() {
+        const ret = wasm.wasmpersistenthomology_getDiagram(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the number of intervals in dimension k.
+     * @param {number} dim
+     * @returns {number}
+     */
+    intervalCount(dim) {
+        const ret = wasm.wasmpersistenthomology_intervalCount(this.__wbg_ptr, dim);
+        return ret >>> 0;
+    }
+    /**
+     * Compute persistent homology from a filtration.
+     * @param {WasmFiltration} filtration
+     * @returns {WasmPersistentHomology}
+     */
+    static compute(filtration) {
+        _assertClass(filtration, WasmFiltration);
+        const ret = wasm.wasmpersistenthomology_compute(filtration.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPersistentHomology.__wrap(ret[0]);
+    }
+    /**
+     * Get the Betti numbers at a specific filtration time.
+     * @param {number} time
+     * @returns {Uint32Array}
+     */
+    bettiAt(time) {
+        const ret = wasm.wasmpersistenthomology_bettiAt(this.__wbg_ptr, time);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+
+const WasmProbFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprob_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for probabilistic values
+ *
+ * Wraps an f64 value with associated probability metadata.
+ * Supports mapping, composition, and probability tracking.
+ */
+export class WasmProb {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmProb.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmProbFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmProbFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmprob_free(ptr, 0);
+    }
+    /**
+     * Get the probability associated with this value
+     * @returns {number}
+     */
+    probability() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a value with specified probability
+     *
+     * Probability must be in [0, 1].
+     * @param {number} probability
+     * @param {number} value
+     * @returns {WasmProb}
+     */
+    static withProbability(probability, value) {
+        const ret = wasm.wasmprob_withProbability(probability, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProb.__wrap(ret[0]);
+    }
+    /**
+     * Map the value by multiplying with a factor, preserving probability
+     * @param {number} factor
+     * @returns {WasmProb}
+     */
+    map(factor) {
+        const ret = wasm.wasmprob_map(this.__wbg_ptr, factor);
+        return WasmProb.__wrap(ret);
+    }
+    /**
+     * Create a certain value (probability = 1.0)
+     * @param {number} value
+     */
+    constructor(value) {
+        const ret = wasm.wasmdualnumber_variable(value);
+        this.__wbg_ptr = ret >>> 0;
+        WasmProbFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the wrapped value
+     * @returns {number}
+     */
+    value() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sample this probabilistic value
+     *
+     * Returns the value with probability p, or NaN otherwise.
+     * @returns {number}
+     */
+    sample() {
+        const ret = wasm.wasmprob_sample(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Combine with another probabilistic value (independent)
+     *
+     * Multiplies probabilities and values together.
+     * @param {number} other_probability
+     * @param {number} other_value
+     * @returns {WasmProb}
+     */
+    andThen(other_probability, other_value) {
+        const ret = wasm.wasmprob_andThen(this.__wbg_ptr, other_probability, other_value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProb.__wrap(ret[0]);
+    }
+}
+
+const WasmProbabilityMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprobabilitymeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for probability measures
+ *
+ * A probability measure assigns total measure 1 to the entire space.
+ */
+export class WasmProbabilityMeasure {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmProbabilityMeasure.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmProbabilityMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmProbabilityMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmprobabilitymeasure_free(ptr, 0);
+    }
+    /**
+     * Get a description of this probability measure
+     * @returns {string}
+     */
+    getDescription() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmprobabilitymeasure_getDescription(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Compute P(X ∈ [a, b]) for uniform distribution
+     * @param {number} a
+     * @param {number} b
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {number}
+     */
+    probabilityInterval(a, b, lower, upper) {
+        const ret = wasm.wasmprobabilitymeasure_probabilityInterval(this.__wbg_ptr, a, b, lower, upper);
+        return ret;
+    }
+    /**
+     * Create a new uniform probability measure on [0, 1]
+     */
+    constructor() {
+        const ret = wasm.wasmprobabilitymeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmProbabilityMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a uniform probability measure on [a, b]
+     * @param {number} a
+     * @param {number} b
+     * @returns {WasmProbabilityMeasure}
+     */
+    static uniform(a, b) {
+        const ret = wasm.wasmprobabilitymeasure_uniform(a, b);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProbabilityMeasure.__wrap(ret[0]);
+    }
+}
+
+const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for projective spaces
+ */
+export class WasmProjectiveSpace {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmProjectiveSpaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmprojectivespace_free(ptr, 0);
+    }
+    /**
+     * Get the dimension of this projective space
+     * @returns {number}
      */
     getDimension() {
         const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
@@ -11405,13 +12740,273 @@ export class WasmSensitivityMap {
     }
 }
 
-const WasmSimpleOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmShortSurrealFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsimpleoptimizer_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmshortsurreal_free(ptr >>> 0, 1));
 /**
- * Simple quadratic optimization problem for WASM demonstration
+ * Exact short surreal value backed by a dyadic rational.
  */
-export class WasmSimpleOptimizer {
+export class WasmShortSurreal {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmShortSurreal.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmShortSurrealFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmShortSurrealFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmshortsurreal_free(ptr, 0);
+    }
+    /**
+     * Reconstruct this short surreal as a numeric CGT game in the provided arena.
+     * @param {WasmCgtArena} arena
+     * @returns {WasmGameId}
+     */
+    toGameIn(arena) {
+        _assertClass(arena, WasmCgtArena);
+        const ret = wasm.wasmshortsurreal_toGameIn(this.__wbg_ptr, arena.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGameId.__wrap(ret[0]);
+    }
+    /**
+     * Checked division; fails if the quotient leaves the dyadic layer.
+     * @param {WasmShortSurreal} rhs
+     * @returns {WasmShortSurreal}
+     */
+    checkedDiv(rhs) {
+        _assertClass(rhs, WasmShortSurreal);
+        const ret = wasm.wasmshortsurreal_checkedDiv(this.__wbg_ptr, rhs.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmShortSurreal.__wrap(ret[0]);
+    }
+    /**
+     * Create a short surreal from an exact dyadic value.
+     * @param {WasmDyadic} value
+     * @returns {WasmShortSurreal}
+     */
+    static fromDyadic(value) {
+        _assertClass(value, WasmDyadic);
+        const ret = wasm.wasmshortsurreal_fromDyadic(value.__wbg_ptr);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Return whether the value is negative.
+     * @returns {boolean}
+     */
+    isNegative() {
+        const ret = wasm.wasmshortsurreal_isNegative(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Return whether the value is positive.
+     * @returns {boolean}
+     */
+    isPositive() {
+        const ret = wasm.wasmshortsurreal_isPositive(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Create a short surreal from an integer.
+     * @param {number} value
+     * @returns {WasmShortSurreal}
+     */
+    static fromInteger(value) {
+        const ret = wasm.wasmshortsurreal_fromInteger(value);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Whether the value was converted from a CGT game handle.
+     * @returns {boolean}
+     */
+    hasProvenance() {
+        const ret = wasm.wasmshortsurreal_hasProvenance(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Checked reciprocal within the dyadic short-surreal layer.
+     * @returns {WasmShortSurreal}
+     */
+    checkedReciprocal() {
+        const ret = wasm.wasmshortsurreal_checkedReciprocal(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmShortSurreal.__wrap(ret[0]);
+    }
+    /**
+     * Absolute value.
+     * @returns {WasmShortSurreal}
+     */
+    abs() {
+        const ret = wasm.wasmshortsurreal_abs(this.__wbg_ptr);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Add two short surreals exactly.
+     * @param {WasmShortSurreal} rhs
+     * @returns {WasmShortSurreal}
+     */
+    add(rhs) {
+        _assertClass(rhs, WasmShortSurreal);
+        const ret = wasm.wasmshortsurreal_add(this.__wbg_ptr, rhs.__wbg_ptr);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Multiply two short surreals exactly.
+     * @param {WasmShortSurreal} rhs
+     * @returns {WasmShortSurreal}
+     */
+    mul(rhs) {
+        _assertClass(rhs, WasmShortSurreal);
+        const ret = wasm.wasmshortsurreal_mul(this.__wbg_ptr, rhs.__wbg_ptr);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Negate the value.
+     * @returns {WasmShortSurreal}
+     */
+    neg() {
+        const ret = wasm.wasmshortsurreal_neg(this.__wbg_ptr);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Return one.
+     * @returns {WasmShortSurreal}
+     */
+    static one() {
+        const ret = wasm.wasmshortsurreal_one();
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Subtract two short surreals exactly.
+     * @param {WasmShortSurreal} rhs
+     * @returns {WasmShortSurreal}
+     */
+    sub(rhs) {
+        _assertClass(rhs, WasmShortSurreal);
+        const ret = wasm.wasmshortsurreal_sub(this.__wbg_ptr, rhs.__wbg_ptr);
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Return the sign as `negative`, `zero`, or `positive`.
+     * @returns {string}
+     */
+    sign() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmshortsurreal_sign(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Return zero.
+     * @returns {WasmShortSurreal}
+     */
+    static zero() {
+        const ret = wasm.wasmshortsurreal_zero();
+        return WasmShortSurreal.__wrap(ret);
+    }
+    /**
+     * Format as an integer or dyadic rational string.
+     * @returns {string}
+     */
+    format() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmshortsurreal_format(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Compare two short surreal values.
+     * @param {WasmShortSurreal} rhs
+     * @returns {string}
+     */
+    compare(rhs) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            _assertClass(rhs, WasmShortSurreal);
+            const ret = wasm.wasmshortsurreal_compare(this.__wbg_ptr, rhs.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Return whether the value is zero.
+     * @returns {boolean}
+     */
+    isZero() {
+        const ret = wasm.wasmshortsurreal_isZero(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Birthday of the short surreal value.
+     * @returns {number}
+     */
+    birthday() {
+        const ret = wasm.wasmgameinspection_birthday(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Convert a numeric CGT game to a short surreal.
+     * @param {WasmCgtArena} arena
+     * @param {WasmGameId} game
+     * @returns {WasmShortSurreal}
+     */
+    static fromGame(arena, game) {
+        _assertClass(arena, WasmCgtArena);
+        _assertClass(game, WasmGameId);
+        const ret = wasm.wasmshortsurreal_fromGame(arena.__wbg_ptr, game.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmShortSurreal.__wrap(ret[0]);
+    }
+    /**
+     * Return the exact dyadic value.
+     * @returns {WasmDyadic}
+     */
+    toDyadic() {
+        const ret = wasm.wasmshortsurreal_toDyadic(this.__wbg_ptr);
+        return WasmDyadic.__wrap(ret);
+    }
+}
+
+const WasmSimpleOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsimpleoptimizer_free(ptr >>> 0, 1));
+/**
+ * Simple quadratic optimization problem for WASM demonstration
+ */
+export class WasmSimpleOptimizer {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -11831,563 +13426,1121 @@ export class WasmSmtProofObligation {
         }
     }
     /**
-     * Create a new proof obligation
-     *
-     * # Arguments
-     * * `name` - Obligation name (used in SMT-LIB2 comments)
-     * * `description` - Human-readable description
-     * * `kind` - One of: "precondition", "postcondition", "expected_value", "concentration"
-     * * `param1` - First parameter (probability for pre/post, expected value for EV, samples for concentration)
-     * * `param2` - Second parameter (unused for pre/post, epsilon for EV and concentration)
-     * @param {string} name
-     * @param {string} description
-     * @param {string} kind
-     * @param {number} param1
-     * @param {number} param2
+     * Create a new proof obligation
+     *
+     * # Arguments
+     * * `name` - Obligation name (used in SMT-LIB2 comments)
+     * * `description` - Human-readable description
+     * * `kind` - One of: "precondition", "postcondition", "expected_value", "concentration"
+     * * `param1` - First parameter (probability for pre/post, expected value for EV, samples for concentration)
+     * * `param2` - Second parameter (unused for pre/post, epsilon for EV and concentration)
+     * @param {string} name
+     * @param {string} description
+     * @param {string} kind
+     * @param {number} param1
+     * @param {number} param2
+     */
+    constructor(name, description, kind, param1, param2) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsmtproofobligation_new(ptr0, len0, ptr1, len1, ptr2, len2, param1, param2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmSmtProofObligationFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmSobolevSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsobolevspace_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Sobolev spaces H^k
+ *
+ * Provides function spaces with weak derivatives.
+ */
+export class WasmSobolevSpace {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSobolevSpace.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSobolevSpaceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSobolevSpaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsobolevspace_free(ptr, 0);
+    }
+    /**
+     * Compute the H^1 seminorm |f|_{H^1} = ||f'||_{L^2}
+     * @param {Function} df
+     * @returns {number}
+     */
+    h1Seminorm(df) {
+        const ret = wasm.wasmsobolevspace_h1Seminorm(this.__wbg_ptr, df);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create H^1 over the unit interval [0, 1]
+     * @returns {WasmSobolevSpace}
+     */
+    static h1UnitInterval() {
+        const ret = wasm.wasmsobolevspace_h1UnitInterval();
+        return WasmSobolevSpace.__wrap(ret);
+    }
+    /**
+     * Create H^2 over the unit interval [0, 1]
+     * @returns {WasmSobolevSpace}
+     */
+    static h2UnitInterval() {
+        const ret = wasm.wasmsobolevspace_h2UnitInterval();
+        return WasmSobolevSpace.__wrap(ret);
+    }
+    /**
+     * Compute L^2 inner product <f, g>
+     * @param {Function} f
+     * @param {Function} g
+     * @returns {number}
+     */
+    l2InnerProduct(f, g) {
+        const ret = wasm.wasmsobolevspace_l2InnerProduct(this.__wbg_ptr, f, g);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute the Poincare constant estimate for the domain
+     *
+     * For [a,b], this is (b-a)/π
+     * @returns {number}
+     */
+    poincareConstant() {
+        const ret = wasm.wasmsobolevspace_poincareConstant(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Set the number of quadrature points
+     * @param {number} n
+     */
+    setQuadraturePoints(n) {
+        wasm.wasmsobolevspace_setQuadraturePoints(this.__wbg_ptr, n);
+    }
+    /**
+     * Create a Sobolev space H^k over an interval [a, b]
+     *
+     * # Arguments
+     * * `order` - The Sobolev regularity (1 for H^1, 2 for H^2)
+     * * `lower` - Lower bound of the interval
+     * * `upper` - Upper bound of the interval
+     * @param {number} order
+     * @param {number} lower
+     * @param {number} upper
+     */
+    constructor(order, lower, upper) {
+        const ret = wasm.wasmsobolevspace_new(order, lower, upper);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmSobolevSpaceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the domain bounds [lower, upper]
+     * @returns {Float64Array}
+     */
+    bounds() {
+        const ret = wasm.wasmsobolevspace_bounds(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Compute the H^k norm of a function using numerical integration
+     *
+     * # Arguments
+     * * `f` - JavaScript function f(x) to evaluate
+     * * `df` - JavaScript function f'(x) (first derivative)
+     * @param {Function} f
+     * @param {Function} df
+     * @returns {number}
+     */
+    h1Norm(f, df) {
+        const ret = wasm.wasmsobolevspace_h1Norm(this.__wbg_ptr, f, df);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute L^2 norm of a function
+     * @param {Function} f
+     * @returns {number}
+     */
+    l2Norm(f) {
+        const ret = wasm.wasmsobolevspace_l2Norm(this.__wbg_ptr, f);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the Sobolev order k
+     * @returns {number}
+     */
+    order() {
+        const ret = wasm.wasmsobolevspace_order(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
+const WasmSpacetimeVectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspacetimevector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for spacetime vectors
+ */
+export class WasmSpacetimeVector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSpacetimeVector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSpacetimeVectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSpacetimeVectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmspacetimevector_free(ptr, 0);
+    }
+    /**
+     * Check if vector is timelike (massive particle)
+     * @returns {boolean}
+     */
+    is_timelike() {
+        const ret = wasm.wasmspacetimevector_is_timelike(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if vector is spacelike
+     * @returns {boolean}
+     */
+    is_spacelike() {
+        const ret = wasm.wasmspacetimevector_is_spacelike(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Compute Minkowski norm squared
+     * @returns {number}
+     */
+    norm_squared() {
+        const ret = wasm.wasmspacetimevector_norm_squared(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute Minkowski inner product with another spacetime vector
+     * @param {WasmSpacetimeVector} other
+     * @returns {number}
+     */
+    minkowski_dot(other) {
+        _assertClass(other, WasmSpacetimeVector);
+        const ret = wasm.wasmspacetimevector_minkowski_dot(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get temporal component
+     * @returns {number}
+     */
+    get t() {
+        const ret = wasm.wasmfourvelocity_gamma(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get x component
+     * @returns {number}
+     */
+    get x() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get y component
+     * @returns {number}
+     */
+    get y() {
+        const ret = wasm.wasmevaluationresult_getGeometricDistance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get z component
+     * @returns {number}
+     */
+    get z() {
+        const ret = wasm.wasmevaluationresult_getCombinedScore(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new spacetime vector with components (ct, x, y, z)
+     * @param {number} t
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    constructor(t, x, y, z) {
+        const ret = wasm.wasmspacetimevector_new(t, x, y, z);
+        this.__wbg_ptr = ret >>> 0;
+        WasmSpacetimeVectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Check if vector is null (lightlike)
+     * @returns {boolean}
+     */
+    is_null() {
+        const ret = wasm.wasmspacetimevector_is_null(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Create a timelike vector
+     * @param {number} t
+     * @returns {WasmSpacetimeVector}
+     */
+    static timelike(t) {
+        const ret = wasm.wasmspacetimevector_timelike(t);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
+    /**
+     * Create a spacelike vector
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {WasmSpacetimeVector}
+     */
+    static spacelike(x, y, z) {
+        const ret = wasm.wasmspacetimevector_spacelike(x, y, z);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
+    /**
+     * Get string representation
+     * @returns {string}
+     */
+    to_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmspacetimevector_to_string(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const WasmSpectralDecompositionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspectraldecomposition_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for spectral decomposition
+ *
+ * Provides eigenvalue decomposition for symmetric matrices.
+ */
+export class WasmSpectralDecomposition {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSpectralDecomposition.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSpectralDecompositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSpectralDecompositionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmspectraldecomposition_free(ptr, 0);
+    }
+    /**
+     * Get the eigenvalues
+     * @returns {Float64Array}
+     */
+    eigenvalues() {
+        const ret = wasm.wasmspectraldecomposition_eigenvalues(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Check if the decomposition is complete
+     * @returns {boolean}
+     */
+    isComplete() {
+        const ret = wasm.wasmspectraldecomposition_isComplete(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the eigenvectors as a flattened array
+     *
+     * Returns 4 eigenvectors of 4 components each (16 total)
+     * @returns {Float64Array}
+     */
+    eigenvectors() {
+        const ret = wasm.wasmspectraldecomposition_eigenvectors(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Apply f(T) = Σᵢ f(λᵢ) Pᵢ to a vector using functional calculus
+     *
+     * # Arguments
+     * * `f` - JavaScript function to apply to eigenvalues
+     * * `x` - Input vector
+     * @param {Function} f
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    applyFunction(f, x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmspectraldecomposition_applyFunction(this.__wbg_ptr, f, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Get the spectral radius (largest |eigenvalue|)
+     * @returns {number}
+     */
+    spectralRadius() {
+        const ret = wasm.wasmspectraldecomposition_spectralRadius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the condition number
+     * @returns {number | undefined}
+     */
+    conditionNumber() {
+        const ret = wasm.wasmspectraldecomposition_conditionNumber(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Check if the operator is positive definite
+     * @returns {boolean}
+     */
+    isPositiveDefinite() {
+        const ret = wasm.wasmspectraldecomposition_isPositiveDefinite(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the operator is positive semi-definite
+     * @returns {boolean}
+     */
+    isPositiveSemidefinite() {
+        const ret = wasm.wasmspectraldecomposition_isPositiveSemidefinite(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Apply the reconstructed operator T = Σᵢ λᵢ Pᵢ to a vector
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    apply(x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmspectraldecomposition_apply(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute spectral decomposition of a symmetric matrix
+     *
+     * # Arguments
+     * * `matrix` - The symmetric matrix operator to decompose
+     * * `max_iterations` - Maximum iterations for eigenvalue computation
+     * * `tolerance` - Convergence tolerance
+     * @param {WasmMatrixOperator} matrix
+     * @param {number} max_iterations
+     * @param {number} tolerance
+     * @returns {WasmSpectralDecomposition}
+     */
+    static compute(matrix, max_iterations, tolerance) {
+        _assertClass(matrix, WasmMatrixOperator);
+        const ret = wasm.wasmspectraldecomposition_compute(matrix.__wbg_ptr, max_iterations, tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmSpectralDecomposition.__wrap(ret[0]);
+    }
+}
+
+const WasmStabilityConditionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstabilitycondition_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Bridgeland-style stability conditions
+ */
+export class WasmStabilityCondition {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmStabilityConditionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmstabilitycondition_free(ptr, 0);
+    }
+    /**
+     * Count stable capabilities in a namespace
+     * @param {WasmNamespace} namespace
+     * @returns {number}
+     */
+    stableCount(namespace) {
+        _assertClass(namespace, WasmNamespace);
+        const ret = wasm.wasmstabilitycondition_stableCount(this.__wbg_ptr, namespace.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the trust level
+     * @returns {number}
+     */
+    getTrustLevel() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a stability condition on Gr(k, n) at a given trust level
+     * @param {number} k
+     * @param {number} n
+     * @param {number} trust_level
+     */
+    constructor(k, n, trust_level) {
+        const ret = wasm.wasmstabilitycondition_new(k, n, trust_level);
+        this.__wbg_ptr = ret >>> 0;
+        WasmStabilityConditionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute the phase of a Schubert class under this stability condition
+     * @param {WasmSchubertClass} _class
+     * @returns {number}
      */
-    constructor(name, description, kind, param1, param2) {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsmtproofobligation_new(ptr0, len0, ptr1, len1, ptr2, len2, param1, param2);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        WasmSmtProofObligationFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    phase(_class) {
+        _assertClass(_class, WasmSchubertClass);
+        const ret = wasm.wasmstabilitycondition_phase(this.__wbg_ptr, _class.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Check if a capability is stable under this condition
+     * @param {WasmCapability} capability
+     * @returns {boolean}
+     */
+    isStable(capability) {
+        _assertClass(capability, WasmCapability);
+        const ret = wasm.wasmstabilitycondition_isStable(this.__wbg_ptr, capability.__wbg_ptr);
+        return ret !== 0;
     }
 }
 
-const WasmSobolevSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmStaticMultiDual2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsobolevspace_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for Sobolev spaces H^k
- *
- * Provides function spaces with weak derivatives.
- */
-export class WasmSobolevSpace {
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstaticmultidual2_free(ptr >>> 0, 1));
+
+export class WasmStaticMultiDual2 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmSobolevSpace.prototype);
+        const obj = Object.create(WasmStaticMultiDual2.prototype);
         obj.__wbg_ptr = ptr;
-        WasmSobolevSpaceFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStaticMultiDual2Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmSobolevSpaceFinalization.unregister(this);
+        WasmStaticMultiDual2Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmsobolevspace_free(ptr, 0);
+        wasm.__wbg_wasmstaticmultidual2_free(ptr, 0);
     }
     /**
-     * Compute the H^1 seminorm |f|_{H^1} = ||f'||_{L^2}
-     * @param {Function} df
-     * @returns {number}
+     * Get the fixed-size gradient as a JavaScript array-compatible vector.
+     * @returns {Float64Array}
      */
-    h1Seminorm(df) {
-        const ret = wasm.wasmsobolevspace_h1Seminorm(this.__wbg_ptr, df);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
+    getGradient() {
+        const ret = wasm.wasmstaticmultidual2_getGradient(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Create H^1 over the unit interval [0, 1]
-     * @returns {WasmSobolevSpace}
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual2} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual2}
      */
-    static h1UnitInterval() {
-        const ret = wasm.wasmsobolevspace_h1UnitInterval();
-        return WasmSobolevSpace.__wrap(ret);
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Create H^2 over the unit interval [0, 1]
-     * @returns {WasmSobolevSpace}
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual2} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual2}
      */
-    static h2UnitInterval() {
-        const ret = wasm.wasmsobolevspace_h2UnitInterval();
-        return WasmSobolevSpace.__wrap(ret);
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Compute L^2 inner product <f, g>
-     * @param {Function} f
-     * @param {Function} g
-     * @returns {number}
+     * Convert to the heap-backed multi-dual wrapper.
+     * @returns {WasmMultiDualNumber}
      */
-    l2InnerProduct(f, g) {
-        const ret = wasm.wasmsobolevspace_l2InnerProduct(this.__wbg_ptr, f, g);
+    toMultiDual() {
+        const ret = wasm.wasmstaticmultidual2_toMultiDual(this.__wbg_ptr);
+        return WasmMultiDualNumber.__wrap(ret);
+    }
+    /**
+     * Addition.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
+     */
+    add(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
+    }
+    /**
+     * Division.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
+     */
+    div(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_div(this.__wbg_ptr, other.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return WasmStaticMultiDual2.__wrap(ret[0]);
     }
     /**
-     * Compute the Poincare constant estimate for the domain
-     *
-     * For [a,b], this is (b-a)/π
-     * @returns {number}
+     * Multiplication.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
      */
-    poincareConstant() {
-        const ret = wasm.wasmsobolevspace_poincareConstant(this.__wbg_ptr);
-        return ret;
+    mul(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_mul(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Set the number of quadrature points
-     * @param {number} n
+     * Negation.
+     * @returns {WasmStaticMultiDual2}
      */
-    setQuadraturePoints(n) {
-        wasm.wasmsobolevspace_setQuadraturePoints(this.__wbg_ptr, n);
+    neg() {
+        const ret = wasm.wasmstaticmultidual2_neg(this.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Create a Sobolev space H^k over an interval [a, b]
-     *
-     * # Arguments
-     * * `order` - The Sobolev regularity (1 for H^1, 2 for H^2)
-     * * `lower` - Lower bound of the interval
-     * * `upper` - Upper bound of the interval
-     * @param {number} order
-     * @param {number} lower
-     * @param {number} upper
+     * Create a fixed-size multi-dual number from a value and gradient.
+     * @param {number} value
+     * @param {Float64Array} gradient
      */
-    constructor(order, lower, upper) {
-        const ret = wasm.wasmsobolevspace_new(order, lower, upper);
+    constructor(value, gradient) {
+        const ptr0 = passArrayF64ToWasm0(gradient, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual2_new(value, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        WasmSobolevSpaceFinalization.register(this, this.__wbg_ptr, this);
+        WasmStaticMultiDual2Finalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Get the domain bounds [lower, upper]
-     * @returns {Float64Array}
+     * Subtraction.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
      */
-    bounds() {
-        const ret = wasm.wasmsobolevspace_bounds(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    sub(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Compute the H^k norm of a function using numerical integration
-     *
-     * # Arguments
-     * * `f` - JavaScript function f(x) to evaluate
-     * * `df` - JavaScript function f'(x) (first derivative)
-     * @param {Function} f
-     * @param {Function} df
+     * Number of derivative variables.
      * @returns {number}
      */
-    h1Norm(f, df) {
-        const ret = wasm.wasmsobolevspace_h1Norm(this.__wbg_ptr, f, df);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
+    nVars() {
+        const ret = wasm.wasmstaticmultidual2_nVars(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Compute L^2 norm of a function
-     * @param {Function} f
-     * @returns {number}
+     * Create a constant with zero gradient.
+     * @param {number} value
+     * @returns {WasmStaticMultiDual2}
      */
-    l2Norm(f) {
-        const ret = wasm.wasmsobolevspace_l2Norm(this.__wbg_ptr, f);
+    static constant(value) {
+        const ret = wasm.wasmstaticmultidual2_constant(value);
+        return WasmStaticMultiDual2.__wrap(ret);
+    }
+    /**
+     * Create a basis-seeded variable.
+     * @param {number} value
+     * @param {number} var_index
+     * @returns {WasmStaticMultiDual2}
+     */
+    static variable(value, var_index) {
+        const ret = wasm.wasmstaticmultidual2_variable(value, var_index);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return WasmStaticMultiDual2.__wrap(ret[0]);
     }
     /**
-     * Get the Sobolev order k
+     * Get the function value.
      * @returns {number}
      */
-    order() {
-        const ret = wasm.wasmsobolevspace_order(this.__wbg_ptr);
-        return ret >>> 0;
+    getValue() {
+        const ret = wasm.wasmevaluationresult_getGeometricDistance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create one fixed-size variable per coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
+     */
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual2_variables(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 
-const WasmSpacetimeVectorFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmStaticMultiDual3Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspacetimevector_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for spacetime vectors
- */
-export class WasmSpacetimeVector {
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstaticmultidual3_free(ptr >>> 0, 1));
+
+export class WasmStaticMultiDual3 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmSpacetimeVector.prototype);
+        const obj = Object.create(WasmStaticMultiDual3.prototype);
         obj.__wbg_ptr = ptr;
-        WasmSpacetimeVectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStaticMultiDual3Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmSpacetimeVectorFinalization.unregister(this);
+        WasmStaticMultiDual3Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmspacetimevector_free(ptr, 0);
+        wasm.__wbg_wasmstaticmultidual3_free(ptr, 0);
     }
     /**
-     * Check if vector is timelike (massive particle)
-     * @returns {boolean}
+     * Get the fixed-size gradient as a JavaScript array-compatible vector.
+     * @returns {Float64Array}
      */
-    is_timelike() {
-        const ret = wasm.wasmspacetimevector_is_timelike(this.__wbg_ptr);
-        return ret !== 0;
+    getGradient() {
+        const ret = wasm.wasmstaticmultidual3_getGradient(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Check if vector is spacelike
-     * @returns {boolean}
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual3} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual3}
      */
-    is_spacelike() {
-        const ret = wasm.wasmspacetimevector_is_spacelike(this.__wbg_ptr);
-        return ret !== 0;
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Compute Minkowski norm squared
-     * @returns {number}
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual3} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual3}
      */
-    norm_squared() {
-        const ret = wasm.wasmspacetimevector_norm_squared(this.__wbg_ptr);
-        return ret;
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Compute Minkowski inner product with another spacetime vector
-     * @param {WasmSpacetimeVector} other
-     * @returns {number}
+     * Convert to the heap-backed multi-dual wrapper.
+     * @returns {WasmMultiDualNumber}
      */
-    minkowski_dot(other) {
-        _assertClass(other, WasmSpacetimeVector);
-        const ret = wasm.wasmspacetimevector_minkowski_dot(this.__wbg_ptr, other.__wbg_ptr);
-        return ret;
+    toMultiDual() {
+        const ret = wasm.wasmstaticmultidual3_toMultiDual(this.__wbg_ptr);
+        return WasmMultiDualNumber.__wrap(ret);
     }
     /**
-     * Get temporal component
-     * @returns {number}
+     * Addition.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get t() {
-        const ret = wasm.wasmfourvelocity_gamma(this.__wbg_ptr);
-        return ret;
+    add(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Get x component
-     * @returns {number}
+     * Division.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get x() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
+    div(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_div(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual3.__wrap(ret[0]);
     }
     /**
-     * Get y component
-     * @returns {number}
+     * Multiplication.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get y() {
-        const ret = wasm.wasmevaluationresult_getGeometricDistance(this.__wbg_ptr);
-        return ret;
+    mul(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_mul(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Get z component
-     * @returns {number}
+     * Negation.
+     * @returns {WasmStaticMultiDual3}
+     */
+    neg() {
+        const ret = wasm.wasmstaticmultidual3_neg(this.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
+    }
+    /**
+     * Create a fixed-size multi-dual number from a value and gradient.
+     * @param {number} value
+     * @param {Float64Array} gradient
+     */
+    constructor(value, gradient) {
+        const ptr0 = passArrayF64ToWasm0(gradient, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual3_new(value, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmStaticMultiDual3Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Subtraction.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get z() {
-        const ret = wasm.wasmevaluationresult_getCombinedScore(this.__wbg_ptr);
-        return ret;
+    sub(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Create a new spacetime vector with components (ct, x, y, z)
-     * @param {number} t
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
+     * Number of derivative variables.
+     * @returns {number}
      */
-    constructor(t, x, y, z) {
-        const ret = wasm.wasmspacetimevector_new(t, x, y, z);
-        this.__wbg_ptr = ret >>> 0;
-        WasmSpacetimeVectorFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    nVars() {
+        const ret = wasm.wasmstaticmultidual3_nVars(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Check if vector is null (lightlike)
-     * @returns {boolean}
+     * Create a constant with zero gradient.
+     * @param {number} value
+     * @returns {WasmStaticMultiDual3}
      */
-    is_null() {
-        const ret = wasm.wasmspacetimevector_is_null(this.__wbg_ptr);
-        return ret !== 0;
+    static constant(value) {
+        const ret = wasm.wasmstaticmultidual3_constant(value);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Create a timelike vector
-     * @param {number} t
-     * @returns {WasmSpacetimeVector}
+     * Create a basis-seeded variable.
+     * @param {number} value
+     * @param {number} var_index
+     * @returns {WasmStaticMultiDual3}
      */
-    static timelike(t) {
-        const ret = wasm.wasmspacetimevector_timelike(t);
-        return WasmSpacetimeVector.__wrap(ret);
+    static variable(value, var_index) {
+        const ret = wasm.wasmstaticmultidual3_variable(value, var_index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual3.__wrap(ret[0]);
     }
     /**
-     * Create a spacelike vector
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @returns {WasmSpacetimeVector}
+     * Get the function value.
+     * @returns {number}
      */
-    static spacelike(x, y, z) {
-        const ret = wasm.wasmspacetimevector_spacelike(x, y, z);
-        return WasmSpacetimeVector.__wrap(ret);
+    getValue() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Get string representation
-     * @returns {string}
+     * Create one fixed-size variable per coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
      */
-    to_string() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmspacetimevector_to_string(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual3_variables(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 
-const WasmSpectralDecompositionFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmStaticMultiDual4Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspectraldecomposition_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for spectral decomposition
- *
- * Provides eigenvalue decomposition for symmetric matrices.
- */
-export class WasmSpectralDecomposition {
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstaticmultidual4_free(ptr >>> 0, 1));
+
+export class WasmStaticMultiDual4 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmSpectralDecomposition.prototype);
+        const obj = Object.create(WasmStaticMultiDual4.prototype);
         obj.__wbg_ptr = ptr;
-        WasmSpectralDecompositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStaticMultiDual4Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmSpectralDecompositionFinalization.unregister(this);
+        WasmStaticMultiDual4Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmspectraldecomposition_free(ptr, 0);
+        wasm.__wbg_wasmstaticmultidual4_free(ptr, 0);
     }
     /**
-     * Get the eigenvalues
+     * Get the fixed-size gradient as a JavaScript array-compatible vector.
      * @returns {Float64Array}
      */
-    eigenvalues() {
-        const ret = wasm.wasmspectraldecomposition_eigenvalues(this.__wbg_ptr);
+    getGradient() {
+        const ret = wasm.wasmstaticmultidual4_getGradient(this.__wbg_ptr);
         var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
     /**
-     * Check if the decomposition is complete
-     * @returns {boolean}
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual4} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual4}
      */
-    isComplete() {
-        const ret = wasm.wasmspectraldecomposition_isComplete(this.__wbg_ptr);
-        return ret !== 0;
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Get the eigenvectors as a flattened array
-     *
-     * Returns 4 eigenvectors of 4 components each (16 total)
-     * @returns {Float64Array}
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual4} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual4}
      */
-    eigenvectors() {
-        const ret = wasm.wasmspectraldecomposition_eigenvectors(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Apply f(T) = Σᵢ f(λᵢ) Pᵢ to a vector using functional calculus
-     *
-     * # Arguments
-     * * `f` - JavaScript function to apply to eigenvalues
-     * * `x` - Input vector
-     * @param {Function} f
-     * @param {Float64Array} x
-     * @returns {Float64Array}
+     * Convert to the heap-backed multi-dual wrapper.
+     * @returns {WasmMultiDualNumber}
      */
-    applyFunction(f, x) {
-        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmspectraldecomposition_applyFunction(this.__wbg_ptr, f, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
+    toMultiDual() {
+        const ret = wasm.wasmstaticmultidual4_toMultiDual(this.__wbg_ptr);
+        return WasmMultiDualNumber.__wrap(ret);
     }
     /**
-     * Get the spectral radius (largest |eigenvalue|)
-     * @returns {number}
+     * Addition.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
      */
-    spectralRadius() {
-        const ret = wasm.wasmspectraldecomposition_spectralRadius(this.__wbg_ptr);
-        return ret;
+    add(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Get the condition number
-     * @returns {number | undefined}
+     * Division.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
      */
-    conditionNumber() {
-        const ret = wasm.wasmspectraldecomposition_conditionNumber(this.__wbg_ptr);
-        return ret[0] === 0 ? undefined : ret[1];
+    div(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_div(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual4.__wrap(ret[0]);
     }
     /**
-     * Check if the operator is positive definite
-     * @returns {boolean}
+     * Multiplication.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
      */
-    isPositiveDefinite() {
-        const ret = wasm.wasmspectraldecomposition_isPositiveDefinite(this.__wbg_ptr);
-        return ret !== 0;
+    mul(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_mul(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Check if the operator is positive semi-definite
-     * @returns {boolean}
+     * Negation.
+     * @returns {WasmStaticMultiDual4}
      */
-    isPositiveSemidefinite() {
-        const ret = wasm.wasmspectraldecomposition_isPositiveSemidefinite(this.__wbg_ptr);
-        return ret !== 0;
+    neg() {
+        const ret = wasm.wasmstaticmultidual4_neg(this.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Apply the reconstructed operator T = Σᵢ λᵢ Pᵢ to a vector
-     * @param {Float64Array} x
-     * @returns {Float64Array}
+     * Create a fixed-size multi-dual number from a value and gradient.
+     * @param {number} value
+     * @param {Float64Array} gradient
      */
-    apply(x) {
-        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    constructor(value, gradient) {
+        const ptr0 = passArrayF64ToWasm0(gradient, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmspectraldecomposition_apply(this.__wbg_ptr, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
-    }
-    /**
-     * Compute spectral decomposition of a symmetric matrix
-     *
-     * # Arguments
-     * * `matrix` - The symmetric matrix operator to decompose
-     * * `max_iterations` - Maximum iterations for eigenvalue computation
-     * * `tolerance` - Convergence tolerance
-     * @param {WasmMatrixOperator} matrix
-     * @param {number} max_iterations
-     * @param {number} tolerance
-     * @returns {WasmSpectralDecomposition}
-     */
-    static compute(matrix, max_iterations, tolerance) {
-        _assertClass(matrix, WasmMatrixOperator);
-        const ret = wasm.wasmspectraldecomposition_compute(matrix.__wbg_ptr, max_iterations, tolerance);
+        const ret = wasm.wasmstaticmultidual4_new(value, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmSpectralDecomposition.__wrap(ret[0]);
-    }
-}
-
-const WasmStabilityConditionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstabilitycondition_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for Bridgeland-style stability conditions
- */
-export class WasmStabilityCondition {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmStabilityConditionFinalization.unregister(this);
-        return ptr;
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmStaticMultiDual4Finalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmstabilitycondition_free(ptr, 0);
+    /**
+     * Subtraction.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
+     */
+    sub(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Count stable capabilities in a namespace
-     * @param {WasmNamespace} namespace
+     * Number of derivative variables.
      * @returns {number}
      */
-    stableCount(namespace) {
-        _assertClass(namespace, WasmNamespace);
-        const ret = wasm.wasmstabilitycondition_stableCount(this.__wbg_ptr, namespace.__wbg_ptr);
+    nVars() {
+        const ret = wasm.wasmhilbertspace_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Get the trust level
-     * @returns {number}
+     * Create a constant with zero gradient.
+     * @param {number} value
+     * @returns {WasmStaticMultiDual4}
      */
-    getTrustLevel() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
+    static constant(value) {
+        const ret = wasm.wasmstaticmultidual4_constant(value);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Create a stability condition on Gr(k, n) at a given trust level
-     * @param {number} k
-     * @param {number} n
-     * @param {number} trust_level
+     * Create a basis-seeded variable.
+     * @param {number} value
+     * @param {number} var_index
+     * @returns {WasmStaticMultiDual4}
      */
-    constructor(k, n, trust_level) {
-        const ret = wasm.wasmstabilitycondition_new(k, n, trust_level);
-        this.__wbg_ptr = ret >>> 0;
-        WasmStabilityConditionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static variable(value, var_index) {
+        const ret = wasm.wasmstaticmultidual4_variable(value, var_index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual4.__wrap(ret[0]);
     }
     /**
-     * Compute the phase of a Schubert class under this stability condition
-     * @param {WasmSchubertClass} _class
+     * Get the function value.
      * @returns {number}
      */
-    phase(_class) {
-        _assertClass(_class, WasmSchubertClass);
-        const ret = wasm.wasmstabilitycondition_phase(this.__wbg_ptr, _class.__wbg_ptr);
+    getValue() {
+        const ret = wasm.wasmschwarzschildmetric_schwarzschild_radius(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Check if a capability is stable under this condition
-     * @param {WasmCapability} capability
-     * @returns {boolean}
+     * Create one fixed-size variable per coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
      */
-    isStable(capability) {
-        _assertClass(capability, WasmCapability);
-        const ret = wasm.wasmstabilitycondition_isStable(this.__wbg_ptr, capability.__wbg_ptr);
-        return ret !== 0;
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual4_variables(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 
@@ -14175,7 +16328,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_7c839ead6adae856 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_d18f68da6e20cb1e = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -14200,7 +16353,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_965(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_1132(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -14291,6 +16444,10 @@ function __wbg_get_imports() {
         const ret = WasmIntersectionResult.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wasmmultidualnumber_new = function(arg0) {
+        const ret = WasmMultiDualNumber.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_wasmnamespace_unwrap = function(arg0) {
         const ret = WasmNamespace.__unwrap(arg0);
         return ret;
@@ -14319,6 +16476,18 @@ function __wbg_get_imports() {
         const ret = WasmSpacetimeVector.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wasmstaticmultidual2_new = function(arg0) {
+        const ret = WasmStaticMultiDual2.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmstaticmultidual3_new = function(arg0) {
+        const ret = WasmStaticMultiDual3.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmstaticmultidual4_new = function(arg0) {
+        const ret = WasmStaticMultiDual4.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_wasmtropicalnumber_new = function(arg0) {
         const ret = WasmTropicalNumber.__wrap(arg0);
         return ret;
@@ -14336,8 +16505,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper2686 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 70, __wbg_adapter_30);
+    imports.wbg.__wbindgen_closure_wrapper3089 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 76, __wbg_adapter_30);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {