@justinelliottcobb/amari-wasm 0.21.0 → 0.22.0

package/amari_wasm.js

@@ -838,11 +838,11 @@ function getArrayF32FromWasm0(ptr, len) {
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 function __wbg_adapter_30(arg0, arg1, arg2) {
-    wasm.closure72_externref_shim(arg0, arg1, arg2);
+    wasm.closure77_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_1057(arg0, arg1, arg2, arg3) {
-    wasm.closure66_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_1132(arg0, arg1, arg2, arg3) {
+    wasm.closure71_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -4277,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));
@@ -5064,6 +5430,221 @@ export class WasmDuallyFlatManifold {
     }
 }
 
+const WasmDyadicFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmdyadic_free(ptr >>> 0, 1));
+/**
+ * Exact dyadic rational `numerator / 2^exponent` for short surreal values.
+ */
+export class WasmDyadic {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmDyadic.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmDyadicFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmDyadicFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmdyadic_free(ptr, 0);
+    }
+    /**
+     * Checked division; fails if the quotient leaves the dyadic layer.
+     * @param {WasmDyadic} rhs
+     * @returns {WasmDyadic}
+     */
+    checkedDiv(rhs) {
+        _assertClass(rhs, WasmDyadic);
+        const ret = wasm.wasmdyadic_checkedDiv(this.__wbg_ptr, rhs.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDyadic.__wrap(ret[0]);
+    }
+    /**
+     * Return whether the dyadic is negative.
+     * @returns {boolean}
+     */
+    isNegative() {
+        const ret = wasm.wasmdyadic_isNegative(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Return whether the dyadic is positive.
+     * @returns {boolean}
+     */
+    isPositive() {
+        const ret = wasm.wasmdyadic_isPositive(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Create a dyadic integer.
+     * @param {number} value
+     * @returns {WasmDyadic}
+     */
+    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));
@@ -5964,6 +6545,170 @@ export class WasmGF2Vector {
     }
 }
 
+const WasmGameIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgameid_free(ptr >>> 0, 1));
+/**
+ * Opaque handle for a short combinatorial game stored in a `WasmCgtArena`.
+ */
+export class WasmGameId {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGameId.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGameIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGameIdFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgameid_free(ptr, 0);
+    }
+    /**
+     * Returns whether two game handles point at the same arena-local game.
+     * @param {WasmGameId} other
+     * @returns {boolean}
+     */
+    same(other) {
+        _assertClass(other, WasmGameId);
+        const ret = wasm.wasmgameid_same(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+
+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);
+    }
+    /**
+     * Whether the game is numeric.
+     * @returns {boolean}
+     */
+    isNumeric() {
+        const ret = wasm.wasmgameinspection_isNumeric(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether the game is partizan.
+     * @returns {boolean}
+     */
+    isPartizan() {
+        const ret = wasm.wasmgameinspection_isPartizan(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether the game already is its canonical representative.
+     * @returns {boolean}
+     */
+    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));
@@ -9917,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;
     }
     /**
@@ -11995,6 +12740,266 @@ export class WasmSensitivityMap {
     }
 }
 
+const WasmShortSurrealFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmshortsurreal_free(ptr >>> 0, 1));
+/**
+ * Exact short surreal value backed by a dyadic rational.
+ */
+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));
@@ -15323,7 +16328,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_845eb41485557ffc = function(arg0, arg1) {
+    imports.wbg.__wbg_log_d18f68da6e20cb1e = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -15348,7 +16353,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_1057(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_1132(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -15500,8 +16505,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper2835 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 71, __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) {