/* @ts-self-types="./wai_web.d.ts" */

/**
 * A signing actor in the browser. The page supplies 32 random bytes
 * (crypto.getRandomValues); the key never leaves the tab — only
 * signed ops do. An op is the unit of play: what travels between
 * tabs (by any transport — transport is out of the extension's
 * scope) is exactly what a native sink would ingest.
 */
export class Actor {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ActorFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_actor_free(ptr, 0);
    }
    /**
     * @param {Uint8Array} seed
     */
    constructor(seed) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.actor_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            ActorFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Lamport discipline: an actor's counter MUST exceed every
     * lamport it has observed. The page calls this with the lamports
     * of ops it receives.
     * @param {bigint} lamport
     */
    observe_lamport(lamport) {
        wasm.actor_observe_lamport(this.__wbg_ptr, lamport);
    }
    /**
     * @returns {string}
     */
    pubkey_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.actor_pubkey_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Sign a truss IMPULSE op (the SUM-resolved shove) targeting
     * `node_id` (16 bytes) at `effect_tick`. `dx/dy/dz` are authoring
     * floats converted to Q32.32 *here, once* — the canonical artifact
     * is the returned op bytes, so every sink derives identical state
     * from them regardless of who authored or how.
     * @param {bigint} effect_tick
     * @param {Uint8Array} node_id
     * @param {number} dx
     * @param {number} dy
     * @param {number} dz
     * @returns {Uint8Array}
     */
    sign_truss_impulse(effect_tick, node_id, dx, dy, dz) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.actor_sign_truss_impulse(retptr, this.__wbg_ptr, effect_tick, ptr0, len0, dx, dy, dz);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) Actor.prototype[Symbol.dispose] = Actor.prototype.free;

export class AssetProvenance {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AssetProvenanceFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_assetprovenance_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    asset_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_asset_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    capability() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_capability(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The hash this sink actually computed over the carried bytes (shown
     * next to `asset_hash` so a mismatch is visible).
     * @returns {string}
     */
    computed_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_computed_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The carried bytes' content hash equals the receipt's `asset_hash`
     * — the asset is exactly what the receipt vouches for. A 1-bit change
     * to the envelope flips this to false.
     * @returns {boolean}
     */
    content_ok() {
        const ret = wasm.assetprovenance_content_ok(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    media() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_media(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Open an asset envelope + its provenance receipt JSON. Constructing
     * with deliberately-mutated `envelope` bytes is how the page shows
     * tamper-evidence: `content_ok` then returns false.
     * @param {Uint8Array} envelope
     * @param {string} receipt_json
     */
    constructor(envelope, receipt_json) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passStringToWasm0(receipt_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            wasm.assetprovenance_new(retptr, ptr0, len0, ptr1, len1);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            AssetProvenanceFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The carried payload bytes — the codec-specific bytes a native
     * element (`<img>`, `<audio>`) consumes. WAI dispatches; it does not
     * decode.
     * @returns {Uint8Array}
     */
    payload() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_payload(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    receipt_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_receipt_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The receipt's Ed25519 signature + Merkle chain + step linkage verify.
     * @returns {boolean}
     */
    signature_ok() {
        const ret = wasm.assetprovenance_signature_ok(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    signer_id() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.assetprovenance_signer_id(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    step_count() {
        const ret = wasm.assetprovenance_step_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {bigint}
     */
    total_joules_micro() {
        const ret = wasm.assetprovenance_total_joules_micro(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
}
if (Symbol.dispose) AssetProvenance.prototype[Symbol.dispose] = AssetProvenance.prototype.free;

export class AudioSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AudioSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_audiosink_free(ptr, 0);
    }
    /**
     * @returns {bigint}
     */
    duration() {
        const ret = wasm.audiosink_duration(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {string}
     */
    floor_layout() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.audiosink_floor_layout(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Load the corpus `.sources.bin`:
     * `n u32 | n × (hash[32], len u32, i16le[len])`.
     * @param {Uint8Array} bin
     */
    load_sources_bin(bin) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bin, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.audiosink_load_sources_bin(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The exact deterministic mixdown — interleaved i16 PCM for the
     * declared layout. These are the bytes the page plays.
     * @param {string} layout
     * @returns {Int16Array}
     */
    mix(layout) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(layout, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.audiosink_mix(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayI16FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 2, 2);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * BLAKE3 over the canonical PCM — compare to the corpus's expected
     * `mixdown_hash` (in-browser mixdown-equivalence, like the worlds
     * state-hash check).
     * @param {string} layout
     * @returns {string}
     */
    mixdown_hash_hex(layout) {
        let deferred3_0;
        let deferred3_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(layout, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.audiosink_mixdown_hash_hex(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr2 = r0;
            var len2 = r1;
            if (r3) {
                ptr2 = 0; len2 = 0;
                throw takeObject(r2);
            }
            deferred3_0 = ptr2;
            deferred3_1 = len2;
            return getStringFromWasm0(ptr2, len2);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
        }
    }
    /**
     * Open a `WSCN` scene container.
     * @param {Uint8Array} wscn
     */
    constructor(wscn) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(wscn, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.audiosink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            AudioSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    num_objects() {
        const ret = wasm.audiosink_num_objects(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Flat `[x, z]` per object at playback sample `t` — for a top-down
     * radar (y/elevation omitted).
     * @param {bigint} t
     * @returns {Float32Array}
     */
    object_xz(t) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.audiosink_object_xz(retptr, this.__wbg_ptr, t);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    sample_rate() {
        const ret = wasm.audiosink_sample_rate(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {string}
     */
    scene_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.audiosink_scene_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) AudioSink.prototype[Symbol.dispose] = AudioSink.prototype.free;

export class BenchDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BenchDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_benchdemo_free(ptr, 0);
    }
    /**
     * Sweep the physical error rate on the [[72,12]] gross code, decoding each
     * sampled error with plain BP and with Relay-BP over identical samples, and
     * report the logical error rate of each — the demonstration that relay is
     * what makes BP work on a quantum LDPC code.
     * @param {number} trials
     * @param {number} seed
     * @param {number} max_legs
     */
    constructor(trials, seed, max_legs) {
        const ret = wasm.benchdemo_new(trials, seed, max_legs);
        this.__wbg_ptr = ret;
        BenchDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {Float64Array}
     */
    plain_rate() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.benchdemo_plain_rate(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    ps() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.benchdemo_ps(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    relay_rate() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.benchdemo_relay_rate(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    trials() {
        const ret = wasm.benchdemo_trials(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) BenchDemo.prototype[Symbol.dispose] = BenchDemo.prototype.free;

export class BornMachine {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BornMachineFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_bornmachine_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    final_kl() {
        const ret = wasm.bornmachine_final_kl(this.__wbg_ptr);
        return ret;
    }
    /**
     * The KL-loss curve over training.
     * @returns {Float64Array}
     */
    loss_curve() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.bornmachine_loss_curve(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The learned model distribution `P_θ(x)`.
     * @returns {Float64Array}
     */
    model_probs() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.bornmachine_model_probs(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Train a Born machine on `target` (a distribution over `2ⁿ` outcomes).
     * @param {Float64Array} target
     * @param {number} n
     * @param {number} layers
     * @param {number} steps
     * @param {number} lr
     * @param {number} seed
     */
    constructor(target, n, layers, steps, lr, seed) {
        const ptr0 = passArrayF64ToWasm0(target, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.bornmachine_new(ptr0, len0, n, layers, steps, lr, seed);
        this.__wbg_ptr = ret;
        BornMachineFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Run the TRAINED generative model on the qFHRR phasor substrate at `bits`-bit
     * phase resolution — its full distribution, deployed on the phasor fabric.
     * @param {number} bits
     * @returns {Float64Array}
     */
    qfhrr_probs(bits) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.bornmachine_qfhrr_probs(retptr, this.__wbg_ptr, bits);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Total-variation distance of the `bits`-bit qFHRR run from the exact model.
     * @param {number} bits
     * @returns {number}
     */
    qfhrr_tv(bits) {
        const ret = wasm.bornmachine_qfhrr_tv(this.__wbg_ptr, bits);
        return ret;
    }
}
if (Symbol.dispose) BornMachine.prototype[Symbol.dispose] = BornMachine.prototype.free;

export class CampaignDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CampaignDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_campaigndemo_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    campaign_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.campaigndemo_campaign_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * This node's parent is exactly the previous node's receipt (root for i=0).
     * @param {number} i
     * @returns {boolean}
     */
    chains_ok(i) {
        const ret = wasm.campaigndemo_chains_ok(this.__wbg_ptr, i);
        return ret !== 0;
    }
    /**
     * @param {number} i
     * @returns {string}
     */
    kind(i) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.campaigndemo_kind(retptr, this.__wbg_ptr, i);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    n_steps() {
        const ret = wasm.campaigndemo_n_steps(this.__wbg_ptr);
        return ret >>> 0;
    }
    constructor() {
        const ret = wasm.campaigndemo_new();
        this.__wbg_ptr = ret;
        CampaignDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {number} i
     * @returns {string}
     */
    receipt_hash(i) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.campaigndemo_receipt_hash(retptr, this.__wbg_ptr, i);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    verify_chain() {
        const ret = wasm.campaigndemo_verify_chain(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) CampaignDemo.prototype[Symbol.dispose] = CampaignDemo.prototype.free;

export class ChargeTuneDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ChargeTuneDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_chargetunedemo_free(ptr, 0);
    }
    /**
     * @returns {boolean}
     */
    found() {
        const ret = wasm.chargetunedemo_found(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.chargetunedemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    n_grid() {
        const ret = wasm.chargetunedemo_n_grid(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Autonomously tune a double quantum dot (hidden capacitance model) to a
     * target charge configuration `(target_nl, target_nr)` by scanning the
     * charge-stability diagram over `[0, v_max]²`.
     * @param {number} alpha_l
     * @param {number} alpha_r
     * @param {number} beta_lr
     * @param {number} beta_rl
     * @param {number} target_nl
     * @param {number} target_nr
     * @param {number} v_max
     * @param {number} n_grid
     */
    constructor(alpha_l, alpha_r, beta_lr, beta_rl, target_nl, target_nr, v_max, n_grid) {
        const ret = wasm.chargetunedemo_new(alpha_l, alpha_r, beta_lr, beta_rl, target_nl, target_nr, v_max, n_grid);
        this.__wbg_ptr = ret;
        ChargeTuneDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Operating point as a `[0,1]` fraction of the scan window (canvas mapping).
     * @returns {number}
     */
    op_x() {
        const ret = wasm.chargetunedemo_op_x(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    op_y() {
        const ret = wasm.chargetunedemo_op_y(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.chargetunedemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.chargetunedemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Row-major `n_grid × n_grid` total-charge signal `n_L + n_R` (the honeycomb).
     * @returns {Int32Array}
     */
    signal() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.chargetunedemo_signal(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayI32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    target_nl() {
        const ret = wasm.chargetunedemo_target_nl(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    target_nr() {
        const ret = wasm.chargetunedemo_target_nr(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    v_l_op() {
        const ret = wasm.chargetunedemo_v_l_op(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    v_r_op() {
        const ret = wasm.chargetunedemo_v_r_op(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) ChargeTuneDemo.prototype[Symbol.dispose] = ChargeTuneDemo.prototype.free;

export class CompileDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CompileDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_compiledemo_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    coupling_kind() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.compiledemo_coupling_kind(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Coupling edges, flattened `[a0,b0,a1,b1,…]`.
     * @returns {Uint32Array}
     */
    edges() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.compiledemo_edges(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {boolean}
     */
    equivalent() {
        const ret = wasm.compiledemo_equivalent(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Uint32Array}
     */
    final_map() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.compiledemo_final_map(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    n() {
        const ret = wasm.compiledemo_n(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Route a random `depth`-gate Clifford circuit on `n` qubits onto a `line` or
     * `ring` coupling, prove equivalence, and also check that a tampered routing
     * (one gate dropped) is correctly rejected.
     * @param {number} n
     * @param {number} depth
     * @param {number} seed
     * @param {string} kind
     */
    constructor(n, depth, seed, kind) {
        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.compiledemo_new(n, depth, seed, ptr0, len0);
        this.__wbg_ptr = ret;
        CompileDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.compiledemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.compiledemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    routed_gates() {
        const ret = wasm.compiledemo_routed_gates(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    source_2q() {
        const ret = wasm.compiledemo_source_2q(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    source_gates() {
        const ret = wasm.compiledemo_source_gates(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {string}
     */
    source_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.compiledemo_source_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Source two-qubit gates that are NOT on a coupled pair (need routing).
     * @returns {number}
     */
    source_nonlocal() {
        const ret = wasm.compiledemo_source_nonlocal(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    swaps() {
        const ret = wasm.compiledemo_swaps(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    tamper_equivalent() {
        const ret = wasm.compiledemo_tamper_equivalent(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    target_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.compiledemo_target_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    work() {
        const ret = wasm.compiledemo_work(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) CompileDemo.prototype[Symbol.dispose] = CompileDemo.prototype.free;

export class CrDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CrDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_crdemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    a0_est() {
        const ret = wasm.crdemo_a0_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    a0_truth() {
        const ret = wasm.crdemo_a0_truth(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    a1_est() {
        const ret = wasm.crdemo_a1_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    a1_truth() {
        const ret = wasm.crdemo_a1_truth(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crdemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} a_pi0
     * @param {number} a_pi1
     * @param {number} seed
     * @param {number} a_max
     * @param {number} shots
     */
    constructor(a_pi0, a_pi1, seed, a_max, shots) {
        const ret = wasm.crdemo_new(a_pi0, a_pi1, seed, a_max, shots);
        this.__wbg_ptr = ret;
        CrDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.crdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Float64Array}
     */
    sweep0_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crdemo_sweep0_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    sweep1_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crdemo_sweep1_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    sweep_x() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crdemo_sweep_x(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    zx_shift() {
        const ret = wasm.crdemo_zx_shift(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) CrDemo.prototype[Symbol.dispose] = CrDemo.prototype.free;

/**
 * A signed bone creation: the op bytes to broadcast + the minted bone id
 * (so the page can target later SET_ROTATION ops at it).
 */
export class CreatedBone {
    static __wrap(ptr) {
        const obj = Object.create(CreatedBone.prototype);
        obj.__wbg_ptr = ptr;
        CreatedBoneFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CreatedBoneFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_createdbone_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    get id() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.createdbone_id(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Uint8Array}
     */
    get op() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.createdbone_op(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) CreatedBone.prototype[Symbol.dispose] = CreatedBone.prototype.free;

export class CrosstalkDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        CrosstalkDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_crosstalkdemo_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crosstalkdemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    max_error() {
        const ret = wasm.crosstalkdemo_max_error(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    n() {
        const ret = wasm.crosstalkdemo_n(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @param {number} n
     * @param {number} seed
     */
    constructor(n, seed) {
        const ret = wasm.crosstalkdemo_new(n, seed);
        this.__wbg_ptr = ret;
        CrosstalkDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.crosstalkdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Float64Array}
     */
    recovered() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crosstalkdemo_recovered(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    truth() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.crosstalkdemo_truth(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    worst_offdiag() {
        const ret = wasm.crosstalkdemo_worst_offdiag(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) CrosstalkDemo.prototype[Symbol.dispose] = CrosstalkDemo.prototype.free;

/**
 * Decoded audio: int16 PCM, mono — to be fed to a Web Audio buffer and hashed
 * (its little-endian bytes) for the in-page receipt check.
 */
export class DecodedAudio {
    static __wrap(ptr) {
        const obj = Object.create(DecodedAudio.prototype);
        obj.__wbg_ptr = ptr;
        DecodedAudioFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DecodedAudioFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_decodedaudio_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    get nSamples() {
        const ret = wasm.decodedaudio_nSamples(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * The decoded int16 PCM samples (mono).
     * @returns {Int16Array}
     */
    get pcm() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.decodedaudio_pcm(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayI16FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 2, 2);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The sample rate the `WIA1` payload states, in hertz; `0` from the JSON form,
     * which carries none.
     * @returns {number}
     */
    get sampleRate() {
        const ret = wasm.decodedaudio_sampleRate(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) DecodedAudio.prototype[Symbol.dispose] = DecodedAudio.prototype.free;

/**
 * An integer-exact decoded image: RGB row-major, `width * height * 3` bytes.
 */
export class DecodedImage {
    static __wrap(ptr) {
        const obj = Object.create(DecodedImage.prototype);
        obj.__wbg_ptr = ptr;
        DecodedImageFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DecodedImageFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_decodedimage_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    get height() {
        const ret = wasm.decodedimage_height(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * RGB bytes, row-major, length `width * height * 3`. Copy into an
     * `ImageData` (after widening to RGBA) to paint a canvas.
     * @returns {Uint8Array}
     */
    get rgb() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.decodedimage_rgb(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get width() {
        const ret = wasm.decodedimage_width(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) DecodedImage.prototype[Symbol.dispose] = DecodedImage.prototype.free;

/**
 * A decoded splat: the `[n_attr · s · s]` `u8` attribute tensor (channel-major) —
 * un-normalized to Gaussians (pos/scale/rot/color/opacity) on the JS side using the
 * per-attribute ranges the payload carries (`ranges`).
 */
export class DecodedSplat {
    static __wrap(ptr) {
        const obj = Object.create(DecodedSplat.prototype);
        obj.__wbg_ptr = ptr;
        DecodedSplatFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DecodedSplatFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_decodedsplat_free(ptr, 0);
    }
    /**
     * @returns {Uint8Array}
     */
    get attr() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.decodedsplat_attr(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get nAttr() {
        const ret = wasm.decodedsplat_nAttr(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Gaussians in the cloud: the first `nGaussians` cells of each `s × s` plane.
     * @returns {number}
     */
    get nGaussians() {
        const ret = wasm.decodedsplat_nGaussians(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Per attribute, `lo` then `hi`: the range its `u8` plane is presented over.
     * Presentation only: the splat-equivalence digest covers `attr`, not these.
     * @returns {Float32Array}
     */
    get ranges() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.decodedsplat_ranges(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get s() {
        const ret = wasm.decodedsplat_s(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) DecodedSplat.prototype[Symbol.dispose] = DecodedSplat.prototype.free;

/**
 * A decoded clip: its frames, each `width · height · 3` bytes of RGB, as the
 * decoder produced them. `frame(i)` hands JS one frame; `rgb` concatenates them all
 * into one new buffer on each read, so a page that paints frame by frame holds the
 * clip once.
 */
export class DecodedVideo {
    static __wrap(ptr) {
        const obj = Object.create(DecodedVideo.prototype);
        obj.__wbg_ptr = ptr;
        DecodedVideoFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DecodedVideoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_decodedvideo_free(ptr, 0);
    }
    /**
     * Frame `index` (`width · height · 3` bytes), or an empty buffer past the last.
     * @param {number} index
     * @returns {Uint8Array}
     */
    frame(index) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.decodedvideo_frame(retptr, this.__wbg_ptr, index);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get height() {
        const ret = wasm.decodedvideo_height(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    get nFrames() {
        const ret = wasm.decodedvideo_nFrames(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * All frames, concatenated into a new buffer: frame `f` is
     * `rgb[f·w·h·3 .. (f+1)·w·h·3]`.
     * @returns {Uint8Array}
     */
    get rgb() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.decodedvideo_rgb(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get width() {
        const ret = wasm.decodedvideo_width(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) DecodedVideo.prototype[Symbol.dispose] = DecodedVideo.prototype.free;

export class DragDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        DragDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_dragdemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    beta_est() {
        const ret = wasm.dragdemo_beta_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    beta_truth() {
        const ret = wasm.dragdemo_beta_truth(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.dragdemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} beta_opt
     * @param {number} curvature
     * @param {number} seed
     * @param {number} shots
     */
    constructor(beta_opt, curvature, seed, shots) {
        const ret = wasm.dragdemo_new(beta_opt, curvature, seed, shots);
        this.__wbg_ptr = ret;
        DragDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.dragdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    residual() {
        const ret = wasm.dragdemo_residual(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {Float64Array}
     */
    sweep_x() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.dragdemo_sweep_x(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    sweep_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.dragdemo_sweep_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) DragDemo.prototype[Symbol.dispose] = DragDemo.prototype.free;

export class FeedSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        FeedSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_feedsink_free(ptr, 0);
    }
    /**
     * Step (or re-derive) the engine to `tick`.
     * @param {bigint} tick
     */
    advance_to(tick) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.feedsink_advance_to(retptr, this.__wbg_ptr, tick);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {bigint}
     */
    current_tick() {
        const ret = wasm.feedsink_current_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {bigint}
     */
    final_tick() {
        const ret = wasm.feedsink_final_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Ingest one signed CausalOp (a live feed publisher's update).
     * @param {Uint8Array} bytes
     */
    ingest_op(bytes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.feedsink_ingest_op(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Open WWLD feed bytes. A seal, if present, is lifted out for
     * `verify_seal`; playback runs the live engine.
     * @param {Uint8Array} bytes
     */
    constructor(bytes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.feedsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            FeedSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    record_count() {
        const ret = wasm.feedsink_record_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * The live state as JSON: `[{ "id": "<hex16>", "cells": [ {t,v}… ] }]`,
     * records in canonical node-id order. Cell `t` ∈ {"int","fixed",
     * "text"}; `fixed` carries both exact `bits` and a display `v`.
     * @returns {string}
     */
    records_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.feedsink_records_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string | undefined}
     */
    seal_hash_hex() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.feedsink_seal_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    sim() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.feedsink_sim(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * BLAKE3 state hash at the current tick — what replay-equivalence
     * is defined over, computed by the corpus-generating code.
     * @returns {string}
     */
    state_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.feedsink_state_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Replay to the sealed final tick and compare hashes. `true` = this
     * browser re-derived the publisher's exact feed state.
     * @returns {boolean}
     */
    verify_seal() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.feedsink_verify_seal(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 !== 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) FeedSink.prototype[Symbol.dispose] = FeedSink.prototype.free;

export class FilmSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        FilmSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_filmsink_free(ptr, 0);
    }
    /**
     * The interpolated camera pose at frame `f`: 8 f32 —
     * `[px, py, pz, qx, qy, qz, qw, fov]`. The pose is exact `Fx` in the
     * floor; this projection to f32 is display only.
     * @param {bigint} f
     * @returns {Float32Array}
     */
    camera(f) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.filmsink_camera(retptr, this.__wbg_ptr, f);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Film identity — binds contract + embedded world + camera.
     * @returns {string}
     */
    film_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.filmsink_film_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Per-frame identity `BLAKE3(world_state_hash(frame_tick) ||
     * camera_pose)` — the same value every sink must agree on.
     * @param {bigint} f
     * @returns {string}
     */
    frame_hash_hex(f) {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.filmsink_frame_hash_hex(retptr, this.__wbg_ptr, f);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * @param {bigint} f
     * @returns {bigint}
     */
    frame_tick(f) {
        const ret = wasm.filmsink_frame_tick(this.__wbg_ptr, f);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {bigint}
     */
    frames() {
        const ret = wasm.filmsink_frames(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * The Merkle root over the per-frame reconstruction hashes — the
     * film-equivalence quantity the corpus freezes. Validates the embedded
     * world (seal re-derives) as a side effect.
     * @returns {string}
     */
    frames_root_hex() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.filmsink_frames_root_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * @param {Uint8Array} wflm
     */
    constructor(wflm) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(wflm, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.filmsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            FilmSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {bigint}
     */
    start_tick() {
        const ret = wasm.filmsink_start_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {bigint}
     */
    ticks_per_frame() {
        const ret = wasm.filmsink_ticks_per_frame(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * The embedded sealed world (a `WWLD`), so the page can drive a
     * `WorldSink` to read the moving world the camera frames.
     * @returns {Uint8Array}
     */
    world_bytes() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.filmsink_world_bytes(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The embedded world's sim capability (e.g. `wai.world.sim.kinematic0` or
     * `wai.world.sim.skeletal0`), so the page renders the right kind of
     * subject — points for a kinematic world, a skeleton for an avatar.
     * @returns {string}
     */
    world_sim() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.filmsink_world_sim(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) FilmSink.prototype[Symbol.dispose] = FilmSink.prototype.free;

/**
 * A generated image: RGB row-major, `width * height * 3` bytes.
 */
export class GeneratedImage {
    static __wrap(ptr) {
        const obj = Object.create(GeneratedImage.prototype);
        obj.__wbg_ptr = ptr;
        GeneratedImageFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GeneratedImageFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_generatedimage_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    get height() {
        const ret = wasm.generatedimage_height(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {Uint8Array}
     */
    get rgb() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.generatedimage_rgb(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get width() {
        const ret = wasm.generatedimage_width(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) GeneratedImage.prototype[Symbol.dispose] = GeneratedImage.prototype.free;

export class GrossDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GrossDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_grossdemo_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    code_id() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.grossdemo_code_id(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    converged() {
        const ret = wasm.grossdemo_converged(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    correction_weight() {
        const ret = wasm.grossdemo_correction_weight(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    error_weight() {
        const ret = wasm.grossdemo_error_weight(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    iters() {
        const ret = wasm.grossdemo_iters(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Modeled joules-per-decode (µJ) = messages · declared per-message energy.
     * @returns {number}
     */
    joules_micro() {
        const ret = wasm.grossdemo_joules_micro(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    k() {
        const ret = wasm.grossdemo_k(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    legs() {
        const ret = wasm.grossdemo_legs(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    logical_success() {
        const ret = wasm.grossdemo_logical_success(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    messages() {
        const ret = wasm.grossdemo_messages(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    n() {
        const ret = wasm.grossdemo_n(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Decode one error on the [[72,12]] bivariate-bicycle code at rate `p`.
     * @param {number} p
     * @param {number} seed
     */
    constructor(p, seed) {
        const ret = wasm.grossdemo_new(p, seed);
        this.__wbg_ptr = ret;
        GrossDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Per-qubit flags for the strip viz: 0 clean, 1 errored, 2 corrected, 3 both.
     * @returns {Uint8Array}
     */
    qubit_flags() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.grossdemo_qubit_flags(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.grossdemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.grossdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    syndrome_weight() {
        const ret = wasm.grossdemo_syndrome_weight(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) GrossDemo.prototype[Symbol.dispose] = GrossDemo.prototype.free;

export class HapticSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HapticSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hapticsink_free(ptr, 0);
    }
    /**
     * Reconstructed channel `c`: interleaved `[intensity, sharpness]`
     * u8 per sample — the canonical buffer, for the waveform view and
     * to drive the actuator.
     * @param {number} c
     * @returns {Uint8Array}
     */
    channel(c) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.hapticsink_channel(retptr, this.__wbg_ptr, c);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {bigint}
     */
    duration() {
        const ret = wasm.hapticsink_duration(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @param {Uint8Array} whap
     */
    constructor(whap) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(whap, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.hapticsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            HapticSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    num_channels() {
        const ret = wasm.hapticsink_num_channels(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    sample_rate() {
        const ret = wasm.hapticsink_sample_rate(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {string}
     */
    signal_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.hapticsink_signal_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) HapticSink.prototype[Symbol.dispose] = HapticSink.prototype.free;

/**
 * What a decode will cost, read before it starts (`intPayloadCost`): the output's
 * bytes, the symbols the streams code, the most bytes the reference decode holds at
 * once, and the networks' multiply-accumulates (`extensions/integer-payloads.md` §7,
 * *Memory and work*). A page applies its own size policy to these and does not
 * decode a payload past it. The byte and symbol counts are under `2^53` and exact as
 * numbers; `macs` is a `BigInt`.
 */
export class IntPayloadCost {
    static __wrap(ptr) {
        const obj = Object.create(IntPayloadCost.prototype);
        obj.__wbg_ptr = ptr;
        IntPayloadCostFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        IntPayloadCostFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_intpayloadcost_free(ptr, 0);
    }
    /**
     * @returns {bigint}
     */
    get macs() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.intpayloadcost_macs(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
            var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
            return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get outputBytes() {
        const ret = wasm.intpayloadcost_outputBytes(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    get symbols() {
        const ret = wasm.intpayloadcost_symbols(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    get workingBytes() {
        const ret = wasm.intpayloadcost_workingBytes(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) IntPayloadCost.prototype[Symbol.dispose] = IntPayloadCost.prototype.free;

/**
 * A title evaluated once, for a page that reads several things of it.
 */
export class MeasureTitle {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MeasureTitleFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_measuretitle_free(ptr, 0);
    }
    /**
     * The text `evaluateTitle` gives.
     * @returns {string}
     */
    json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.measuretitle_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The simulator's model of the title: `wai-sim-model/1`.
     * @returns {string}
     */
    model() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.measuretitle_model(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The title in `dir` from `files`, evaluated and checked against its expectation.
     * @param {string} dir
     * @param {Map<any, any>} files
     */
    constructor(dir, files) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(dir, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.measuretitle_new(retptr, ptr0, len0, addBorrowedObject(files));
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            MeasureTitleFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            heap[stack_pointer++] = undefined;
        }
    }
    /**
     * The session the native tool records over the title (`stage_measure::session::recorder_of`):
     * every base, then every layer, decoded on the primary path with no deadline, every
     * object received whole and presented. `host_json` as `sessionBegin` reads it.
     * @param {string} host_json
     * @param {string} nonce_hex
     * @returns {SessionHandle}
     */
    session(host_json, nonce_hex) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(host_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passStringToWasm0(nonce_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            wasm.measuretitle_session(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return SessionHandle.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The text `simulate` gives.
     * @param {string} plan_json
     * @returns {string}
     */
    simulate(plan_json) {
        let deferred3_0;
        let deferred3_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(plan_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.measuretitle_simulate(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr2 = r0;
            var len2 = r1;
            if (r3) {
                ptr2 = 0; len2 = 0;
                throw takeObject(r2);
            }
            deferred3_0 = ptr2;
            deferred3_1 = len2;
            return getStringFromWasm0(ptr2, len2);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
        }
    }
}
if (Symbol.dispose) MeasureTitle.prototype[Symbol.dispose] = MeasureTitle.prototype.free;

export class NoiseLearnDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        NoiseLearnDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_noiselearndemo_free(ptr, 0);
    }
    /**
     * @returns {string[]}
     */
    gen_labels() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_gen_labels(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayJsValueFromWasm0(r0, r1);
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    lambdas_learned() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_lambdas_learned(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    lambdas_true() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_lambdas_true(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Does the PEC receipt bind exactly the learned model? (The loop close.)
     * @returns {boolean}
     */
    mit_binds_model() {
        const ret = wasm.noiselearndemo_mit_binds_model(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * The PEC mitigation receipt, whose noise_model_hash binds the learned model.
     * @returns {string}
     */
    mit_receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_mit_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    mit_receipt_verifies() {
        const ret = wasm.noiselearndemo_mit_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    model_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_model_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    n_generators() {
        const ret = wasm.noiselearndemo_n_generators(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    n_probes() {
        const ret = wasm.noiselearndemo_n_probes(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Learn a hidden 3-qubit (line-connectivity) sparse Pauli–Lindblad model from
     * a Cycle-Benchmarking experiment, then PEC-correct a Pauli observable with it.
     * @param {number} seed
     */
    constructor(seed) {
        const ret = wasm.noiselearndemo_new(seed);
        this.__wbg_ptr = ret;
        NoiseLearnDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    pec_ideal() {
        const ret = wasm.noiselearndemo_pec_ideal(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    pec_mitigated() {
        const ret = wasm.noiselearndemo_pec_mitigated(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    pec_obs() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_pec_obs(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    pec_raw() {
        const ret = wasm.noiselearndemo_pec_raw(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    rate_error() {
        const ret = wasm.noiselearndemo_rate_error(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.noiselearndemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.noiselearndemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    total_learned() {
        const ret = wasm.noiselearndemo_total_learned(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    total_true() {
        const ret = wasm.noiselearndemo_total_true(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) NoiseLearnDemo.prototype[Symbol.dispose] = NoiseLearnDemo.prototype.free;

/**
 * An attested ad break — the budget half of the story.
 */
export class OttAdBreak {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OttAdBreakFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_ottadbreak_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    billable() {
        const ret = wasm.ottadbreak_billable(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {bigint}
     */
    budget_spent() {
        const ret = wasm.ottadbreak_budget_spent(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Run a deterministic decision over a three-ad pod against `budget_micros`,
     * mark the filled slots as played, and seal. Set `budget_micros` below the
     * resulting spend to watch a ceiling breach refuse to verify.
     * @param {number} avail_slots
     * @param {bigint} avail_ms
     * @param {bigint} budget_micros
     * @param {bigint} ceiling_micros
     */
    constructor(avail_slots, avail_ms, budget_micros, ceiling_micros) {
        const ret = wasm.ottadbreak_new(avail_slots, avail_ms, budget_micros, ceiling_micros);
        this.__wbg_ptr = ret;
        OttAdBreakFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * `[[slot, ad_id, price_micros, quartiles], ...]` as JSON.
     * @returns {string}
     */
    slots_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottadbreak_slots_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * `false` when the spend exceeds the grant's ceiling — overspend cannot be
     * signed into a valid receipt.
     * @returns {boolean}
     */
    verify() {
        const ret = wasm.ottadbreak_verify(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) OttAdBreak.prototype[Symbol.dispose] = OttAdBreak.prototype.free;

/**
 * An attested per-session manifest, live in the page.
 */
export class OttSession {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        OttSessionFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_ottsession_free(ptr, 0);
    }
    /**
     * The monetisation audit, derived from the ad-bearing segments:
     * `[[break_index, ad_id, duration_ms], ...]` as JSON.
     * @returns {string}
     */
    ads_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottsession_ads_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The dedup key: every viewer of this class gets these identical bytes.
     * @returns {string}
     */
    class_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottsession_class_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The manifest currently implied by the sealed composition. After a tamper
     * this diverges from [`OttSession::manifest`].
     * @returns {string}
     */
    composed_manifest() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottsession_composed_manifest(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The rendered HLS the player receives — ad breaks appear as real
     * `EXT-X-DISCONTINUITY` splices.
     * @returns {string}
     */
    manifest() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottsession_manifest(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    manifest_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottsession_manifest_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Compose a session class, render its manifest and seal the receipt.
     * `blackouts` is a comma-separated set (order-independent by construction).
     * @param {string} content_id
     * @param {string} entitlement
     * @param {string} geo
     * @param {string} blackouts
     * @param {string} ad_pod_id
     * @param {bigint} window
     * @param {number} n_content
     * @param {string} ad_id
     * @param {bigint} viewers_served
     * @param {bigint} joules_micro
     */
    constructor(content_id, entitlement, geo, blackouts, ad_pod_id, window, n_content, ad_id, viewers_served, joules_micro) {
        const ptr0 = passStringToWasm0(content_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(entitlement, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passStringToWasm0(geo, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passStringToWasm0(blackouts, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len3 = WASM_VECTOR_LEN;
        const ptr4 = passStringToWasm0(ad_pod_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len4 = WASM_VECTOR_LEN;
        const ptr5 = passStringToWasm0(ad_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len5 = WASM_VECTOR_LEN;
        const ret = wasm.ottsession_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, window, n_content, ptr5, len5, viewers_served, joules_micro);
        this.__wbg_ptr = ret;
        OttSessionFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {string}
     */
    receipt_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ottsession_receipt_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    segment_count() {
        const ret = wasm.ottsession_segment_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Substitute a different creative into the break **without re-signing** —
     * the ad-fraud move. `verify()` flips to false, because the sealed
     * `manifest_hash` no longer matches what the composition renders.
     * @param {string} new_ad_id
     */
    swap_ad(new_ad_id) {
        const ptr0 = passStringToWasm0(new_ad_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.ottsession_swap_ad(this.__wbg_ptr, ptr0, len0);
    }
    /**
     * Amortised microjoules per viewer, or `-1` when unmetered. This is the
     * figure a 1:1-unique generator cannot report below its per-viewer cost.
     * @returns {number}
     */
    uj_per_viewer() {
        const ret = wasm.ottsession_uj_per_viewer(this.__wbg_ptr);
        return ret;
    }
    /**
     * Signature + internal consistency, recomputed in the tab.
     * @returns {boolean}
     */
    verify() {
        const ret = wasm.ottsession_verify(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * The independent check against the bytes actually delivered.
     * @returns {boolean}
     */
    verify_delivered() {
        const ret = wasm.ottsession_verify_delivered(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {bigint}
     */
    viewers_served() {
        const ret = wasm.ottsession_viewers_served(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
}
if (Symbol.dispose) OttSession.prototype[Symbol.dispose] = OttSession.prototype.free;

export class PhasorBridge {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        PhasorBridgeFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_phasorbridge_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    err_phasor() {
        const ret = wasm.phasorbridge_err_phasor(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    err_qfhrr() {
        const ret = wasm.phasorbridge_err_qfhrr(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    n_freqs() {
        const ret = wasm.phasorbridge_n_freqs(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Build a random `r`-reupload quantum model, extract its spectrum, and evaluate
     * three ways on a `grid`: the quantum state-vector model, the classical phasor
     * sum (FHRR), and the `bits`-bit quantized phasor sum (qFHRR).
     * @param {number} r
     * @param {number} seed
     * @param {number} grid
     * @param {number} bits
     */
    constructor(r, seed, grid, bits) {
        const ret = wasm.phasorbridge_new(r, seed, grid, bits);
        this.__wbg_ptr = ret;
        PhasorBridgeFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {Float64Array}
     */
    phasor() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorbridge_phasor(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    qfhrr() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorbridge_qfhrr(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    quantum() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorbridge_quantum(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) PhasorBridge.prototype[Symbol.dispose] = PhasorBridge.prototype.free;

export class PhasorKernel {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        PhasorKernelFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_phasorkernel_free(ptr, 0);
    }
    /**
     * Phasor operations to featurize the test set (the joule-priced count).
     * @returns {number}
     */
    feature_ops() {
        const ret = wasm.phasorkernel_feature_ops(this.__wbg_ptr);
        return ret;
    }
    /**
     * Decision score on a `res × res` grid over `[-1.5, 1.5]²` — the boundary.
     * @param {number} res
     * @returns {Float64Array}
     */
    grid_scores(res) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorkernel_grid_scores(retptr, this.__wbg_ptr, res);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Train a phasor-feature ridge classifier on `dataset` ("circles" | "xor").
     * @param {string} dataset_name
     * @param {number} n
     * @param {number} n_features
     * @param {number} gamma
     * @param {number} seed
     */
    constructor(dataset_name, n, n_features, gamma, seed) {
        const ptr0 = passStringToWasm0(dataset_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.phasorkernel_new(ptr0, len0, n, n_features, gamma, seed);
        this.__wbg_ptr = ret;
        PhasorKernelFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Seal a signed phasor energy receipt over this trained classifier: the
     * portable-exact phasor work (recomputed from the shape) bound to the fitted
     * weights' reproducible-f64 fingerprint, plus `joules_micro` in the energy
     * slot. The browser has no hardware meter, so pass an *illustrative* draw (or
     * `0` for honest-unmetered); on a metered sink this slot carries the real
     * energy and the receipt format is byte-identical.
     * @param {number} joules_micro
     * @returns {PhasorReceiptJs}
     */
    seal_receipt(joules_micro) {
        const ret = wasm.phasorkernel_seal_receipt(this.__wbg_ptr, joules_micro);
        return PhasorReceiptJs.__wrap(ret);
    }
    /**
     * @returns {number}
     */
    test_accuracy() {
        const ret = wasm.phasorkernel_test_accuracy(this.__wbg_ptr);
        return ret;
    }
    /**
     * @param {number} bits
     * @returns {number}
     */
    test_accuracy_qfhrr(bits) {
        const ret = wasm.phasorkernel_test_accuracy_qfhrr(this.__wbg_ptr, bits);
        return ret;
    }
    /**
     * Training points, flattened `[x, y, label, …]`.
     * @returns {Float64Array}
     */
    train_points() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorkernel_train_points(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) PhasorKernel.prototype[Symbol.dispose] = PhasorKernel.prototype.free;

/**
 * A signed phasor energy receipt in the browser — the accountable seal for this
 * interference computation (`wai.quantum.phasor`).
 */
export class PhasorReceiptJs {
    static __wrap(ptr) {
        const obj = Object.create(PhasorReceiptJs.prototype);
        obj.__wbg_ptr = ptr;
        PhasorReceiptJsFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        PhasorReceiptJsFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_phasorreceiptjs_free(ptr, 0);
    }
    /**
     * The energy slot (microjoules). `0` = unmetered; illustrative in the browser.
     * @returns {number}
     */
    joules_micro() {
        const ret = wasm.phasorreceiptjs_joules_micro(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    method() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorreceiptjs_method(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Measured microjoules per million phasor ops — the accountable price.
     * @returns {number}
     */
    micro_joules_per_megaop() {
        const ret = wasm.phasorreceiptjs_micro_joules_per_megaop(this.__wbg_ptr);
        return ret;
    }
    /**
     * Portable-exact phasor work (bind/bundle/similarity ops) — recomputable.
     * @returns {number}
     */
    phasor_ops() {
        const ret = wasm.phasorreceiptjs_phasor_ops(this.__wbg_ptr);
        return ret;
    }
    /**
     * Picojoules per phasor op.
     * @returns {number}
     */
    pico_joules_per_op() {
        const ret = wasm.phasorreceiptjs_pico_joules_per_op(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    signer_id() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorreceiptjs_signer_id(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The canonical portable receipt JSON.
     * @returns {string}
     */
    to_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.phasorreceiptjs_to_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Does the receipt verify — Merkle + recomputed work + Ed25519 signature?
     * @returns {boolean}
     */
    verifies() {
        const ret = wasm.phasorreceiptjs_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) PhasorReceiptJs.prototype[Symbol.dispose] = PhasorReceiptJs.prototype.free;

export class QDataSeparation {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        QDataSeparationFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_qdataseparation_free(ptr, 0);
    }
    /**
     * Smallest Bell copies to reach worst-case error `≤ eps` (0 = grid ceiling
     * insufficient).
     * @param {number} eps
     * @param {number} seed
     * @returns {number}
     */
    bell_copies_for(eps, seed) {
        const ret = wasm.qdataseparation_bell_copies_for(this.__wbg_ptr, eps, seed);
        return ret;
    }
    /**
     * Worst-case fidelity error of the two-copy **Bell** (quantum-memory) estimator.
     * @returns {Float64Array}
     */
    bell_err() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qdataseparation_bell_err(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Smallest conventional copies to reach `≤ eps`.
     * @param {number} eps
     * @param {number} seed
     * @returns {number}
     */
    conv_copies_for(eps, seed) {
        const ret = wasm.qdataseparation_conv_copies_for(this.__wbg_ptr, eps, seed);
        return ret;
    }
    /**
     * Worst-case fidelity error of the **entanglement-free** (conventional) estimator.
     * @returns {Float64Array}
     */
    conv_err() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qdataseparation_conv_err(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The copy budgets (x-axis).
     * @returns {Float64Array}
     */
    copies() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qdataseparation_copies(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * `2^n` — the number of Pauli fidelities to learn (the conventional cost floor).
     * @returns {number}
     */
    dim() {
        const ret = wasm.qdataseparation_dim(this.__wbg_ptr);
        return ret;
    }
    /**
     * Simulate the separation for an `n`-qubit demo channel over the copy grid.
     * @param {number} n
     * @param {number} seed
     */
    constructor(n, seed) {
        const ret = wasm.qdataseparation_new(n, seed);
        this.__wbg_ptr = ret;
        QDataSeparationFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * The copies ratio `conventional / Bell ≈ 2^n` — the exponential price of no
     * quantum memory.
     * @param {number} eps
     * @param {number} seed
     * @returns {number}
     */
    ratio_for(eps, seed) {
        const ret = wasm.qdataseparation_ratio_for(this.__wbg_ptr, eps, seed);
        return ret;
    }
}
if (Symbol.dispose) QDataSeparation.prototype[Symbol.dispose] = QDataSeparation.prototype.free;

export class QbomDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        QbomDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_qbomdemo_free(ptr, 0);
    }
    /**
     * Every listed stage binds a receipt that itself verifies.
     * @returns {boolean}
     */
    all_bind() {
        const ret = wasm.qbomdemo_all_bind(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    device_id() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_device_id(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    job_id() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_job_id(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Build a QBOM for one computation on `seed`: compile + rearrange run live,
     * calibrate + mitigate + decode are sealed as stage receipts, all bundled and
     * signed.
     * @param {number} seed
     */
    constructor(seed) {
        const ret = wasm.qbomdemo_new(seed);
        this.__wbg_ptr = ret;
        QbomDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {string}
     */
    operator_envelope() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_operator_envelope(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    program_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_program_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    provenance_root_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_provenance_root_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    qbom_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_qbom_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    stage_count() {
        const ret = wasm.qbomdemo_stage_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {string[]}
     */
    stage_hashes() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_stage_hashes(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayJsValueFromWasm0(r0, r1);
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Uint32Array}
     */
    stage_joules() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_stage_joules(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string[]}
     */
    stage_kinds() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.qbomdemo_stage_kinds(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayJsValueFromWasm0(r0, r1);
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Swap one stage's receipt for a forgery — the bill must NOT bind.
     * @returns {boolean}
     */
    tamper_binds() {
        const ret = wasm.qbomdemo_tamper_binds(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    total_joules_micro() {
        const ret = wasm.qbomdemo_total_joules_micro(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    verifies() {
        const ret = wasm.qbomdemo_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) QbomDemo.prototype[Symbol.dispose] = QbomDemo.prototype.free;

export class QuantumCal {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        QuantumCalFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_quantumcal_free(ptr, 0);
    }
    /**
     * A fidelity claim binds to the exact dataset bytes that produced it.
     * @param {Uint8Array} bytes
     * @returns {boolean}
     */
    evidence_matches(bytes) {
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.quantumcal_evidence_matches(this.__wbg_ptr, ptr0, len0);
        return ret !== 0;
    }
    /**
     * @returns {boolean}
     */
    honors_budget() {
        const ret = wasm.quantumcal_honors_budget(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {bigint}
     */
    joule_ceiling() {
        const ret = wasm.quantumcal_joule_ceiling(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {bigint}
     */
    joules_micro() {
        const ret = wasm.quantumcal_joules_micro(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {string}
     */
    json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumcal_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Seal a calibration receipt. `config_bytes` and `evidence_bytes` are the raw
     * artifacts (content-addressed inside); `joule_ceiling` is the grant's budget.
     * @param {number} seed
     * @param {string} device
     * @param {string} target
     * @param {Uint8Array} config_bytes
     * @param {string} evidence_kind
     * @param {Uint8Array} evidence_bytes
     * @param {string} evidence_summary
     * @param {bigint} joules_micro
     * @param {string} capability
     * @param {bigint} joule_ceiling
     */
    constructor(seed, device, target, config_bytes, evidence_kind, evidence_bytes, evidence_summary, joules_micro, capability, joule_ceiling) {
        const ptr0 = passStringToWasm0(device, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(target, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(config_bytes, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passStringToWasm0(evidence_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len3 = WASM_VECTOR_LEN;
        const ptr4 = passArray8ToWasm0(evidence_bytes, wasm.__wbindgen_export);
        const len4 = WASM_VECTOR_LEN;
        const ptr5 = passStringToWasm0(evidence_summary, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len5 = WASM_VECTOR_LEN;
        const ptr6 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len6 = WASM_VECTOR_LEN;
        const ret = wasm.quantumcal_new(seed, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, joules_micro, ptr6, len6, joule_ceiling);
        this.__wbg_ptr = ret;
        QuantumCalFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {string}
     */
    receipt_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumcal_receipt_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Tamper: overwrite the signed `joules_micro`. `verify()` now fails — the
     * signature no longer covers the mutated field.
     * @param {bigint} j
     */
    tamper_joules(j) {
        wasm.quantumcal_tamper_joules(this.__wbg_ptr, j);
    }
    /**
     * Cryptographically valid AND within the grant's joule budget.
     * @returns {boolean}
     */
    verify() {
        const ret = wasm.quantumcal_verify(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) QuantumCal.prototype[Symbol.dispose] = QuantumCal.prototype.free;

export class QuantumIde {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        QuantumIdeFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_quantumide_free(ptr, 0);
    }
    /**
     * Append a gate. `controls` are the control qubits (empty for a 1-qubit gate);
     * `param` is the `P(k)` dyadic index (ignored otherwise).
     * @param {string} name
     * @param {Uint8Array} controls
     * @param {number} target
     * @param {number} param
     * @returns {boolean}
     */
    add(name, controls, target, param) {
        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(controls, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.quantumide_add(this.__wbg_ptr, ptr0, len0, ptr1, len1, target, param);
        return ret !== 0;
    }
    /**
     * @returns {Float64Array}
     */
    amp_mag() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_amp_mag(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    amp_phase() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_amp_phase(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    backend() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_backend(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    backend_why() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_backend_why(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} q
     * @returns {Float64Array}
     */
    bloch(q) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_bloch(retptr, this.__wbg_ptr, q);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    circuit_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_circuit_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    clear() {
        wasm.quantumide_clear(this.__wbg_ptr);
    }
    /**
     * @param {number} seed
     * @param {number} shots
     * @returns {Uint32Array}
     */
    counts(seed, shots) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_counts(retptr, this.__wbg_ptr, seed, shots);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {number} q
     * @returns {number}
     */
    entropy(q) {
        const ret = wasm.quantumide_entropy(this.__wbg_ptr, q);
        return ret;
    }
    /**
     * @param {number} q
     * @returns {number}
     */
    expect_z(q) {
        const ret = wasm.quantumide_expect_z(this.__wbg_ptr, q);
        return ret;
    }
    /**
     * Compute ⟨Z_q⟩ on the current circuit via sparse-Pauli / Heisenberg
     * propagation: `{value, peak}` (peak Pauli-sum size) or `{error}`.
     * @param {number} q
     * @param {number} threshold
     * @returns {string}
     */
    expect_z_pauli(q, threshold) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_expect_z_pauli(retptr, this.__wbg_ptr, q, threshold);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The op-log as JSON, for the editor to render.
     * @returns {string}
     */
    gates_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_gates_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    is_clifford() {
        const ret = wasm.quantumide_is_clifford(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Replace the circuit with a library algorithm.
     * @param {string} id
     * @param {number} n
     * @param {number} param
     * @returns {boolean}
     */
    load_algorithm(id, n, param) {
        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.quantumide_load_algorithm(this.__wbg_ptr, ptr0, len0, n, param);
        return ret !== 0;
    }
    /**
     * Replace the circuit from an OpenQASM source. Returns an error string on
     * failure (unsupported gate, non-dyadic phase, bad register).
     * @param {string} src
     */
    load_qasm(src) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(src, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.quantumide_load_qasm(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    n_gates() {
        const ret = wasm.quantumide_n_gates(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    n_qubits() {
        const ret = wasm.quantumide_n_qubits(this.__wbg_ptr);
        return ret;
    }
    /**
     * @param {number} n_qubits
     */
    constructor(n_qubits) {
        const ret = wasm.quantumide_new(n_qubits);
        this.__wbg_ptr = ret;
        QuantumIdeFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * ⟨Z_q⟩ under a per-gate depolarizing channel at `depol_permille`/1000, averaged
     * over `trajectories` Monte-Carlo runs — decoherence, made measurable.
     * @param {number} q
     * @param {number} depol_permille
     * @param {number} trajectories
     * @param {number} seed
     * @returns {number}
     */
    noisy_expect_z(q, depol_permille, trajectories, seed) {
        const ret = wasm.quantumide_noisy_expect_z(this.__wbg_ptr, q, depol_permille, trajectories, seed);
        return ret;
    }
    /**
     * Scale demonstration: ⟨Z_0⟩ on an `n`-qubit low-magic circuit — a single
     * expectation propagates a bounded Pauli sum where a 2ⁿ state cannot exist.
     * @param {number} n
     * @param {number} threshold
     * @returns {string}
     */
    pauli_scale(n, threshold) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_pauli_scale(retptr, this.__wbg_ptr, n, threshold);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    pop() {
        wasm.quantumide_pop(this.__wbg_ptr);
    }
    /**
     * @returns {Float64Array}
     */
    probabilities() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_probabilities(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {number} q
     * @returns {number}
     */
    purity(q) {
        const ret = wasm.quantumide_purity(this.__wbg_ptr, q);
        return ret;
    }
    /**
     * @returns {string}
     */
    qasm() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_qasm(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Seal a signed run receipt over the byte-exact reconstruction (and a shot
     * histogram). The receipt re-simulates internally — its statevector hash is the
     * true reconstruction, never a claim.
     * @param {number} seed
     * @param {number} shots
     * @returns {string}
     */
    receipt_json(seed, shots) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_receipt_json(retptr, this.__wbg_ptr, seed, shots);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} seed
     * @param {number} shots
     * @returns {boolean}
     */
    receipt_verifies(seed, shots) {
        const ret = wasm.quantumide_receipt_verifies(this.__wbg_ptr, seed, shots);
        return ret !== 0;
    }
    run() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_run(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Run the circuit through the tensor-network (MPS) backend at bond cap
     * `chi_max` and report `{bond, retained, fidelity}` against the exact dense
     * statevector (or `{error}`). This is the classical referee, live.
     * @param {number} chi_max
     * @returns {string}
     */
    run_mps(chi_max) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_run_mps(retptr, this.__wbg_ptr, chi_max);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Debugger step: simulate only the first `k` gates and set the inspected state
     * to that intermediate point. The analysis getters then reflect the state
     * *after gate k* — step through and watch superposition, interference, and
     * entanglement build up.
     * @param {number} k
     */
    run_to(k) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_run_to(retptr, this.__wbg_ptr, k);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Sample the current circuit on the O(n²) stabilizer backend (if Clifford):
     * `{distinct, top_index, top_count}` or `{error}`.
     * @param {number} seed
     * @param {number} shots
     * @returns {string}
     */
    sample_stabilizer(seed, shots) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_sample_stabilizer(retptr, this.__wbg_ptr, seed, shots);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} n
     */
    set_qubits(n) {
        wasm.quantumide_set_qubits(this.__wbg_ptr, n);
    }
    /**
     * Scale demonstration: build an `n`-qubit GHZ and sample it on the stabilizer
     * backend — instant where a dense `2ⁿ`-amplitude state is impossible.
     * @param {number} n
     * @param {number} seed
     * @param {number} shots
     * @returns {string}
     */
    stabilizer_scale(n, seed, shots) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_stabilizer_scale(retptr, this.__wbg_ptr, n, seed, shots);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    statevector_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_statevector_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} k
     * @returns {Uint32Array}
     */
    top_indices(k) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_top_indices(retptr, this.__wbg_ptr, k);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {number} k
     * @returns {Float64Array}
     */
    top_probs(k) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_top_probs(retptr, this.__wbg_ptr, k);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Route the circuit onto a linear nearest-neighbour coupling and prove the
     * routed circuit is equivalent: `{source_2q, nonlocal, routed_gates, swaps,
     * equivalent}`.
     * @returns {string}
     */
    transpile_line() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumide_transpile_line(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    work() {
        const ret = wasm.quantumide_work(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) QuantumIde.prototype[Symbol.dispose] = QuantumIde.prototype.free;

export class QuantumJob {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        QuantumJobFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_quantumjob_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumjob_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Seal a job receipt. `cal_ref_hex` is the calibration receipt's hash (the
     * device state it ran under); pass `null`/undefined for a simulator run.
     * @param {number} seed
     * @param {string} backend
     * @param {Uint8Array} circuit_bytes
     * @param {Uint8Array} result_bytes
     * @param {string | null | undefined} cal_ref_hex
     * @param {bigint} shots
     * @param {bigint} joules_micro
     * @param {string} capability
     * @param {bigint} joule_ceiling
     */
    constructor(seed, backend, circuit_bytes, result_bytes, cal_ref_hex, shots, joules_micro, capability, joule_ceiling) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(backend, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passArray8ToWasm0(circuit_bytes, wasm.__wbindgen_export);
            const len1 = WASM_VECTOR_LEN;
            const ptr2 = passArray8ToWasm0(result_bytes, wasm.__wbindgen_export);
            const len2 = WASM_VECTOR_LEN;
            var ptr3 = isLikeNone(cal_ref_hex) ? 0 : passStringToWasm0(cal_ref_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            var len3 = WASM_VECTOR_LEN;
            const ptr4 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len4 = WASM_VECTOR_LEN;
            wasm.quantumjob_new(retptr, seed, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, shots, joules_micro, ptr4, len4, joule_ceiling);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            QuantumJobFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    receipt_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumjob_receipt_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    verify() {
        const ret = wasm.quantumjob_verify(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * The cross-link: does this job bind to the given calibration state? Confirms
     * the job names that calibration's hash and both receipts verify. The
     * calibration may be in either form — as sealed, or with its joule figure's
     * acquisition class inside the signature — and is named by the identity of the
     * form it is in.
     * @param {string} cal_json
     * @returns {boolean}
     */
    verify_against_calibration(cal_json) {
        const ptr0 = passStringToWasm0(cal_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.quantumjob_verify_against_calibration(this.__wbg_ptr, ptr0, len0);
        return ret !== 0;
    }
}
if (Symbol.dispose) QuantumJob.prototype[Symbol.dispose] = QuantumJob.prototype.free;

export class QuantumSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        QuantumSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_quantumsink_free(ptr, 0);
    }
    /**
     * `2^n` — the number of complex amplitudes reconstructed.
     * @returns {number}
     */
    dim() {
        const ret = wasm.quantumsink_dim(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    has_measure() {
        const ret = wasm.quantumsink_has_measure(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Shot-histogram hash at the pinned `(seed, shots)`, if the container
     * carries a measurement — the shot-histogram-equivalence hash.
     * @returns {string | undefined}
     */
    histogram_hash_hex() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumsink_histogram_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    n_ops() {
        const ret = wasm.quantumsink_n_ops(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    n_qubits() {
        const ret = wasm.quantumsink_n_qubits(this.__wbg_ptr);
        return ret;
    }
    /**
     * Parse a `WQC` container and classically simulate it — pure i64, no float.
     * Throws on a malformed container or an over-large circuit.
     * @param {Uint8Array} wqc
     */
    constructor(wqc) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(wqc, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.quantumsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            QuantumSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Per-basis-state measurement probabilities (`|amp|^2`, normalized) —
     * **display only**; the hash is the contract, this is for the bar chart.
     * Derived from the integer `prob_weights`, so it is itself deterministic.
     * @returns {Float64Array}
     */
    probabilities() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumsink_probabilities(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {bigint}
     */
    seed() {
        const ret = wasm.quantumsink_seed(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Sampled shot counts per basis state at the pinned `(seed, shots)` — the
     * deterministic `splitmix64` sampler, for the measured-histogram view.
     * @returns {Uint32Array}
     */
    shot_counts() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumsink_shot_counts(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {bigint}
     */
    shots() {
        const ret = wasm.quantumsink_shots(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * The portable statevector hash — what statevector-equivalence is defined
     * over. Matches the native reference byte-for-byte on every machine.
     * @returns {string}
     */
    statevector_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.quantumsink_statevector_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) QuantumSink.prototype[Symbol.dispose] = QuantumSink.prototype.free;

export class RabiDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RabiDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_rabidemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    estimate() {
        const ret = wasm.rabidemo_estimate(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rabidemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Tune a simulated qubit whose true π-amplitude is `a_pi_true` (hidden from
     * the calibrator), sweeping `[0, a_max]` with `shots` per point.
     * @param {number} a_pi_true
     * @param {number} seed
     * @param {number} a_max
     * @param {number} shots
     */
    constructor(a_pi_true, seed, a_max, shots) {
        const ret = wasm.rabidemo_new(a_pi_true, seed, a_max, shots);
        this.__wbg_ptr = ret;
        RabiDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    quality() {
        const ret = wasm.rabidemo_quality(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rabidemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.rabidemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Float64Array}
     */
    sweep_x() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rabidemo_sweep_x(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    sweep_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rabidemo_sweep_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    truth() {
        const ret = wasm.rabidemo_truth(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) RabiDemo.prototype[Symbol.dispose] = RabiDemo.prototype.free;

export class RamseyDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RamseyDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_ramseydemo_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ramseydemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} omega_true
     * @param {number} t2_true
     * @param {number} seed
     * @param {number} tau_max
     * @param {number} shots
     */
    constructor(omega_true, t2_true, seed, tau_max, shots) {
        const ret = wasm.ramseydemo_new(omega_true, t2_true, seed, tau_max, shots);
        this.__wbg_ptr = ret;
        RamseyDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    omega_est() {
        const ret = wasm.ramseydemo_omega_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    omega_truth() {
        const ret = wasm.ramseydemo_omega_truth(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ramseydemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.ramseydemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Float64Array}
     */
    sweep_x() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ramseydemo_sweep_x(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    sweep_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ramseydemo_sweep_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    t2_est() {
        const ret = wasm.ramseydemo_t2_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    t2_truth() {
        const ret = wasm.ramseydemo_t2_truth(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) RamseyDemo.prototype[Symbol.dispose] = RamseyDemo.prototype.free;

export class RbDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RbDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_rbdemo_free(ptr, 0);
    }
    /**
     * @returns {Float64Array}
     */
    curve_x() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rbdemo_curve_x(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    curve_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rbdemo_curve_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    fidelity_est() {
        const ret = wasm.rbdemo_fidelity_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * The hidden true fidelity `F = 1 − ε`.
     * @returns {number}
     */
    fidelity_truth() {
        const ret = wasm.rbdemo_fidelity_truth(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rbdemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} epsilon_true
     * @param {number} seed
     */
    constructor(epsilon_true, seed) {
        const ret = wasm.rbdemo_new(epsilon_true, seed);
        this.__wbg_ptr = ret;
        RbDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    p_est() {
        const ret = wasm.rbdemo_p_est(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rbdemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.rbdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) RbDemo.prototype[Symbol.dispose] = RbDemo.prototype.free;

export class ReadoutDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ReadoutDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_readoutdemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    fidelity() {
        const ret = wasm.readoutdemo_fidelity(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutdemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {number} s0
     * @param {number} s1
     * @param {number} sigma
     * @param {number} seed
     * @param {number} n
     */
    constructor(s0, s1, sigma, seed, n) {
        const ret = wasm.readoutdemo_new(s0, s1, sigma, seed, n);
        this.__wbg_ptr = ret;
        ReadoutDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {Float64Array}
     */
    ones() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutdemo_ones(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutdemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.readoutdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    threshold() {
        const ret = wasm.readoutdemo_threshold(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {Float64Array}
     */
    zeros() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutdemo_zeros(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) ReadoutDemo.prototype[Symbol.dispose] = ReadoutDemo.prototype.free;

export class ReadoutMitigateDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ReadoutMitigateDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_readoutmitigatedemo_free(ptr, 0);
    }
    /**
     * Corrected quasi-probability per bitstring (after A⁻¹).
     * @returns {Float64Array}
     */
    corrected() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutmitigatedemo_corrected(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    ideal() {
        const ret = wasm.readoutmitigatedemo_ideal(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string[]}
     */
    labels() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutmitigatedemo_labels(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayJsValueFromWasm0(r0, r1);
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Measured probability per bitstring (before correction).
     * @returns {Float64Array}
     */
    measured() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutmitigatedemo_measured(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    mitigated() {
        const ret = wasm.readoutmitigatedemo_mitigated(this.__wbg_ptr);
        return ret;
    }
    /**
     * Content hash of the pinned readout model (the noise model the receipt binds).
     * @returns {string}
     */
    model_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutmitigatedemo_model_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    n_qubits() {
        const ret = wasm.readoutmitigatedemo_n_qubits(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Negativity of the corrected distribution (0 = stayed physical).
     * @returns {number}
     */
    negativity() {
        const ret = wasm.readoutmitigatedemo_negativity(this.__wbg_ptr);
        return ret;
    }
    /**
     * Mitigate readout error on an `n`-qubit GHZ-like state (½ on |0…0⟩, ½ on
     * |1…1⟩) for the parity observable `Z^{⊗n}`. Each qubit misassigns `0→1`
     * with rate `p10` and `1→0` with rate `p01`. `shots` sampled from the
     * symmetric readout model; `A⁻¹` inverts it.
     * @param {number} n_qubits
     * @param {number} p01
     * @param {number} p10
     * @param {number} shots
     * @param {number} seed
     */
    constructor(n_qubits, p01, p10, shots, seed) {
        const ret = wasm.readoutmitigatedemo_new(n_qubits, p01, p10, shots, seed);
        this.__wbg_ptr = ret;
        ReadoutMitigateDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    raw() {
        const ret = wasm.readoutmitigatedemo_raw(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.readoutmitigatedemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.readoutmitigatedemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) ReadoutMitigateDemo.prototype[Symbol.dispose] = ReadoutMitigateDemo.prototype.free;

export class RearrangeDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RearrangeDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_rearrangedemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    atoms_loaded() {
        const ret = wasm.rearrangedemo_atoms_loaded(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    atoms_moved() {
        const ret = wasm.rearrangedemo_atoms_moved(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    feasible() {
        const ret = wasm.rearrangedemo_feasible(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    h() {
        const ret = wasm.rearrangedemo_h(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {string}
     */
    initial_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rearrangedemo_initial_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Moves flattened `[from0,to0,from1,to1,…]`.
     * @returns {Uint32Array}
     */
    moves_flat() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rearrangedemo_moves_flat(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Load a `w × h` array at `fill_permille`/1000 occupancy and rearrange into a
     * centered `tw × th` defect-free target register.
     * @param {number} w
     * @param {number} h
     * @param {number} fill_permille
     * @param {number} tw
     * @param {number} th
     * @param {number} seed
     */
    constructor(w, h, fill_permille, tw, th, seed) {
        const ret = wasm.rearrangedemo_new(w, h, fill_permille, tw, th, seed);
        this.__wbg_ptr = ret;
        RearrangeDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Indices of initially-occupied sites.
     * @returns {Uint32Array}
     */
    occupied_initial() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rearrangedemo_occupied_initial(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    plan_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rearrangedemo_plan_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rearrangedemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.rearrangedemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Discard the demo's solve and re-solve (identical) — exposes the pure solver
     * for a benchmark button if needed.
     * @returns {number}
     */
    resolve_distance() {
        const ret = wasm.rearrangedemo_resolve_distance(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    sites() {
        const ret = wasm.rearrangedemo_sites(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    success() {
        const ret = wasm.rearrangedemo_success(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {boolean}
     */
    tamper_success() {
        const ret = wasm.rearrangedemo_tamper_success(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Target sites occupied after the plan (defect-free ⇒ = target_size).
     * @returns {number}
     */
    target_fill_after() {
        const ret = wasm.rearrangedemo_target_fill_after(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Target sites already occupied in the raw load (the stochastic yield).
     * @returns {number}
     */
    target_fill_before() {
        const ret = wasm.rearrangedemo_target_fill_before(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Target site indices.
     * @returns {Uint32Array}
     */
    target_sites() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rearrangedemo_target_sites(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    target_size() {
        const ret = wasm.rearrangedemo_target_size(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    total_distance() {
        const ret = wasm.rearrangedemo_total_distance(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    w() {
        const ret = wasm.rearrangedemo_w(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) RearrangeDemo.prototype[Symbol.dispose] = RearrangeDemo.prototype.free;

export class ReelSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ReelSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_reelsink_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    audio_mixdown_hash_hex() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_audio_mixdown_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * The soundtrack's canonical `i16` PCM mixdown — what a Web Audio buffer
     * plays, and the mixdown-equivalence quantity.
     * @returns {Int16Array}
     */
    audio_pcm() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_audio_pcm(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v1 = getArrayI16FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 2, 2);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    audio_sample_rate() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_audio_sample_rate(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 >>> 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Interpolated camera pose at global frame `f`: 8 f32 `[px,py,pz,
     * qx,qy,qz,qw, fov]`.
     * @param {bigint} f
     * @returns {Float32Array}
     */
    camera(f) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_camera(retptr, this.__wbg_ptr, f);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {bigint} f
     * @returns {bigint}
     */
    frame_tick(f) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_frame_tick(retptr, this.__wbg_ptr, f);
            var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            return BigInt.asUintN(64, r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Merkle root over the per-frame `BLAKE3(world_state_hash || camera_pose)`
     * blocks — the reel-equivalence quantity (validates the world as a side
     * effect).
     * @returns {string}
     */
    frames_root_hex() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_frames_root_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    has_audio() {
        const ret = wasm.reelsink_has_audio(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @param {Uint8Array} wrel
     */
    constructor(wrel) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(wrel, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.reelsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            ReelSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    reel_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_reel_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {bigint}
     */
    samples_per_frame() {
        const ret = wasm.reelsink_samples_per_frame(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {number}
     */
    shots() {
        const ret = wasm.reelsink_shots(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {bigint}
     */
    total_frames() {
        const ret = wasm.reelsink_total_frames(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {Uint8Array}
     */
    world_bytes() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_world_bytes(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    world_sim() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.reelsink_world_sim(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) ReelSink.prototype[Symbol.dispose] = ReelSink.prototype.free;

/**
 * One component of a WAI2 envelope. `payload` is the codec bytes the handler
 * for `capability` consumes.
 */
export class Rendition {
    static __wrap(ptr) {
        const obj = Object.create(Rendition.prototype);
        obj.__wbg_ptr = ptr;
        RenditionFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RenditionFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_rendition_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    get capability() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rendition_capability(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    get kind() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rendition_kind(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {Uint8Array}
     */
    get payload() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.rendition_payload(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get payload_len() {
        const ret = wasm.rendition_payload_len(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) Rendition.prototype[Symbol.dispose] = Rendition.prototype.free;

export class RobustDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RobustDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_robustdemo_free(ptr, 0);
    }
    /**
     * @returns {Float64Array}
     */
    eps_axis() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustdemo_eps_axis(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustdemo_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    improvement() {
        const ret = wasm.robustdemo_improvement(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {Float64Array}
     */
    naive_infid() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustdemo_naive_infid(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {number} err_max
     * @param {number} n_eps
     */
    constructor(err_max, n_eps) {
        const ret = wasm.robustdemo_new(err_max, n_eps);
        this.__wbg_ptr = ret;
        RobustDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    phi_deg() {
        const ret = wasm.robustdemo_phi_deg(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.robustdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Float64Array}
     */
    robust_infid() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustdemo_robust_infid(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    worst_naive() {
        const ret = wasm.robustdemo_worst_naive(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    worst_robust() {
        const ret = wasm.robustdemo_worst_robust(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) RobustDemo.prototype[Symbol.dispose] = RobustDemo.prototype.free;

export class RobustFFDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RobustFFDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_robustffdemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    chi_cpmg() {
        const ret = wasm.robustffdemo_chi_cpmg(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    chi_opt() {
        const ret = wasm.robustffdemo_chi_opt(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    coh_cpmg() {
        const ret = wasm.robustffdemo_coh_cpmg(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    coh_opt() {
        const ret = wasm.robustffdemo_coh_opt(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    improvement() {
        const ret = wasm.robustffdemo_improvement(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {Float64Array}
     */
    kern_cpmg() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_kern_cpmg(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    kern_opt() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_kern_opt(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    n_pulses() {
        const ret = wasm.robustffdemo_n_pulses(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Reshape an `n`-pulse DD sequence to minimise the filter overlap against a
     * `1/f + bump` PSD whose bump sits right under equal-spaced CPMG's passband.
     * @param {number} n
     * @param {number} seed
     */
    constructor(n, seed) {
        const ret = wasm.robustffdemo_new(n, seed);
        this.__wbg_ptr = ret;
        RobustFFDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {Float64Array}
     */
    omega() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_omega(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    psd() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_psd(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Equal-spaced CPMG pulse positions (in [0,1]).
     * @returns {Float64Array}
     */
    pulses_cpmg() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_pulses_cpmg(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The optimised (reshaped) pulse positions.
     * @returns {Float64Array}
     */
    pulses_opt() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_pulses_opt(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.robustffdemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.robustffdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) RobustFFDemo.prototype[Symbol.dispose] = RobustFFDemo.prototype.free;

export class ScoreSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ScoreSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_scoresink_free(ptr, 0);
    }
    /**
     * @returns {bigint}
     */
    duration() {
        const ret = wasm.scoresink_duration(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * The canonical mono `i16` PCM — the mixdown-equivalence quantity,
     * and the samples a Web Audio buffer plays.
     * @returns {Int16Array}
     */
    mixdown() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.scoresink_mixdown(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayI16FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 2, 2);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    mixdown_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.scoresink_mixdown_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @param {Uint8Array} wscr
     */
    constructor(wscr) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(wscr, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.scoresink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            ScoreSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    note_count() {
        const ret = wasm.scoresink_note_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Per-note display rows for a piano-roll view: 4 f32 per note —
     * `[start, dur, pitch_norm, gain]` where `pitch_norm` is derived
     * from the phase increment (∝ log frequency) for vertical placement.
     * @returns {Float32Array}
     */
    notes() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.scoresink_notes(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    sample_rate() {
        const ret = wasm.scoresink_sample_rate(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {string}
     */
    score_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.scoresink_score_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) ScoreSink.prototype[Symbol.dispose] = ScoreSink.prototype.free;

/**
 * The artifact a sealed session yields: a `wai.world.replay` payload
 * and its §8 session receipt. The replay re-derives every frame; the
 * receipt is the signed, energy-accounted record over the op batches.
 */
export class SealedSession {
    static __wrap(ptr) {
        const obj = Object.create(SealedSession.prototype);
        obj.__wbg_ptr = ptr;
        SealedSessionFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SealedSessionFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_sealedsession_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    final_hash() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sealedsession_final_hash(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {bigint}
     */
    final_tick() {
        const ret = wasm.sealedsession_final_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {number}
     */
    leaf_count() {
        const ret = wasm.sealedsession_leaf_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * This receipt's stable id — the next seal in the world's timeline
     * names it as its parent.
     * @returns {string}
     */
    receipt_hash() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sealedsession_receipt_hash(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sealedsession_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The `wai.world.replay` WWLD bytes — download as `.wwld`, it
     * re-opens in this very sink and verifies its own seal.
     * @returns {Uint8Array}
     */
    replay_bytes() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sealedsession_replay_bytes(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    root_hash() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sealedsession_root_hash(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Exact deterministic node-steps simulated (the signed work figure).
     * @returns {bigint}
     */
    work_steps() {
        const ret = wasm.sealedsession_work_steps(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {string}
     */
    world_hash() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sealedsession_world_hash(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) SealedSession.prototype[Symbol.dispose] = SealedSession.prototype.free;

/**
 * One session at this sink, recorded as it happens and sealed as a `reconstruct-session`
 * claim (`wai::session_recorder::SessionRecorder`).
 */
export class SessionHandle {
    static __wrap(ptr) {
        const obj = Object.create(SessionHandle.prototype);
        obj.__wbg_ptr = ptr;
        SessionHandleFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SessionHandleFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_sessionhandle_free(ptr, 0);
    }
    /**
     * The handle of the decoder that decoded `envelope` here, through `via` (its
     * manifest's capability where absent; otherwise that capability or its fallback, and
     * any other is refused); `pinned` when the decode verified the parameter set the
     * manifest pins; `first_unit`, which the page states, the title's unit that is unit 0
     * of the object's base (of the object for a base, of the base it refines for a layer).
     * The recorder holds the envelopes, so a `first_unit` that is not a layer's base's, or
     * that puts a presentation outside the units its envelope covers, is refused when the
     * session is sealed. The same decoder on the same object gives the same handle.
     * @param {Uint8Array} envelope
     * @param {string | null | undefined} via
     * @param {boolean} pinned
     * @param {number} first_unit
     * @returns {number}
     */
    decoderFor(envelope, via, pinned, first_unit) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            var ptr1 = isLikeNone(via) ? 0 : passStringToWasm0(via, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            var len1 = WASM_VECTOR_LEN;
            wasm.sessionhandle_decoderFor(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, pinned, first_unit);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 >>> 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Seal the session, about its entry object: the key from the 32-byte `seed_hex`;
     * `signer_id` the key's `did:key` where absent; `issued_at` an RFC 3339 time. Gives
     * `{claim, link_hash, outputs, objects}`: the claim's wire form (JCS) and what
     * `verifyClaim` checks it against. The recorder checks the claim against what it
     * recorded first — the presentations, the objects and the envelopes it holds — and
     * refuses one a verifier holding them would refuse. A handle seals once.
     * @param {string} seed_hex
     * @param {string | null | undefined} signer_id
     * @param {string} issued_at
     * @returns {any}
     */
    finish(seed_hex, signer_id, issued_at) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            var ptr1 = isLikeNone(signer_id) ? 0 : passStringToWasm0(signer_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            var len1 = WASM_VECTOR_LEN;
            const ptr2 = passStringToWasm0(issued_at, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len2 = WASM_VECTOR_LEN;
            wasm.sessionhandle_finish(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * A presentation: `unit` at `layers` (1 for the base alone), through the decoder
     * `decoder` names, the SHA-256 of its output's canonical buffer, and how late it was
     * where it missed the session's deadline.
     * @param {number} unit
     * @param {number} layers
     * @param {number} decoder
     * @param {string} out_digest_hex
     * @param {number | null} [late_us]
     */
    presented(unit, layers, decoder, out_digest_hex, late_us) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(out_digest_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.sessionhandle_presented(retptr, this.__wbg_ptr, unit, layers, decoder, ptr0, len0, !isLikeNone(late_us), isLikeNone(late_us) ? 0 : late_us);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * An object received whole on the primary path, as its bytes — every object the page
     * received, presented or not, and one it refused too: an envelope whose payloads are
     * encrypted, or bytes that are not an envelope at all, are recorded as an object
     * neither counted nor presented, so the session accounts for every byte transferred.
     * The recorder derives its figures, and whether a decoder entry names it, and holds
     * it, so `finish` checks the claim against it. An encrypted envelope's manifest and
     * rendition table are in the clear: a `WAI2` envelope's classical rendition, encrypted
     * or not, counts in the classical length `finish` derives from the envelopes held
     * (jwp-receipts §2.4.12 rule 9), which the page never states. Received again, it is one
     * object with the bytes of both.
     * @param {Uint8Array} envelope
     */
    received(envelope) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.sessionhandle_received(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) SessionHandle.prototype[Symbol.dispose] = SessionHandle.prototype.free;

export class ShadowDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ShadowDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_shadowdemo_free(ptr, 0);
    }
    /**
     * @returns {Float64Array}
     */
    conv_est() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.shadowdemo_conv_est(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Uint32Array}
     */
    conv_n() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.shadowdemo_conv_n(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    error() {
        const ret = wasm.shadowdemo_error(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    estimate() {
        const ret = wasm.shadowdemo_estimate(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    input_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.shadowdemo_input_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    n_snapshots() {
        const ret = wasm.shadowdemo_n_snapshots(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Estimate ⟨X₀ Y₁ Z₂⟩ of a hidden 3-qubit product state from `n_snapshots`
     * randomized single-qubit Pauli measurements, via the classical-shadows
     * inverse channel with a 10-batch median-of-means. Reports a convergence
     * curve so you can watch the estimate approach the (hidden) truth.
     * @param {number} seed
     * @param {number} n_snapshots
     */
    constructor(seed, n_snapshots) {
        const ret = wasm.shadowdemo_new(seed, n_snapshots);
        this.__wbg_ptr = ret;
        ShadowDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {number}
     */
    raw() {
        const ret = wasm.shadowdemo_raw(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.shadowdemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.shadowdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    truth() {
        const ret = wasm.shadowdemo_truth(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) ShadowDemo.prototype[Symbol.dispose] = ShadowDemo.prototype.free;

/**
 * A skeletal signing actor in the browser. The page supplies 32 random
 * bytes; the key never leaves the tab — only signed ops do. Each op is a
 * `CausalOp` a native sink would ingest, identical to the worlds path.
 */
export class SkeletalActor {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SkeletalActorFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_skeletalactor_free(ptr, 0);
    }
    /**
     * @param {Uint8Array} seed
     */
    constructor(seed) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.skeletalactor_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            SkeletalActorFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Lamport discipline: the counter MUST exceed every observed lamport.
     * @param {bigint} lamport
     */
    observe_lamport(lamport) {
        wasm.skeletalactor_observe_lamport(this.__wbg_ptr, lamport);
    }
    /**
     * @returns {string}
     */
    pubkey_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalactor_pubkey_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Sign a CREATE for a bone with the given local TRS, parented to
     * `parent_id` (16 bytes; all-zero = root). The bone id is minted
     * deterministically from `(actor, lamport)` and returned so the page
     * can animate it. Authoring floats → Q32.32 here, once.
     * @param {bigint} effect_tick
     * @param {Uint8Array} parent_id
     * @param {number} tx
     * @param {number} ty
     * @param {number} tz
     * @param {number} qx
     * @param {number} qy
     * @param {number} qz
     * @param {number} qw
     * @returns {CreatedBone}
     */
    sign_create_bone(effect_tick, parent_id, tx, ty, tz, qx, qy, qz, qw) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(parent_id, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.skeletalactor_sign_create_bone(retptr, this.__wbg_ptr, effect_tick, ptr0, len0, tx, ty, tz, qx, qy, qz, qw);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return CreatedBone.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Sign a SET_ROTATION for `bone_id` (16 bytes) at `effect_tick`.
     * @param {bigint} effect_tick
     * @param {Uint8Array} bone_id
     * @param {number} qx
     * @param {number} qy
     * @param {number} qz
     * @param {number} qw
     * @returns {Uint8Array}
     */
    sign_set_rotation(effect_tick, bone_id, qx, qy, qz, qw) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bone_id, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.skeletalactor_sign_set_rotation(retptr, this.__wbg_ptr, effect_tick, ptr0, len0, qx, qy, qz, qw);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) SkeletalActor.prototype[Symbol.dispose] = SkeletalActor.prototype.free;

export class SkeletalSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SkeletalSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_skeletalsink_free(ptr, 0);
    }
    /**
     * @param {bigint} tick
     */
    advance_to(tick) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_advance_to(retptr, this.__wbg_ptr, tick);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    bone_count() {
        const ret = wasm.skeletalsink_bone_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Bone segments, 6 f32 each (`[x1,y1,z1, x2,y2,z2]` = parent-joint →
     * this-joint), one per bone that has a present parent — the skeleton
     * wireframe.
     * @returns {Float32Array}
     */
    bones() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_bones(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {bigint}
     */
    current_tick() {
        const ret = wasm.skeletalsink_current_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {bigint}
     */
    final_tick() {
        const ret = wasm.skeletalsink_final_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @param {Uint8Array} bytes
     */
    ingest_op(bytes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.skeletalsink_ingest_op(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * World-space joint positions, 3 f32 per bone (`[x, y, z]`), bones
     * in canonical node-id order — the FK composition of the hashed
     * local transforms (presentation: f32, never the state). The pose
     * is exact `Fx`; only this display projection is float.
     * @returns {Float32Array}
     */
    joints() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_joints(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Open WWLD avatar bytes. A seal, if present, is lifted out for
     * `verify_seal`; playback runs the live engine.
     * @param {Uint8Array} bytes
     */
    constructor(bytes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.skeletalsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            SkeletalSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * BLAKE3 pose hash at the current tick — the quantity
     * pose-equivalence is defined over (the per-bone local transforms),
     * computed by the corpus-generating code.
     * @returns {string}
     */
    pose_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_pose_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string | undefined}
     */
    seal_hash_hex() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_seal_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    sim() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_sim(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Replay to the sealed final tick and compare hashes. `true` = this
     * browser re-derived the publisher's exact pose.
     * @returns {boolean}
     */
    verify_seal() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.skeletalsink_verify_seal(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 !== 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) SkeletalSink.prototype[Symbol.dispose] = SkeletalSink.prototype.free;

export class SpectroDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SpectroDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_spectrodemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    error() {
        const ret = wasm.spectrodemo_error(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    mean_psd() {
        const ret = wasm.spectrodemo_mean_psd(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {number}
     */
    n_sequences() {
        const ret = wasm.spectrodemo_n_sequences(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Reconstruct a hidden `1/f + Lorentzian-bump` PSD from a bank of CPMG
     * filters, each a narrow-band probe. `seed` varies the sampling noise.
     * @param {number} seed
     */
    constructor(seed) {
        const ret = wasm.spectrodemo_new(seed);
        this.__wbg_ptr = ret;
        SpectroDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {Float64Array}
     */
    omega() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.spectrodemo_omega(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    psd_est() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.spectrodemo_psd_est(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {Float64Array}
     */
    psd_true() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.spectrodemo_psd_true(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.spectrodemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.spectrodemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) SpectroDemo.prototype[Symbol.dispose] = SpectroDemo.prototype.free;

export class Splat4dSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        Splat4dSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_splat4dsink_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    clip_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.splat4dsink_clip_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The reconstructed cloud at `frame`: 14 f32 per Gaussian —
     * `[x,y,z, sx,sy,sz, qx,qy,qz,qw, r,g,b,a]`. The render's job is the
     * sink's; this is the verified state, projected to f32 for the GPU.
     * @param {bigint} frame
     * @returns {Float32Array}
     */
    frame(frame) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.splat4dsink_frame(retptr, this.__wbg_ptr, frame);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Frame-state-equivalence quantity at `frame` — the BLAKE3 of the
     * reconstructed Gaussian set, computed by the corpus-generating code.
     * @param {bigint} frame
     * @returns {string}
     */
    frame_hash_hex(frame) {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.splat4dsink_frame_hash_hex(retptr, this.__wbg_ptr, frame);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    frame_rate() {
        const ret = wasm.splat4dsink_frame_rate(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {bigint}
     */
    n_frames() {
        const ret = wasm.splat4dsink_n_frames(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {number}
     */
    n_gaussians() {
        const ret = wasm.splat4dsink_n_gaussians(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @param {Uint8Array} w4ds
     */
    constructor(w4ds) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(w4ds, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.splat4dsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            Splat4dSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) Splat4dSink.prototype[Symbol.dispose] = Splat4dSink.prototype.free;

/**
 * A base, ready for a sink: its info (content hash, the capability it was decoded
 * through, whether through a fallback, its tier, whether the sink verified a delivery
 * receipt for it, the live position of its unit 0) and its units.
 *
 * A base is **decoded** ([`StageBase::decode`]: the reference decode ran here, so its
 * units and tier are the decode's) or **claimed** ([`StageBase::from_stage0`]: the page
 * supplied its units, and nothing here checked them against the envelope). A claimed
 * base's tier is never above what its capability gives a base with no resolved pin,
 * and every unit, report and stage hash of its chain says `claimed`: a stage hash of a
 * claimed chain is the hash of what the page supplied and the layers applied to it,
 * not evidence that the envelope decodes to it.
 */
export class StageBase {
    static __wrap(ptr) {
        const obj = Object.create(StageBase.prototype);
        obj.__wbg_ptr = ptr;
        StageBaseFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        StageBaseFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_stagebase_free(ptr, 0);
    }
    /**
     * Whether the sink verified a delivery receipt for the base (§10).
     * @returns {boolean}
     */
    get attested() {
        const ret = wasm.stagebase_attested(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {string}
     */
    get capability() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagebase_capability(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Whether the page supplied this base's units ([`StageBase::from_stage0`]).
     * @returns {boolean}
     */
    get claimed() {
        const ret = wasm.stagebase_claimed(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * The base envelope's content hash, lowercase hex.
     * @returns {string}
     */
    get contentHash() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagebase_contentHash(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Decode a base envelope by SPEC §4 through the integer path
     * (`wai::staged::decode_base_via`). `set` maps each parameter file's name (as SPEC
     * §5 names it) to its bytes, and is absent for a capability that reads none
     * (`wai.video.int_motion`); the envelope's pin is verified against those bytes.
     * `via` is the capability to decode through: absent to run §4 (the manifest's
     * capability, then its fallback), or one of those two. `limit` is required: the
     * page's cost limit, `{output_bytes, symbols, working_bytes, macs}` (`macs`
     * optional), or `null` for the payload format's caps only; leaving it out is an
     * error, so a page never decodes unbounded by accident. The limit binds a base
     * whose capability declares a cost before decoding (the integer payloads SPEC §5
     * pins: `WIV1`, `WIH1`, `WIA1`, `WIS1`), checked before any symbol is decoded or
     * any output allocated (`cost_over_limit`); a capability that declares no cost
     * (`wai.neural.int_synth`, `wai.neural.int_mlicpp`) decodes under its format's caps
     * whatever the limit. No key log is held here, so SPEC §3.1's check 5 is not run.
     * A refusal's message starts with its code.
     * @param {Uint8Array} envelope
     * @param {Map<any, any> | null | undefined} set
     * @param {string | null | undefined} via
     * @param {any} limit
     * @returns {StageBase}
     */
    static decode(envelope, set, via, limit) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            var ptr1 = isLikeNone(via) ? 0 : passStringToWasm0(via, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            var len1 = WASM_VECTOR_LEN;
            wasm.stagebase_decode(retptr, ptr0, len0, isLikeNone(set) ? 0 : addHeapObject(set), ptr1, len1, addHeapObject(limit));
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return StageBase.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The live clock position of the base's unit 0 (§8).
     * @returns {number}
     */
    get firstUnit() {
        const ret = wasm.stagebase_firstUnit(this.__wbg_ptr);
        return ret;
    }
    /**
     * A base the page decoded elsewhere (a codec this build does not run, or a
     * fixture): its envelope, the capability it was decoded through (the manifest's
     * capability, or its fallback, which makes it decoded through a fallback), the
     * tier the page claims for that step (`decode-equivalence`, `entropy-consistency`
     * or `none`; lowered to what the capability gives a base with no resolved pin),
     * and its units as their canonical buffers concatenated, `shapes` holding three
     * dimensions per unit and `elem` `u8` or `i16`. The base is **claimed**.
     * @param {Uint8Array} envelope
     * @param {string} capability
     * @param {string} tier_token
     * @param {Uint32Array} shapes
     * @param {string} elem
     * @param {Uint8Array} stage0
     * @returns {StageBase}
     */
    static fromStage0(envelope, capability, tier_token, shapes, elem, stage0) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            const ptr2 = passStringToWasm0(tier_token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len2 = WASM_VECTOR_LEN;
            const ptr3 = passArray32ToWasm0(shapes, wasm.__wbindgen_export);
            const len3 = WASM_VECTOR_LEN;
            const ptr4 = passStringToWasm0(elem, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len4 = WASM_VECTOR_LEN;
            const ptr5 = passArray8ToWasm0(stage0, wasm.__wbindgen_export);
            const len5 = WASM_VECTOR_LEN;
            wasm.stagebase_fromStage0(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return StageBase.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get nUnits() {
        const ret = wasm.stagebase_nUnits(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Set the live clock position of the base's unit 0: a non-negative integer.
     * @param {number} v
     */
    setFirstUnit(v) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagebase_setFirstUnit(retptr, this.__wbg_ptr, v);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Record that the sink verified a delivery receipt for the base (§10): from then
     * on its layers need `delivered-verified` evidence. A verified receipt is never
     * unverified, so `false` changes nothing.
     * @param {boolean} v
     */
    set attested(v) {
        wasm.stagebase_set_attested(this.__wbg_ptr, v);
    }
    /**
     * The units' canonical buffers concatenated, in unit order (SPEC §7 *Digests*).
     * @returns {Uint8Array}
     */
    stage0() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagebase_stage0(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    get tier() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagebase_tier(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Whether the base was decoded through its manifest's fallback (§4.1 step 3
     * refuses its layers). Read-only: the decode, or the capability a claimed base
     * names, decides it.
     * @returns {boolean}
     */
    get viaFallback() {
        const ret = wasm.stagebase_viaFallback(this.__wbg_ptr);
        return ret !== 0;
    }
}
if (Symbol.dispose) StageBase.prototype[Symbol.dispose] = StageBase.prototype.free;

/**
 * A staged-delivery sink: `wai::staged::StageSink`. Every method that decides returns
 * the reports of that step, an array in the corpus's form; a unit is read back by its
 * base's content hash (hex) and its index. A report, a base's units and a stage hash
 * from the chain of a claimed base carry `claimed: true` (see [`StageBase`]).
 */
export class StageSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        StageSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_stagesink_free(ptr, 0);
    }
    /**
     * Add a base, which releases the layers held for it (§4.4). The base is moved
     * into the sink: the JS object is spent. A base the sink already holds is kept as
     * it is. A base whose units' output passes the chain budget is not added: its one
     * report refuses its envelope `chain-over-limit` (§4.5).
     * @param {StageBase} base
     * @returns {any}
     */
    addBase(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            _assertClass(base, StageBase);
            var ptr0 = base.__destroy_into_raw();
            wasm.stagesink_addBase(retptr, this.__wbg_ptr, ptr0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The base's clip hash as `{sha256, claimed}`, or `undefined` unless every unit
     * holds `decode-equivalence`.
     * @param {string} base
     * @returns {any}
     */
    clipSha256(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_clipSha256(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Discard what has been held past the bound at `now_ms` (§4.3).
     * @param {number} now_ms
     * @returns {any}
     */
    expire(now_ms) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagesink_expire(retptr, this.__wbg_ptr, now_ms);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Discard what the sink keeps of a base it does not hold (§14).
     * @param {string} base
     * @returns {boolean}
     */
    forgetBase(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_forgetBase(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 !== 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Whether the sink holds the base.
     * @param {string} base
     * @returns {boolean}
     */
    hasBase(base) {
        const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.stagesink_hasBase(this.__wbg_ptr, ptr0, len0);
        return ret !== 0;
    }
    /**
     * The envelopes held for the base's units, `[[object, unit], …]`.
     * @param {string} base
     * @returns {any}
     */
    held(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_held(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Whether the base's chain started from a claimed base.
     * @param {string} base
     * @returns {boolean}
     */
    isClaimed(base) {
        const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.stagesink_isClaimed(this.__wbg_ptr, ptr0, len0);
        return ret !== 0;
    }
    /**
     * The bytes the sink keeps of bases it does not hold (§4.4).
     * @returns {number}
     */
    keptBytes() {
        const ret = wasm.stagesink_keptBytes(this.__wbg_ptr);
        return ret;
    }
    /**
     * Record that the sink verified a delivery receipt for the base (§10).
     * @param {string} base
     */
    markAttested(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_markAttested(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {string} base
     * @returns {number}
     */
    nUnits(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_nUnits(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 >>> 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * A sink with the configuration `config`, in the form a corpus case states it:
     * `{bound: {max_envelopes, max_age_ms}, cost_limit, budget, record_budget, live}`
     * (`cost_limit` and `live` null or absent for none).
     * @param {any} config
     */
    constructor(config) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.stagesink_new(retptr, addHeapObject(config));
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            StageSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Offer the envelope `envelope` at `now_ms` with the receipt evidence `evidence`
     * (`delivered-verified`, `inclusion-verified` or `none`). Bytes that are not a
     * `WAI1` envelope, or one this sink cannot open, are an error whose message
     * starts with `not-wai1` or `encrypted`.
     * @param {Uint8Array} envelope
     * @param {number} now_ms
     * @param {string} evidence
     * @returns {any}
     */
    offer(envelope, now_ms, evidence) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passStringToWasm0(evidence, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            wasm.stagesink_offer(retptr, this.__wbg_ptr, ptr0, len0, now_ms, ptr1, len1);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Drop a base's chain (§4.4); its units' records are kept. `null` when the sink
     * holds no such base.
     * @param {string} base
     * @returns {any}
     */
    removeBase(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_removeBase(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The chain's state in bytes (§4.5).
     * @param {string} base
     * @returns {number}
     */
    stateBytes(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_stateBytes(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getFloat64(retptr + 8 * 0, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            return r0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The unit's current output, 8-bit samples (RGB8 for a picture). An error for a
     * unit of 16-bit samples.
     * @param {string} base
     * @param {number} u
     * @returns {Uint8Array}
     */
    unitBytes(base, u) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitBytes(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Whether the unit is frozen by a conflict (§4.1 step 7).
     * @param {string} base
     * @param {number} u
     * @returns {boolean}
     */
    unitFrozen(base, u) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitFrozen(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 !== 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The unit's current output, 16-bit samples, channels interleaved.
     * @param {string} base
     * @param {number} u
     * @returns {Int16Array}
     */
    unitPcm(base, u) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitPcm(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayI16FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 2, 2);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The content hash of the envelope that produced the unit's stage (the base at
     * stage 0).
     * @param {string} base
     * @param {number} u
     * @returns {string}
     */
    unitProducer(base, u) {
        let deferred3_0;
        let deferred3_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitProducer(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr2 = r0;
            var len2 = r1;
            if (r3) {
                ptr2 = 0; len2 = 0;
                throw takeObject(r2);
            }
            deferred3_0 = ptr2;
            deferred3_1 = len2;
            return getStringFromWasm0(ptr2, len2);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
        }
    }
    /**
     * The unit's stage hash (SHA-256 of its canonical buffer) as `{sha256, claimed}`,
     * or `undefined` unless the unit holds `decode-equivalence` (§5). `claimed` is true
     * where the chain started from a claimed base.
     * @param {string} base
     * @param {number} u
     * @returns {any}
     */
    unitSha256(base, u) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitSha256(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The unit's shape: rows, columns and channels of a picture.
     * @param {string} base
     * @param {number} u
     * @returns {Uint32Array}
     */
    unitShape(base, u) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitShape(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The squared error of the unit's current 8-bit output against `reference`,
     * summed exactly (a `BigInt`): the numerator of the page's PSNR.
     * @param {string} base
     * @param {number} u
     * @param {Uint8Array} reference
     * @returns {bigint}
     */
    unitSseU8(base, u, reference) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passArray8ToWasm0(reference, wasm.__wbindgen_export);
            const len1 = WASM_VECTOR_LEN;
            wasm.stagesink_unitSseU8(retptr, this.__wbg_ptr, ptr0, len0, u, ptr1, len1);
            var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            return BigInt.asUintN(64, r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {string} base
     * @param {number} u
     * @returns {number}
     */
    unitStage(base, u) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitStage(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 >>> 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @param {string} base
     * @param {number} u
     * @returns {string}
     */
    unitTier(base, u) {
        let deferred3_0;
        let deferred3_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_unitTier(retptr, this.__wbg_ptr, ptr0, len0, u);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr2 = r0;
            var len2 = r1;
            if (r3) {
                ptr2 = 0; len2 = 0;
                throw takeObject(r2);
            }
            deferred3_0 = ptr2;
            deferred3_1 = len2;
            return getStringFromWasm0(ptr2, len2);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
        }
    }
    /**
     * The base's units and clip hash, as the corpus states a base at the end of a case
     * (`{units: [{stage, producer, frozen, tier, shape, stage_sha256}], clip_sha256,
     * n_units}`), with `claimed: true` on the base and on each unit where its chain
     * started from a claimed base; `null` when the sink holds no such base.
     * @param {string} base
     * @returns {any}
     */
    units(base) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.stagesink_units(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) StageSink.prototype[Symbol.dispose] = StageSink.prototype.free;

export class ToricDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ToricDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_toricdemo_free(ptr, 0);
    }
    /**
     * @returns {boolean}
     */
    converged() {
        const ret = wasm.toricdemo_converged(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {Uint32Array}
     */
    correction_qubits() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.toricdemo_correction_qubits(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * True-error qubit ids (edges). Convention: id < L² is a horizontal edge at
     * (id/L, id%L); else a vertical edge at ((id−L²)/L, (id−L²)%L).
     * @returns {Uint32Array}
     */
    error_qubits() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.toricdemo_error_qubits(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    error_weight() {
        const ret = wasm.toricdemo_error_weight(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    iters() {
        const ret = wasm.toricdemo_iters(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    l() {
        const ret = wasm.toricdemo_l(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    legs() {
        const ret = wasm.toricdemo_legs(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {boolean}
     */
    logical_success() {
        const ret = wasm.toricdemo_logical_success(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * @returns {number}
     */
    messages() {
        const ret = wasm.toricdemo_messages(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    n() {
        const ret = wasm.toricdemo_n(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Decode one bit-flip error on the `L×L` toric code at physical rate `p`.
     * @param {number} l
     * @param {number} p
     * @param {number} seed
     */
    constructor(l, p, seed) {
        const ret = wasm.toricdemo_new(l, p, seed);
        this.__wbg_ptr = ret;
        ToricDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.toricdemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.toricdemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Unsatisfied plaquette (Z-check) indices; plaquette c is at (c/L, c%L).
     * @returns {Uint32Array}
     */
    syndrome_checks() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.toricdemo_syndrome_checks(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) ToricDemo.prototype[Symbol.dispose] = ToricDemo.prototype.free;

/**
 * Parsed WAI envelope returned to JS. The payload is a separate
 * Uint8Array so handlers can feed it straight into whatever decoder they
 * choose.
 */
export class WaiEnvelope {
    static __wrap(ptr) {
        const obj = Object.create(WaiEnvelope.prototype);
        obj.__wbg_ptr = ptr;
        WaiEnvelopeFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        WaiEnvelopeFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_waienvelope_free(ptr, 0);
    }
    /**
     * @returns {string}
     */
    get capability() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_capability(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The first static pin finding (SPEC §3.1, §7), or `undefined`.
     * @returns {string | undefined}
     */
    checkPin() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_checkPin(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * SPEC §4: the capability that decodes this envelope at a page that
     * advertises `advertised` and holds the parameter sets `held` (see
     * `verifyPin`); `undefined` when it is inert here — including when its
     * capability is companion-only, when its pin is refused and no fallback
     * remains, or when its manifest declares an encryption, which this page does not
     * open (SPEC §6.4 step 2).
     * @param {string[]} advertised
     * @param {any} held
     * @returns {string | undefined}
     */
    dispatchCapability(advertised, held) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayJsValueToWasm0(advertised, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.waienvelope_dispatchCapability(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(held));
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            let v2;
            if (r0 !== 0) {
                v2 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string | undefined}
     */
    get fallback() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_fallback(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    get intent() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_intent(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    get kind() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_kind(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The manifest JSON exactly as the envelope carries it.
     * @returns {string}
     */
    get manifest() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_manifest(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    get media() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_media(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Returns the payload bytes — the codec-specific bytes the
     * handler for `capability` knows how to consume.
     * @returns {Uint8Array}
     */
    get payload() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_payload(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    get payload_len() {
        const ret = wasm.waienvelope_payload_len(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * The pin (`conditioning.prior`) as JSON, or `undefined`.
     * @returns {string | undefined}
     */
    get prior() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waienvelope_prior(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) WaiEnvelope.prototype[Symbol.dispose] = WaiEnvelope.prototype.free;

/**
 * Parsed WAI2 envelope. Pick with `pick` (SPEC §7.1: component digests and pins
 * checked), present `rendition(index)`, and apply `companionsOf(index)` with it.
 */
export class WaiMulti {
    static __wrap(ptr) {
        const obj = Object.create(WaiMulti.prototype);
        obj.__wbg_ptr = ptr;
        WaiMultiFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        WaiMultiFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_waimulti_free(ptr, 0);
    }
    /**
     * The first static pin finding, `[index] reason: detail`, or `undefined`.
     * @returns {string | undefined}
     */
    checkPins() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_checkPins(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The companion at `i` (applied with a rendition, never on its own). Throws
     * unless the entry is a companion, and when its payload does not match its
     * `sha256` (`component_digest_mismatch`): such a companion is not applied.
     * @param {number} i
     * @returns {Rendition}
     */
    companion(i) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_companion(retptr, this.__wbg_ptr, i);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return Rendition.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The indexes of the companions to apply with the rendition at `index`.
     * @param {number} index
     * @returns {Uint32Array}
     */
    companionsOf(index) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_companionsOf(retptr, this.__wbg_ptr, index);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    get intent() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_intent(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    get manifest() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_manifest(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {string}
     */
    get media() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_media(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    get n_renditions() {
        const ret = wasm.waimulti_n_renditions(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * SPEC §7.1 selection at a page that advertises `advertised` and holds the
     * parameter sets `held`. Returns `{index, capability, kind, skipped: [[i,
     * reason], …]}`; throws, naming every entry's reason, when nothing is picked.
     * @param {string[]} advertised
     * @param {any} held
     * @returns {any}
     */
    pick(advertised, held) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayJsValueToWasm0(advertised, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.waimulti_pick(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(held));
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The rendition at `i`, to present as media. Throws for an index out of range,
     * for a component that is not a selectable rendition (a companion, or a
     * companion-only capability), which is never presented as media, and for one
     * whose payload does not match its `sha256` (`component_digest_mismatch`).
     * @param {number} i
     * @returns {Rendition}
     */
    rendition(i) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_rendition(retptr, this.__wbg_ptr, i);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return Rendition.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Every entry's members — `capability`, `kind`, and `id`, `sha256`, `prior`,
     * `role`, `companion_of`, `companion_of_id` when present — plus `selectable`.
     * @returns {any}
     */
    renditionsMeta() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.waimulti_renditionsMeta(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) WaiMulti.prototype[Symbol.dispose] = WaiMulti.prototype.free;

/**
 * A stateful integer world model: hold the transition `T` + synthesis `g_s`, carry
 * the latent state `z`, and advance it one action at a time — the live-play path.
 */
export class WorldModel {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        WorldModelFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_worldmodel_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    get framePx() {
        const ret = wasm.worldmodel_framePx(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Load the two WHM1 models (`world_T.bin`, `world_gs.bin`); `c`/`lat` from
     * `world.json`.
     * @param {Uint8Array} t_bin
     * @param {Uint8Array} gs_bin
     * @param {number} c
     * @param {number} lat
     */
    constructor(t_bin, gs_bin, c, lat) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(t_bin, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passArray8ToWasm0(gs_bin, wasm.__wbindgen_export);
            const len1 = WASM_VECTOR_LEN;
            wasm.worldmodel_new(retptr, ptr0, len0, ptr1, len1, c, lat);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            WorldModelFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Reset the world to an initial latent `z0` (`c·lat·lat` ints at `2^afrac`);
     * returns the rendered frame 0 (HWC RGB `u8`).
     * @param {Int32Array} z0
     * @returns {Uint8Array}
     */
    reset(z0) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray32ToWasm0(z0, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.worldmodel_reset(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v2 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Advance the integer transition by one `action` (index into the reference
     * action set: 0 stay, 1 +x, 2 −x, 3 +y, 4 −y) and render — pure i64, byte-exact.
     * @param {number} action
     * @returns {Uint8Array}
     */
    step(action) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldmodel_step(retptr, this.__wbg_ptr, action);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Advance the transition by raw `(dx, dy)` deltas and render — the shared-world
     * path (a merged multi-actor log decodes to a delta sequence via
     * [`replay_world_ops`]).
     * @param {number} dx
     * @param {number} dy
     * @returns {Uint8Array}
     */
    stepDelta(dx, dy) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldmodel_stepDelta(retptr, this.__wbg_ptr, dx, dy);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Advance the transition by an explicit set of action **planes** (length = the
     * model's `A`; values at `2^afrac`) and render — the multi-agent path, where a
     * step carries every agent's action (e.g. `[dxA,dyA,dxB,dyB]` for two agents).
     * @param {Int32Array} planes
     * @returns {Uint8Array}
     */
    stepPlanes(planes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray32ToWasm0(planes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.worldmodel_stepPlanes(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v2 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) WorldModel.prototype[Symbol.dispose] = WorldModel.prototype.free;

/**
 * The result of replaying a merged multi-actor action log: the convergent session
 * hash + the canonical `(dx, dy)` delta sequence to render.
 */
export class WorldReplay {
    static __wrap(ptr) {
        const obj = Object.create(WorldReplay.prototype);
        obj.__wbg_ptr = ptr;
        WorldReplayFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        WorldReplayFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_worldreplay_free(ptr, 0);
    }
    /**
     * Flattened `[dx0, dy0, dx1, dy1, …]` in canonical total order.
     * @returns {Int32Array}
     */
    get deltas() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldreplay_deltas(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayI32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    get sessionHash() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldreplay_sessionHash(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Per-op agent SLOT (the op's actor's index in canonical actor order) — so a
     * peer can place each op's `(dx,dy)` in its agent's plane lane for multi-agent
     * co-control. Same on every peer (the actor set + ordering is canonical).
     * @returns {Uint32Array}
     */
    get slots() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldreplay_slots(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) WorldReplay.prototype[Symbol.dispose] = WorldReplay.prototype.free;

/**
 * A `wai.world.*` sink. Construct from WWLD payload bytes (the cargo
 * of a `wai.world.scene` / `replay` / `live` envelope).
 */
export class WorldSink {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        WorldSinkFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_worldsink_free(ptr, 0);
    }
    /**
     * Step (or re-derive) the deterministic engine to `tick`.
     * @param {bigint} tick
     */
    advance_to(tick) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_advance_to(retptr, this.__wbg_ptr, tick);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Back-compat shim: `wai.mesh.glb` payload.
     * @param {string} name
     * @param {Uint8Array} envelope
     * @returns {Uint8Array}
     */
    asset_glb(name, envelope) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len1 = WASM_VECTOR_LEN;
            wasm.worldsink_asset_glb(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v3 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v3;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Verify a fetched asset envelope against the table and unwrap it
     * to the inner payload, requiring `expect_cap` (§4.1: a sink that
     * received mutated bytes MUST reject the content-hash mismatch).
     * The decode itself is the page's job — WAI dispatches, it does
     * not decode meshes or splats.
     * @param {string} name
     * @param {Uint8Array} envelope
     * @param {string} expect_cap
     * @returns {Uint8Array}
     */
    asset_payload(name, envelope, expect_cap) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
            const len1 = WASM_VECTOR_LEN;
            const ptr2 = passStringToWasm0(expect_cap, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len2 = WASM_VECTOR_LEN;
            wasm.worldsink_asset_payload(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v4 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v4;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * The asset table as JSON `[{hash, role, name}]` — the §4.1
     * content-addressed WAI objects this world names. The page fetches
     * each by `name`, verifies `hash` via [`Self::asset_glb`], decodes,
     * and binds it to a node for presentation.
     * @returns {string}
     */
    assets() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_assets(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {bigint}
     */
    checkpoint_every() {
        const ret = wasm.worldsink_checkpoint_every(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * @returns {bigint}
     */
    current_tick() {
        const ret = wasm.worldsink_current_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * The sealed final tick, or 0 for scene/live worlds.
     * @returns {bigint}
     */
    final_tick() {
        const ret = wasm.worldsink_final_tick(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Ingest one signed CausalOp (live worlds — the multiplayer path).
     * @param {Uint8Array} bytes
     */
    ingest_op(bytes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.worldsink_ingest_op(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Display buffer: 6 f32 per member segment —
     * `[x1, y1, z1, x2, y2, z2]` (truss worlds; empty otherwise).
     * @returns {Float32Array}
     */
    members() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_members(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Open WWLD bytes. A seal section, if present, is lifted out and
     * kept for `verify_seal` — playback itself runs the live engine.
     * @param {Uint8Array} bytes
     */
    constructor(bytes) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.worldsink_new(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            this.__wbg_ptr = r0;
            WorldSinkFinalization.register(this, this.__wbg_ptr, this);
            return this;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {number}
     */
    node_count() {
        const ret = wasm.worldsink_node_count(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Node ids of the particles in `particles()` order, 16 bytes
     * each, concatenated — so the page can target the particle
     * nearest a pointer event.
     * @returns {Uint8Array}
     */
    particle_ids() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_particle_ids(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayU8FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Display buffer: 5 f32 per particle — `[x, y, z, radius, kind]`,
     * kind 0 = free, 1 = anchored. f32 is for the GPU only; the
     * simulation state stays exact fixed-point inside the engine.
     * @returns {Float32Array}
     */
    particles() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_particles(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string | undefined}
     */
    seal_hash_hex() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_seal_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v1;
            if (r0 !== 0) {
                v1 = getStringFromWasm0(r0, r1);
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Seal the session as it stands at the current tick into a
     * `wai.world.replay` plus its §8 receipt, signed by `publisher`.
     *
     * `joules_micro` is **carried, never invented** — the page passes a
     * measured wall-clock estimate (with a declared coefficient) or `0`
     * when unmetered. `group_id` + `parent_hex` chain this seal onto the
     * world's prior receipt (empty `parent_hex` starts a fresh chain).
     * The exact deterministic work figure is computed here, not passed.
     * @param {Uint8Array} publisher_seed
     * @param {string} signer_id
     * @param {bigint} joules_micro
     * @param {bigint} group_id
     * @param {string} parent_hex
     * @returns {SealedSession}
     */
    seal_session(publisher_seed, signer_id, joules_micro, group_id, parent_hex) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArray8ToWasm0(publisher_seed, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passStringToWasm0(signer_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            const ptr2 = passStringToWasm0(parent_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len2 = WASM_VECTOR_LEN;
            wasm.worldsink_seal_session(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, joules_micro, group_id, ptr2, len2);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return SealedSession.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    sim() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_sim(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * BLAKE3 state hash at the current tick — the quantity
     * replay-equivalence is defined over, computed by the same code
     * that generated the conformance corpus.
     * @returns {string}
     */
    state_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_state_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {number}
     */
    tick_rate() {
        const ret = wasm.worldsink_tick_rate(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Replay to the sealed final tick and compare state hashes.
     * `true` = this browser re-derived the publisher's exact world.
     * @returns {boolean}
     */
    verify_seal() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_verify_seal(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return r0 !== 0;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * World identity (§7.4): BLAKE3 over contract + tick-0 graph.
     * @returns {string}
     */
    world_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.worldsink_world_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) WorldSink.prototype[Symbol.dispose] = WorldSink.prototype.free;

export class ZneDemo {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ZneDemoFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_znedemo_free(ptr, 0);
    }
    /**
     * @returns {number}
     */
    error() {
        const ret = wasm.znedemo_error(this.__wbg_ptr);
        return ret;
    }
    /**
     * The hidden ideal (ground truth) the extrapolation should recover.
     * @returns {number}
     */
    ideal() {
        const ret = wasm.znedemo_ideal(this.__wbg_ptr);
        return ret;
    }
    /**
     * BLAKE3 of the raw input table — the portable content address of the data.
     * @returns {string}
     */
    input_hash_hex() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.znedemo_input_hash_hex(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Measured expectation at each scale (y-axis).
     * @returns {Float64Array}
     */
    meas_y() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.znedemo_meas_y(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * @returns {string}
     */
    method() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.znedemo_method(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * The extrapolated zero-noise estimate.
     * @returns {number}
     */
    mitigated() {
        const ret = wasm.znedemo_mitigated(this.__wbg_ptr);
        return ret;
    }
    /**
     * Extrapolate a noisy observable to zero noise. The hidden ideal expectation
     * is `ideal`; the (simulated) hardware decays it as `exp(-gamma·λ)` and is
     * sampled with `shots` per scale over `n_scales` integer noise scales
     * (1×, 2×, …). `richardson=true` fits the exact polynomial; otherwise a
     * least-squares line.
     * @param {number} ideal
     * @param {number} gamma
     * @param {number} seed
     * @param {number} n_scales
     * @param {number} shots
     * @param {boolean} richardson
     */
    constructor(ideal, gamma, seed, n_scales, shots, richardson) {
        const ret = wasm.znedemo_new(ideal, gamma, seed, n_scales, shots, richardson);
        this.__wbg_ptr = ret;
        ZneDemoFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * The raw base-noise (λ=1) expectation — what you'd report without mitigation.
     * @returns {number}
     */
    raw() {
        const ret = wasm.znedemo_raw(this.__wbg_ptr);
        return ret;
    }
    /**
     * @returns {string}
     */
    receipt_json() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.znedemo_receipt_json(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred1_0 = r0;
            deferred1_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * @returns {boolean}
     */
    receipt_verifies() {
        const ret = wasm.znedemo_receipt_verifies(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Noise scales measured (x-axis).
     * @returns {Float64Array}
     */
    scales_x() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.znedemo_scales_x(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF64FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 8, 8);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
}
if (Symbol.dispose) ZneDemo.prototype[Symbol.dispose] = ZneDemo.prototype.free;

/**
 * Lowercase-hex BLAKE3 of `bytes` — the in-page receipt check. Hash the RGB of
 * an integer-exact decode and compare it to the digest a publisher pinned: the
 * reconstruction either matches on this machine or it does not, verified
 * client-side with no server round-trip. This is the whole point of an
 * integer-exact decode — the hash is portable.
 * @param {Uint8Array} bytes
 * @returns {string}
 */
export function blake3Hex(bytes) {
    let deferred2_0;
    let deferred2_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.blake3Hex(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        deferred2_0 = r0;
        deferred2_1 = r1;
        return getStringFromWasm0(r0, r1);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
    }
}

/**
 * A title that exists to be refused: the code it was refused with, which is the one it
 * states (`refused`). A title evaluated, or refused with another code, is an error.
 * @param {string} dir
 * @param {Map<any, any>} files
 * @returns {string}
 */
export function checkRefusal(dir, files) {
    let deferred3_0;
    let deferred3_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(dir, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.checkRefusal(retptr, ptr0, len0, addBorrowedObject(files));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr2 = r0;
        var len2 = r1;
        if (r3) {
            ptr2 = 0; len2 = 0;
            throw takeObject(r2);
        }
        deferred3_0 = ptr2;
        deferred3_1 = len2;
        return getStringFromWasm0(ptr2, len2);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
    }
}

/**
 * One object's counted bytes (§3): `{counted: {header, manifest, payload, total},
 * framing}` or, where it is not countable, `{counted: null, refused: <code>, component,
 * detail}`.
 * @param {Uint8Array} envelope
 * @returns {any}
 */
export function countObject(envelope) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.countObject(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a learned-audio model (`audio_model.bin`, WAM1) + the tool's JSON
 * bitstream (`audio_bitstream.json`) to int16 PCM in the browser. For debugging and
 * conversion only: the payload `wai.audio.int_codec` carries is `WIA1`
 * ([`decode_wia1`]). Byte-identical to the native reference.
 * @param {Uint8Array} model_bin
 * @param {Uint8Array} bitstream_json
 * @returns {DecodedAudio}
 */
export function decodeIntAudio(model_bin, bitstream_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(model_bin, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(bitstream_json, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.decodeIntAudio(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedAudio.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode the tool's JSON conditional bitstream → RGB in the browser. For debugging
 * and conversion only: the payload `wai.neural.int_hyper` carries is `WIH1`
 * ([`decode_wih1`]). The rest of this note describes the decode both share:
 * integer-exact (`wai.neural.int_hyper`). The host installs the model
 * (`int_synth_sota_model.json` = g_s, `int_hs_model.json` = h_s,
 * `cond_entropy.json` = the entropy tables); WAI carries the bitstream
 * (`cond_bitstream.json`). The WHOLE decode — factorized z, integer h_s,
 * integer-σ entropy, integer g_s — is pure i64, no float, no ONNX, so the RGB
 * is byte-identical to the native reference on every machine: a pretrained
 * learned codec decoding deterministically in-page, zero JS ML runtime.
 * @param {Uint8Array} g_s_json
 * @param {Uint8Array} h_s_json
 * @param {Uint8Array} entropy_json
 * @param {Uint8Array} bitstream_json
 * @returns {DecodedImage}
 */
export function decodeIntHyper(g_s_json, h_s_json, entropy_json, bitstream_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(g_s_json, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(h_s_json, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(entropy_json, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passArray8ToWasm0(bitstream_json, wasm.__wbindgen_export);
        const len3 = WASM_VECTOR_LEN;
        wasm.decodeIntHyper(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedImage.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Same decode from the **compact binary** model (`*_model.bin`, int12 weights as
 * `i16`), of the tool's JSON bitstream. For debugging and conversion only: the
 * payload is `WIH1` ([`decode_wih1`]). Byte-identical to the JSON model and to the
 * native reference.
 * @param {Uint8Array} g_s_bin
 * @param {Uint8Array} h_s_bin
 * @param {Uint8Array} entropy_json
 * @param {Uint8Array} bitstream_json
 * @returns {DecodedImage}
 */
export function decodeIntHyperBin(g_s_bin, h_s_bin, entropy_json, bitstream_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(g_s_bin, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(h_s_bin, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(entropy_json, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passArray8ToWasm0(bitstream_json, wasm.__wbindgen_export);
        const len3 = WASM_VECTOR_LEN;
        wasm.decodeIntHyperBin(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedImage.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a learned-splat model (`splat_gs.bin`, WHM1) + the tool's JSON bitstream
 * (`splat.json`) to the integer attribute tensor in the browser. For debugging and
 * conversion only: the payload `wai.splat.int_codec` carries is `WIS1`
 * ([`decode_wis1`]). Byte-identical to the native reference.
 * @param {Uint8Array} gs_bin
 * @param {Uint8Array} bitstream_json
 * @returns {DecodedSplat}
 */
export function decodeIntSplat(gs_bin, bitstream_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(gs_bin, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(bitstream_json, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.decodeIntSplat(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedSplat.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a `wai.neural.int_synth` payload to RGB in the browser, integer-exact.
 * `payload` is the envelope's payload bytes; `spec_json` is the model spec (the
 * `int_synth.json` weights) the host has installed. No float, no ONNX — the
 * output is byte-identical to the native reference decode.
 * @param {Uint8Array} payload
 * @param {Uint8Array} spec_json
 * @returns {DecodedImage}
 */
export function decodeIntSynth(payload, spec_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(spec_json, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.decodeIntSynth(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedImage.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode the tool's JSON bitstream (`int_video_bitstream.json`) to RGB frames. For
 * debugging and conversion only: the payload `wai.video.int_motion` carries is
 * `WIV1` ([`decode_wiv1`]), and a JSON form is not one. Byte-identical to the
 * native reference; `fnv1aHex` (the `generate` binding) hashes each frame.
 * @param {Uint8Array} bitstream_json
 * @returns {DecodedVideo}
 */
export function decodeIntVideo(bitstream_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bitstream_json, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.decodeIntVideo(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedVideo.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode the **P-frames** of a JSON bitstream on top of an already-decoded I-frame
 * (`i_frame`, RGB HWC `u8`, e.g. from `decodeIntHyperBin`) — the NEURAL-KEYFRAME
 * path (`wai.video.int_hyper`): a learned `int_hyper` keyframe + integer
 * inter-frames, the whole clip byte-exact. For debugging and conversion only: the
 * payload is `WIV1` with its keyframe nested ([`decode_wiv1`]). No float, no ML
 * runtime.
 * @param {Uint8Array} i_frame
 * @param {number} w
 * @param {number} h
 * @param {Uint8Array} bitstream_json
 * @returns {DecodedVideo}
 */
export function decodeIntVideoPframes(i_frame, w, h, bitstream_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(i_frame, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(bitstream_json, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.decodeIntVideoPframes(retptr, ptr0, len0, w, h, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedVideo.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a full ISO/IEC 6048 JPEG-AI codestream to RGB in the browser
 * (`wai.image.jpegai`). The same exact decoder a native sink runs
 * (`wai::jpegai_decode::decode`), compiled to wasm32: an integer entropy decode and
 * integer PTQ networks, then dequantisation, post-filters and colour conversion in
 * IEEE-754 float with a fixed evaluation order. It pins one reconstruction, which
 * reproduces across machines under the conditions in
 * `extensions/determinism-tiers.md` §5; that is a property of this decoder, not of
 * the capability, which is registered at entropy-consistency and does not back
 * `intent = replicate`. It decodes one configuration and refuses any other
 * codestream with the reason (`wai::jpegai_decode::check_scope`). The 13 byte
 * inputs are the model weight bundle (`tools/wai_jpegai_build_e2e_inputs.py`):
 * per-plane hyper-scale / hyper-decoder / synthesis, the four luma MCM stages, the
 * eICCI net, and the normative tables (`norm`).
 * @param {Uint8Array} codestream
 * @param {Uint8Array} hs_y
 * @param {Uint8Array} hyp_y
 * @param {Uint8Array} synth_y
 * @param {Uint8Array} hs_uv
 * @param {Uint8Array} hyp_uv
 * @param {Uint8Array} synth_uv
 * @param {Uint8Array} mcm0
 * @param {Uint8Array} mcm1
 * @param {Uint8Array} mcm2
 * @param {Uint8Array} mcm3
 * @param {Uint8Array} icci
 * @param {Uint8Array} norm
 * @returns {DecodedImage}
 */
export function decodeJpegAiFull(codestream, hs_y, hyp_y, synth_y, hs_uv, hyp_uv, synth_uv, mcm0, mcm1, mcm2, mcm3, icci, norm) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(codestream, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(hs_y, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(hyp_y, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passArray8ToWasm0(synth_y, wasm.__wbindgen_export);
        const len3 = WASM_VECTOR_LEN;
        const ptr4 = passArray8ToWasm0(hs_uv, wasm.__wbindgen_export);
        const len4 = WASM_VECTOR_LEN;
        const ptr5 = passArray8ToWasm0(hyp_uv, wasm.__wbindgen_export);
        const len5 = WASM_VECTOR_LEN;
        const ptr6 = passArray8ToWasm0(synth_uv, wasm.__wbindgen_export);
        const len6 = WASM_VECTOR_LEN;
        const ptr7 = passArray8ToWasm0(mcm0, wasm.__wbindgen_export);
        const len7 = WASM_VECTOR_LEN;
        const ptr8 = passArray8ToWasm0(mcm1, wasm.__wbindgen_export);
        const len8 = WASM_VECTOR_LEN;
        const ptr9 = passArray8ToWasm0(mcm2, wasm.__wbindgen_export);
        const len9 = WASM_VECTOR_LEN;
        const ptr10 = passArray8ToWasm0(mcm3, wasm.__wbindgen_export);
        const len10 = WASM_VECTOR_LEN;
        const ptr11 = passArray8ToWasm0(icci, wasm.__wbindgen_export);
        const len11 = WASM_VECTOR_LEN;
        const ptr12 = passArray8ToWasm0(norm, wasm.__wbindgen_export);
        const len12 = WASM_VECTOR_LEN;
        wasm.decodeJpegAiFull(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, ptr11, len11, ptr12, len12);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedImage.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode the ISO/IEC 6048 JPEG-AI **mANS** entropy stream in the browser, byte-exact —
 * the same pure-i64 decoder native sinks run (`wai::jpegai_mans`), compiled to wasm32.
 *
 * A **reproduction vector**: given the reference stream `mem`, the integer PMF rows
 * (`pmf_flat`, `n_rows × 256` row-major), the per-distribution `bounds`, and the
 * per-position `sigma` distribution indices + coded-position `masks` (0/1), it returns
 * the decoded residual symbols. The decode is entirely integer, so the symbols — and
 * their hash — are identical on every machine. The page hashes them and compares to the
 * digest the native reference produced; a byte-identical match across host + browser is
 * the whole point of the integer-entropy contract. This is the same stream and
 * symbols the cross-architecture byte-equality matrix checks natively.
 * @param {Uint8Array} mem
 * @param {BigInt64Array} pmf_flat
 * @param {Uint8Array} bounds
 * @param {Uint8Array} sigma
 * @param {Uint8Array} masks
 * @returns {Int16Array}
 */
export function decodeJpegAiMans(mem, pmf_flat, bounds, sigma, masks) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(mem, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray64ToWasm0(pmf_flat, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(bounds, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passArray8ToWasm0(sigma, wasm.__wbindgen_export);
        const len3 = WASM_VECTOR_LEN;
        const ptr4 = passArray8ToWasm0(masks, wasm.__wbindgen_export);
        const len4 = WASM_VECTOR_LEN;
        wasm.decodeJpegAiMans(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var v6 = getArrayI16FromWasm0(r0, r1).slice();
        wasm.__wbindgen_export4(r0, r1 * 2, 2);
        return v6;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a `WIA1` payload (`wai.audio.int_codec`, `extensions/integer-payloads.md`
 * §5) to int16 PCM in the browser, byte-identical to the native reference, with its
 * one-file parameter set (`model.wam`, the `WAM1` synthesis). A refusal's message
 * starts with its code (`bad_magic` for a JSON form). No float, no ML runtime.
 * @param {Uint8Array} payload
 * @param {Uint8Array} model_wam
 * @returns {DecodedAudio}
 */
export function decodeWia1(payload, model_wam) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(model_wam, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.decodeWia1(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedAudio.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a `WIH1` payload (`wai.neural.int_hyper`, `extensions/integer-payloads.md`
 * §4) → RGB in the browser, byte-identical to the native reference, with the
 * conditional codec's set: `g_s.whm` and `h_s.whm` (the compact `WHM1` networks) and
 * `entropy.json` (the tables). A refusal's message starts with its code
 * (`bad_magic` for a JSON form). No float, no ONNX.
 * @param {Uint8Array} payload
 * @param {Uint8Array} g_s
 * @param {Uint8Array} h_s
 * @param {Uint8Array} entropy
 * @returns {DecodedImage}
 */
export function decodeWih1(payload, g_s, h_s, entropy) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(g_s, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(h_s, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ptr3 = passArray8ToWasm0(entropy, wasm.__wbindgen_export);
        const len3 = WASM_VECTOR_LEN;
        wasm.decodeWih1(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedImage.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a `WIS1` payload (`wai.splat.int_codec`, `extensions/integer-payloads.md`
 * §6) to the integer attribute tensor in the browser, byte-identical to the native
 * reference, with its one-file parameter set (`g_s.whm`, the `WHM1` synthesis), and
 * the per-attribute ranges and Gaussian count the payload carries. A refusal's
 * message starts with its code (`bad_magic` for a JSON form). No float, no ML runtime.
 * @param {Uint8Array} payload
 * @param {Uint8Array} g_s
 * @returns {DecodedSplat}
 */
export function decodeWis1(payload, g_s) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(g_s, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.decodeWis1(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedSplat.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Decode a `WIV1` payload (`extensions/integer-payloads.md` §3) to RGB frames in
 * the browser, byte-identical to the native reference: `capability` is the
 * envelope's, `wai.video.int_motion` (keyframe 0, no parameters) or
 * `wai.video.int_hyper` (keyframe 1, whose nested `WIH1` keyframe decodes with the
 * conditional codec's `g_s.whm`, `h_s.whm` and `entropy.json`). A refusal's message
 * starts with its code (`bad_magic` for a JSON form). No float, no ML runtime.
 * @param {string} capability
 * @param {Uint8Array} payload
 * @param {Uint8Array | null} [g_s]
 * @param {Uint8Array | null} [h_s]
 * @param {Uint8Array | null} [entropy]
 * @returns {DecodedVideo}
 */
export function decodeWiv1(capability, payload, g_s, h_s, entropy) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        var ptr2 = isLikeNone(g_s) ? 0 : passArray8ToWasm0(g_s, wasm.__wbindgen_export);
        var len2 = WASM_VECTOR_LEN;
        var ptr3 = isLikeNone(h_s) ? 0 : passArray8ToWasm0(h_s, wasm.__wbindgen_export);
        var len3 = WASM_VECTOR_LEN;
        var ptr4 = isLikeNone(entropy) ? 0 : passArray8ToWasm0(entropy, wasm.__wbindgen_export);
        var len4 = WASM_VECTOR_LEN;
        wasm.decodeWiv1(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return DecodedVideo.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Integer `build_index`: bucket a fixed-point σ to a scale-table index — pure
 * integer, identical on every machine given the same `sigma_q`. `edges_q` from
 * [`fixed_scale_edges`].
 * @param {bigint} sigma_q
 * @param {BigInt64Array} edges_q
 * @returns {number}
 */
export function detBuildIndex(sigma_q, edges_q) {
    const ptr0 = passArray64ToWasm0(edges_q, wasm.__wbindgen_export);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.detBuildIndex(sigma_q, ptr0, len0);
    return ret >>> 0;
}

/**
 * Sniff the magic. Returns 1 for WAI1, 2 for WAI2, throws otherwise.
 * Use this to route between `parse` and `parseMulti`.
 * @param {Uint8Array} bytes
 * @returns {number}
 */
export function detectVersion(bytes) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.detectVersion(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return r0;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * A title's deterministic figures: the text `wai_stage_measure eval --json` prints for
 * it, which is its block of the corpus's `goldens.json`. A refusal's message starts
 * `refused <code>`.
 * @param {string} dir
 * @param {Map<any, any>} files
 * @returns {string}
 */
export function evaluateTitle(dir, files) {
    let deferred3_0;
    let deferred3_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(dir, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.evaluateTitle(retptr, ptr0, len0, addBorrowedObject(files));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr2 = r0;
        var len2 = r1;
        if (r3) {
            ptr2 = 0; len2 = 0;
            throw takeObject(r2);
        }
        deferred3_0 = ptr2;
        deferred3_1 = len2;
        return getStringFromWasm0(ptr2, len2);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
    }
}

/**
 * Precompute a CompressAI-style ascending `scale_table` as fixed-point integer
 * bucket edges (Q`frac`). Returns a `BigInt64Array` to JS.
 * @param {Float32Array} scale_table
 * @param {number} frac
 * @returns {BigInt64Array}
 */
export function fixedScaleEdges(scale_table, frac) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArrayF32ToWasm0(scale_table, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.fixedScaleEdges(retptr, ptr0, len0, frac);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var v2 = getArrayI64FromWasm0(r0, r1).slice();
        wasm.__wbindgen_export4(r0, r1 * 8, 8);
        return v2;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * FNV-1a 64-bit of `bytes` as lowercase hex — the portable generation hash the
 * page pins and re-checks, the same checksum the native generator emits.
 * @param {Uint8Array} bytes
 * @returns {string}
 */
export function fnv1aHex(bytes) {
    let deferred2_0;
    let deferred2_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.fnv1aHex(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        deferred2_0 = r0;
        deferred2_1 = r1;
        return getStringFromWasm0(r0, r1);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
    }
}

/**
 * Generate an image deterministically from `(model, prompt, seed, steps)`, in the
 * browser, integer-exact. `model_json` is the pinned model bundle
 * (`generate_spectral_model.json`); the output is byte-identical to the native
 * reference, so its FNV-1a is portable. No float, no ML runtime.
 * @param {Uint8Array} model_json
 * @param {string} prompt
 * @param {number} seed
 * @param {number} steps
 * @param {number} w
 * @param {number} h
 * @returns {GeneratedImage}
 */
export function generateSpectral(model_json, prompt, seed, steps, w, h) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(model_json, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(prompt, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        wasm.generateSpectral(retptr, ptr0, len0, ptr1, len1, seed, steps, w, h);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return GeneratedImage.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The algorithm library catalog as JSON `[{id,name,desc}]`, for the IDE dropdown.
 * @returns {string}
 */
export function ide_catalog() {
    let deferred1_0;
    let deferred1_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.ide_catalog(retptr);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        deferred1_0 = r0;
        deferred1_1 = r1;
        return getStringFromWasm0(r0, r1);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
    }
}

/**
 * The declared cost of decoding `payload` through `capability`, before decoding it.
 * The set members are given as the decoders take them: `g_s`, `h_s` and `entropy`
 * for `wai.neural.int_hyper` and `wai.video.int_hyper`, `model` for
 * `wai.audio.int_codec`, `g_s` for `wai.splat.int_codec`, none for
 * `wai.video.int_motion`. A refusal's message starts with its code.
 * @param {string} capability
 * @param {Uint8Array} payload
 * @param {Uint8Array | null} [g_s]
 * @param {Uint8Array | null} [h_s]
 * @param {Uint8Array | null} [entropy]
 * @param {Uint8Array | null} [model]
 * @returns {IntPayloadCost}
 */
export function intPayloadCost(capability, payload, g_s, h_s, entropy, model) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        var ptr2 = isLikeNone(g_s) ? 0 : passArray8ToWasm0(g_s, wasm.__wbindgen_export);
        var len2 = WASM_VECTOR_LEN;
        var ptr3 = isLikeNone(h_s) ? 0 : passArray8ToWasm0(h_s, wasm.__wbindgen_export);
        var len3 = WASM_VECTOR_LEN;
        var ptr4 = isLikeNone(entropy) ? 0 : passArray8ToWasm0(entropy, wasm.__wbindgen_export);
        var len4 = WASM_VECTOR_LEN;
        var ptr5 = isLikeNone(model) ? 0 : passArray8ToWasm0(model, wasm.__wbindgen_export);
        var len5 = WASM_VECTOR_LEN;
        wasm.intPayloadCost(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return IntPayloadCost.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Whether `cap` is a registered **candidate** capability: registered, but with no
 * payload format pinned, so an encoder MUST NOT emit it and a sink treats it as
 * unsupported (SPEC §5, *Candidate capabilities*). The registry's own predicate,
 * `wai::codecs::is_candidate`.
 * @param {string} cap
 * @returns {boolean}
 */
export function isCandidate(cap) {
    const ptr0 = passStringToWasm0(cap, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.isCandidate(ptr0, len0);
    return ret !== 0;
}

/**
 * Whether `cap` is a string the registry registers as a payload or companion
 * capability (`wai::codecs::is_known_capability`).
 * @param {string} cap
 * @returns {boolean}
 */
export function isRegistered(cap) {
    const ptr0 = passStringToWasm0(cap, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.isRegistered(ptr0, len0);
    return ret !== 0;
}

/**
 * @returns {any[]}
 */
export function known_capabilities() {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.known_capabilities(retptr);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var v1 = getArrayJsValueFromWasm0(r0, r1);
        wasm.__wbindgen_export4(r0, r1 * 4, 4);
        return v1;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Lamport of an op on the wire (for `observe_lamport` without the
 * page parsing the binary layout).
 * @param {Uint8Array} bytes
 * @returns {bigint}
 */
export function op_lamport(bytes) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.op_lamport(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        return BigInt.asUintN(64, r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The output tree's root over presentations given as a JSON array of `{unit, layers,
 * decoder, out_digest}`, or `undefined` for none. A (unit, layers) given twice is an
 * error.
 * @param {string} outputs_json
 * @returns {string | undefined}
 */
export function outputRoot(outputs_json) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(outputs_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.outputRoot(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        let v2;
        if (r0 !== 0) {
            v2 = getStringFromWasm0(r0, r1);
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
        }
        return v2;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Build a WAI envelope from a manifest JSON string + a payload byte
 * array. Mirrors `wai_envelope_pack` from the native SDK so JS code
 * can produce .wai files in the browser too: like it, refuses a manifest
 * that names a candidate capability as its capability or fallback, which an
 * encoder MUST NOT emit (SPEC §5, *Candidate capabilities*), and a payload that is
 * not the format SPEC §5 pins its integer capability or fallback to. The manifest is
 * written as given, so a manifest that names a member twice in one object is refused
 * (SPEC §2), as every reader refuses it.
 * @param {string} manifest_json
 * @param {Uint8Array} payload
 * @returns {Uint8Array}
 */
export function pack(manifest_json, payload) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(manifest_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.pack(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        var v3 = getArrayU8FromWasm0(r0, r1).slice();
        wasm.__wbindgen_export4(r0, r1 * 1, 1);
        return v3;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Pack a WAI2 envelope from a manifest JSON + array of payload byte arrays.
 * The manifest's `renditions` array MUST be the same length and order as the
 * payloads. The manifest is written as given. Like `wai_envelope_pack_multi`,
 * refuses a table with a component, in either role, whose capability is a
 * candidate, or whose payload is not the format SPEC §5 pins its integer capability
 * to (SPEC §5).
 * @param {string} manifest_json
 * @param {Array<any>} payloads
 * @returns {Uint8Array}
 */
export function packMulti(manifest_json, payloads) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(manifest_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.packMulti(retptr, ptr0, len0, addHeapObject(payloads));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        var v2 = getArrayU8FromWasm0(r0, r1).slice();
        wasm.__wbindgen_export4(r0, r1 * 1, 1);
        return v2;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Parse a `Uint8Array` containing a complete WAI1 envelope. Throws a
 * JS Error with a descriptive message on bad magic / truncation /
 * invalid manifest JSON — the JS shim catches and surfaces it.
 * @param {Uint8Array} bytes
 * @returns {WaiEnvelope}
 */
export function parse(bytes) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.parse(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return WaiEnvelope.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * @param {Uint8Array} bytes
 * @returns {WaiMulti}
 */
export function parseMulti(bytes) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.parseMulti(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return WaiMulti.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * §4.2's integers for two RGB8 pictures of `w × h`: `{kind, n_samples, sse_rgb, sse_y,
 * ssim_y_q32, windows}`, the sums of squares as decimal strings.
 * @param {number} w
 * @param {number} h
 * @param {Uint8Array} reference
 * @param {Uint8Array} test
 * @returns {any}
 */
export function qualityRgb8(w, h, reference, test) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(reference, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(test, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.qualityRgb8(retptr, w, h, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Snap a float σ to the fixed-point grid (Q`frac`), deterministic floor.
 * @param {number} sigma
 * @param {number} frac
 * @returns {bigint}
 */
export function quantizeScale(sigma, frac) {
    const ret = wasm.quantizeScale(sigma, frac);
    return ret;
}

/**
 * Replay a MERGED multi-actor action log (`log` = everyone's `CausalOp`s
 * concatenated, any order) → the convergent session hash + the canonical delta
 * sequence. Every peer that holds the same op set computes the IDENTICAL result —
 * replay-equivalence — so rendering the deltas yields the same byte-exact world on
 * every tab. Signatures are verified.
 * @param {string} model_id_hex
 * @param {bigint} seed
 * @param {number} width
 * @param {number} height
 * @param {number} fps
 * @param {Uint8Array} log
 * @returns {WorldReplay}
 */
export function replayWorldOps(model_id_hex, seed, width, height, fps, log) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(model_id_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(log, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.replayWorldOps(retptr, ptr0, len0, seed, width, height, fps, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return WorldReplay.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Begin a session at its entry object `entry`, the first envelope the sink dispatches:
 * the claim states its manifest's `media` and names it as the subject. `host_json` is the
 * decoder host, `{profile, target, threads}` (`profile` one of jwp-receipts §2.4.12's,
 * `target` a term or `null`, `threads` the decode workers); `nonce_hex` 32 fresh random
 * bytes derived from nothing that identifies a person, a device or an account;
 * `deadline_us` a per-unit deadline, or `undefined` for none.
 * @param {Uint8Array} entry
 * @param {string} host_json
 * @param {string} nonce_hex
 * @param {number | null} [deadline_us]
 * @returns {SessionHandle}
 */
export function sessionBegin(entry, host_json, nonce_hex, deadline_us) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(entry, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(host_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passStringToWasm0(nonce_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len2 = WASM_VECTOR_LEN;
        wasm.sessionBegin(retptr, ptr0, len0, ptr1, len1, ptr2, len2, !isLikeNone(deadline_us), isLikeNone(deadline_us) ? 0 : deadline_us);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return SessionHandle.__wrap(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * SHA-256 of `bytes` as 64 lowercase hexadecimal digits (SPEC §7, *Digests*).
 * @param {Uint8Array} bytes
 * @returns {string}
 */
export function sha256Hex(bytes) {
    let deferred2_0;
    let deferred2_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.sha256Hex(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        deferred2_0 = r0;
        deferred2_1 = r1;
        return getStringFromWasm0(r0, r1);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
    }
}

/**
 * Sign one action op for a SHARED world and return its serialized bytes (a
 * `CausalOp`). Each peer signs with its own actor key (`actor_seed_hex`) and
 * broadcasts these bytes; peers concatenate everyone's ops into one log and
 * [`replay_world_ops`] it. The signature binds the action to the actor — an op can
 * only claim the identity that signed it.
 * @param {string} actor_seed_hex
 * @param {bigint} lamport
 * @param {bigint} tick
 * @param {number} dx
 * @param {number} dy
 * @param {number} buttons
 * @returns {Uint8Array}
 */
export function signWorldAction(actor_seed_hex, lamport, tick, dx, dy, buttons) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(actor_seed_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.signWorldAction(retptr, ptr0, len0, lamport, tick, dx, dy, buttons);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        var v2 = getArrayU8FromWasm0(r0, r1).slice();
        wasm.__wbindgen_export4(r0, r1 * 1, 1);
        return v2;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * Simulate a `wai-sim/1` plan over a title's objects and counted bytes: the text
 * `wai_stage_measure sim <fixture> <plan>` prints.
 * @param {string} dir
 * @param {Map<any, any>} files
 * @param {string} plan_json
 * @returns {string}
 */
export function simulate(dir, files, plan_json) {
    let deferred4_0;
    let deferred4_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(dir, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(plan_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        wasm.simulate(retptr, ptr0, len0, addBorrowedObject(files), ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr3 = r0;
        var len3 = r1;
        if (r3) {
            ptr3 = 0; len3 = 0;
            throw takeObject(r2);
        }
        deferred4_0 = ptr3;
        deferred4_1 = len3;
        return getStringFromWasm0(ptr3, len3);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
    }
}

/**
 * Simulate a plan over a `wai-sim-model/1` model: the text `wai_stage_measure sim
 * <model.json> <plan>` prints.
 * @param {string} model_json
 * @param {string} plan_json
 * @returns {string}
 */
export function simulateModel(model_json, plan_json) {
    let deferred4_0;
    let deferred4_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(model_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(plan_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        wasm.simulateModel(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr3 = r0;
        var len3 = r1;
        if (r3) {
            ptr3 = 0; len3 = 0;
            throw takeObject(r2);
        }
        deferred4_0 = ptr3;
        deferred4_1 = len3;
        return getStringFromWasm0(ptr3, len3);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
    }
}

/**
 * Lamport of an op on the wire (so the page need not parse the layout).
 * @param {Uint8Array} bytes
 * @returns {bigint}
 */
export function skel_op_lamport(bytes) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.skel_op_lamport(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        return BigInt.asUintN(64, r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The same for 16-bit samples.
 * @param {Int16Array} a
 * @param {Int16Array} b
 * @returns {bigint}
 */
export function sseI16(a, b) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray16ToWasm0(a, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray16ToWasm0(b, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.sseI16(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        return BigInt.asUintN(64, r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The exact sum of squared differences of two equal-length byte buffers (a `BigInt`).
 * @param {Uint8Array} a
 * @param {Uint8Array} b
 * @returns {bigint}
 */
export function sseU8(a, b) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(a, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArray8ToWasm0(b, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        wasm.sseU8(retptr, ptr0, len0, ptr1, len1);
        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        return BigInt.asUintN(64, r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The content hash of an envelope (jwp-receipts §2.1), lowercase hex: the identity a
 * layer's `refines` names its base and producers by.
 * @param {Uint8Array} envelope
 * @returns {string}
 */
export function stageContentHash(envelope) {
    let deferred2_0;
    let deferred2_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.stageContentHash(retptr, ptr0, len0);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        deferred2_0 = r0;
        deferred2_1 = r1;
        return getStringFromWasm0(r0, r1);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
    }
}

/**
 * What an envelope is, before it is offered or decoded: `{object, bytes,
 * framing_bytes, manifest_bytes, payload_bytes, capability, refinement_only, refines,
 * wir1, declared_cost, error}`, where `wir1` is a layer's header (`n_units`, `shape`,
 * `predictor`, `q`, `tables`) and `declared_cost` a layer's output bytes, symbols and
 * working bytes (Appendix A.5), or a base's declared decode cost
 * (`extensions/integer-payloads.md` §7, with `macs` as a decimal string and the
 * capability it was read for as `cost_capability`), against the parameter set `set`
 * where the base's codec reads one. Not a `WAI1` envelope: an error starting
 * `not-wai1`.
 * @param {Uint8Array} envelope
 * @param {Map<any, any> | null} [set]
 * @returns {any}
 */
export function stageLayerInfo(envelope, set) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passArray8ToWasm0(envelope, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.stageLayerInfo(retptr, ptr0, len0, isLikeNone(set) ? 0 : addHeapObject(set));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        if (r2) {
            throw takeObject(r1);
        }
        return takeObject(r0);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The next file the title in `dir` (below `wai/`) needs and `files` does not hold, or
 * `undefined` once it holds every one.
 * @param {string} dir
 * @param {Map<any, any>} files
 * @returns {string | undefined}
 */
export function titleMissing(dir, files) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(dir, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.titleMissing(retptr, ptr0, len0, addBorrowedObject(files));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        if (r3) {
            throw takeObject(r2);
        }
        let v2;
        if (r0 !== 0) {
            v2 = getStringFromWasm0(r0, r1);
            wasm.__wbindgen_export4(r0, r1 * 1, 1);
        }
        return v2;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        heap[stack_pointer++] = undefined;
    }
}

/**
 * Check a `reconstruct-session` claim (its wire form) against the presentations
 * (`outputs`, `[{unit, layers, decoder, out_digest}]`), the objects received
 * (`[{content_hash, path, counted, transferred, presented}]`) and, where given, the
 * envelopes received (an array of `Uint8Array`): the signature and the class's rules,
 * the output tree, the consistency of the members the presentations give, the byte sums,
 * and that each decoder entry names what its envelope gives. `""` when accepted,
 * otherwise the reason (jwp-receipts §3.1).
 * @param {string} claim
 * @param {string} outputs_json
 * @param {string} objects_json
 * @param {Array<any> | null} [envelopes]
 * @returns {string}
 */
export function verifyClaim(claim, outputs_json, objects_json, envelopes) {
    let deferred5_0;
    let deferred5_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(claim, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(outputs_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passStringToWasm0(objects_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len2 = WASM_VECTOR_LEN;
        wasm.verifyClaim(retptr, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(envelopes) ? 0 : addHeapObject(envelopes));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr4 = r0;
        var len4 = r1;
        if (r3) {
            ptr4 = 0; len4 = 0;
            throw takeObject(r2);
        }
        deferred5_0 = ptr4;
        deferred5_1 = len4;
        return getStringFromWasm0(ptr4, len4);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred5_0, deferred5_1, 1);
    }
}

/**
 * Check a pin (JSON) over `capability` against the parameter sets `held`:
 * `{ "<capability>": [ {file: Uint8Array} | {listing: Uint8Array, files: {"<path>":
 * Uint8Array}} ] }`. Returns `"ok"` or SPEC §3.1's reason.
 * @param {string} prior_json
 * @param {string} capability
 * @param {any} held
 * @returns {string}
 */
export function verifyPin(prior_json, capability, held) {
    let deferred4_0;
    let deferred4_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(prior_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        wasm.verifyPin(retptr, ptr0, len0, ptr1, len1, addHeapObject(held));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr3 = r0;
        var len3 = r1;
        if (r3) {
            ptr3 = 0; len3 = 0;
            throw takeObject(r2);
        }
        deferred4_0 = ptr3;
        deferred4_1 = len3;
        return getStringFromWasm0(ptr3, len3);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
    }
}

/**
 * The barren-plateau signature: variance of a cost gradient at `(n, layers)`.
 * @param {number} n
 * @param {number} layers
 * @param {number} samples
 * @param {number} seed
 * @returns {number}
 */
export function vml_barren_variance(n, layers, samples, seed) {
    const ret = wasm.vml_barren_variance(n, layers, samples, seed);
    return ret;
}

/**
 * The parity (interference) target on `n` qubits: uniform over even-parity strings,
 * zero on odd — matchable only by amplitudes that destructively cancel.
 * @param {number} n
 * @returns {Float64Array}
 */
export function vml_parity_target(n) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.vml_parity_target(retptr, n);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var v1 = getArrayF64FromWasm0(r0, r1).slice();
        wasm.__wbindgen_export4(r0, r1 * 8, 8);
        return v1;
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

/**
 * The bytes of linear memory this instance holds: what a page or a test reads to see
 * what a call allocated (linear memory only grows). 0 off wasm32.
 * @returns {number}
 */
export function wasmMemoryBytes() {
    const ret = wasm.wasmMemoryBytes();
    return ret;
}

/**
 * Replay a signed action trace → the portable **session hash** (hex), in the
 * browser. `actions_json` is `[{lamport,tick,dx,dy,buttons}]`; each is signed with
 * the actor key derived from `key_seed_hex` (32-byte seed), then replayed under
 * canonical total order — the same `wai.world.model` replay-equivalence the native
 * reference computes. Lets the page show that the keystrokes the user just made
 * hash to one portable, signed session identity.
 * @param {string} model_id_hex
 * @param {bigint} seed
 * @param {number} width
 * @param {number} height
 * @param {number} fps
 * @param {string} key_seed_hex
 * @param {Uint8Array} actions_json
 * @returns {string}
 */
export function worldSessionHash(model_id_hex, seed, width, height, fps, key_seed_hex, actions_json) {
    let deferred5_0;
    let deferred5_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        const ptr0 = passStringToWasm0(model_id_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(key_seed_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArray8ToWasm0(actions_json, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        wasm.worldSessionHash(retptr, ptr0, len0, seed, width, height, fps, ptr1, len1, ptr2, len2);
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
        var ptr4 = r0;
        var len4 = r1;
        if (r3) {
            ptr4 = 0; len4 = 0;
            throw takeObject(r2);
        }
        deferred5_0 = ptr4;
        deferred5_1 = len4;
        return getStringFromWasm0(ptr4, len4);
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
        wasm.__wbindgen_export4(deferred5_0, deferred5_1, 1);
    }
}
function __wbg_get_imports() {
    const import0 = {
        __proto__: null,
        __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
            const ret = Error(getStringFromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __wbg_String_8564e559799eccda: function(arg0, arg1) {
            const ret = String(getObject(arg1));
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
        },
        __wbg___wbindgen_bigint_get_as_i64_c4ecf48528083721: function(arg0, arg1) {
            const v = getObject(arg1);
            const ret = typeof(v) === 'bigint' ? v : undefined;
            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
        },
        __wbg___wbindgen_boolean_get_c9c83ebd41b34df3: function(arg0) {
            const v = getObject(arg0);
            const ret = typeof(v) === 'boolean' ? v : undefined;
            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
        },
        __wbg___wbindgen_debug_string_a57024b9c6e4a48b: function(arg0, arg1) {
            const ret = debugString(getObject(arg1));
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
        },
        __wbg___wbindgen_in_ac983077f137f2e6: function(arg0, arg1) {
            const ret = getObject(arg0) in getObject(arg1);
            return ret;
        },
        __wbg___wbindgen_is_bigint_8ffbbef442139384: function(arg0) {
            const ret = typeof(getObject(arg0)) === 'bigint';
            return ret;
        },
        __wbg___wbindgen_is_function_5e4570eb24ffa122: function(arg0) {
            const ret = typeof(getObject(arg0)) === 'function';
            return ret;
        },
        __wbg___wbindgen_is_null_7d13f41e1a2d5140: function(arg0) {
            const ret = getObject(arg0) === null;
            return ret;
        },
        __wbg___wbindgen_is_object_a2790eb24c211ea0: function(arg0) {
            const val = getObject(arg0);
            const ret = typeof(val) === 'object' && val !== null;
            return ret;
        },
        __wbg___wbindgen_is_string_e6f02f0ea5f20a32: function(arg0) {
            const ret = typeof(getObject(arg0)) === 'string';
            return ret;
        },
        __wbg___wbindgen_is_undefined_6cff064c44e0d823: function(arg0) {
            const ret = getObject(arg0) === undefined;
            return ret;
        },
        __wbg___wbindgen_jsval_eq_0a18949a61670320: function(arg0, arg1) {
            const ret = getObject(arg0) === getObject(arg1);
            return ret;
        },
        __wbg___wbindgen_jsval_loose_eq_acf2776254a8d832: function(arg0, arg1) {
            const ret = getObject(arg0) == getObject(arg1);
            return ret;
        },
        __wbg___wbindgen_number_get_136b9679cab35cfb: function(arg0, arg1) {
            const obj = getObject(arg1);
            const ret = typeof(obj) === 'number' ? obj : undefined;
            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
        },
        __wbg___wbindgen_string_get_d154f1e671052120: function(arg0, arg1) {
            const obj = getObject(arg1);
            const ret = typeof(obj) === 'string' ? obj : undefined;
            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            var len1 = WASM_VECTOR_LEN;
            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
        },
        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
            throw new Error(getStringFromWasm0(arg0, arg1));
        },
        __wbg_call_1c5886ab9c57d1c7: function() { return handleError(function (arg0, arg1) {
            const ret = getObject(arg0).call(getObject(arg1));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_done_669171204c3dcae2: function(arg0) {
            const ret = getObject(arg0).done;
            return ret;
        },
        __wbg_entries_71601bcb707d5078: function(arg0) {
            const ret = getObject(arg0).entries();
            return addHeapObject(ret);
        },
        __wbg_entries_7774d489e1da5f4f: function(arg0) {
            const ret = Object.entries(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_from_74f3d90e0ff11240: function(arg0) {
            const ret = Array.from(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_get_971a0c45d172643f: function() { return handleError(function (arg0, arg1) {
            const ret = Reflect.get(getObject(arg0), getObject(arg1));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_get_c0c8f8d7da0c03dd: function(arg0, arg1) {
            const ret = getObject(arg0)[arg1 >>> 0];
            return addHeapObject(ret);
        },
        __wbg_get_d173c0308df22d37: function() { return handleError(function (arg0, arg1) {
            const ret = Reflect.get(getObject(arg0), getObject(arg1));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_get_unchecked_e20b893aeafc3fca: function(arg0, arg1) {
            const ret = getObject(arg0)[arg1 >>> 0];
            return addHeapObject(ret);
        },
        __wbg_instanceof_ArrayBuffer_993d02d2d254cad1: function(arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof ArrayBuffer;
            } catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_instanceof_Map_9a4d6ead180ae3a9: function(arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Map;
            } catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_instanceof_Object_80ad464782e2bd73: function(arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Object;
            } catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_instanceof_Uint8Array_f935dbb0aa7cdeed: function(arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Uint8Array;
            } catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_isArray_6339f732981044bf: function(arg0) {
            const ret = Array.isArray(getObject(arg0));
            return ret;
        },
        __wbg_isSafeInteger_f3d6cd19ccfe4512: function(arg0) {
            const ret = Number.isSafeInteger(getObject(arg0));
            return ret;
        },
        __wbg_iterator_5cebbb86e33c6dd6: function() {
            const ret = Symbol.iterator;
            return addHeapObject(ret);
        },
        __wbg_length_36bd29c6848c2144: function(arg0) {
            const ret = getObject(arg0).length;
            return ret;
        },
        __wbg_length_ecfa2c63d3d0d82c: function(arg0) {
            const ret = getObject(arg0).length;
            return ret;
        },
        __wbg_new_116be93542d39019: function() {
            const ret = new Array();
            return addHeapObject(ret);
        },
        __wbg_new_77cc4f4f472aeb81: function(arg0) {
            const ret = new Uint8Array(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_new_cdf041679ded4c5f: function() {
            const ret = new Map();
            return addHeapObject(ret);
        },
        __wbg_new_ebe3e0f6837f0879: function() {
            const ret = new Object();
            return addHeapObject(ret);
        },
        __wbg_next_42cf16ee0dafc9e2: function() { return handleError(function (arg0) {
            const ret = getObject(arg0).next();
            return addHeapObject(ret);
        }, arguments); },
        __wbg_next_8f26b64fa5e9f64b: function(arg0) {
            const ret = getObject(arg0).next;
            return addHeapObject(ret);
        },
        __wbg_parse_1cc93481b0865939: function() { return handleError(function (arg0, arg1) {
            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_prototypesetcall_de8e0d9553586985: function(arg0, arg1, arg2) {
            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
        },
        __wbg_set_014226dfeca53178: function(arg0, arg1, arg2) {
            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
            return addHeapObject(ret);
        },
        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
        },
        __wbg_set_a80955eb93b145c6: function(arg0, arg1, arg2) {
            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
        },
        __wbg_value_1e2369fab29b420e: function(arg0) {
            const ret = getObject(arg0).value;
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000001: function(arg0) {
            // Cast intrinsic for `F64 -> Externref`.
            const ret = arg0;
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000002: function(arg0) {
            // Cast intrinsic for `I64 -> Externref`.
            const ret = arg0;
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
            // Cast intrinsic for `Ref(String) -> Externref`.
            const ret = getStringFromWasm0(arg0, arg1);
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000004: function(arg0) {
            // Cast intrinsic for `U64 -> Externref`.
            const ret = BigInt.asUintN(64, arg0);
            return addHeapObject(ret);
        },
        __wbindgen_object_drop_ref: function(arg0) {
            takeObject(arg0);
        },
    };
    return {
        __proto__: null,
        "./wai_web_bg.js": import0,
    };
}

const ActorFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_actor_free(ptr, 1));
const AssetProvenanceFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_assetprovenance_free(ptr, 1));
const AudioSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_audiosink_free(ptr, 1));
const BenchDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_benchdemo_free(ptr, 1));
const BornMachineFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_bornmachine_free(ptr, 1));
const CampaignDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_campaigndemo_free(ptr, 1));
const ChargeTuneDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_chargetunedemo_free(ptr, 1));
const CompileDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_compiledemo_free(ptr, 1));
const CrDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_crdemo_free(ptr, 1));
const CreatedBoneFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_createdbone_free(ptr, 1));
const CrosstalkDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_crosstalkdemo_free(ptr, 1));
const DecodedAudioFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_decodedaudio_free(ptr, 1));
const DecodedImageFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_decodedimage_free(ptr, 1));
const DecodedSplatFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_decodedsplat_free(ptr, 1));
const DecodedVideoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_decodedvideo_free(ptr, 1));
const DragDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_dragdemo_free(ptr, 1));
const FeedSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_feedsink_free(ptr, 1));
const FilmSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_filmsink_free(ptr, 1));
const GeneratedImageFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_generatedimage_free(ptr, 1));
const GrossDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_grossdemo_free(ptr, 1));
const HapticSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hapticsink_free(ptr, 1));
const IntPayloadCostFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_intpayloadcost_free(ptr, 1));
const MeasureTitleFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_measuretitle_free(ptr, 1));
const NoiseLearnDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_noiselearndemo_free(ptr, 1));
const OttAdBreakFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_ottadbreak_free(ptr, 1));
const OttSessionFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_ottsession_free(ptr, 1));
const PhasorBridgeFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_phasorbridge_free(ptr, 1));
const PhasorKernelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_phasorkernel_free(ptr, 1));
const PhasorReceiptJsFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_phasorreceiptjs_free(ptr, 1));
const QDataSeparationFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_qdataseparation_free(ptr, 1));
const QbomDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_qbomdemo_free(ptr, 1));
const QuantumCalFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_quantumcal_free(ptr, 1));
const QuantumIdeFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_quantumide_free(ptr, 1));
const QuantumJobFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_quantumjob_free(ptr, 1));
const QuantumSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_quantumsink_free(ptr, 1));
const RabiDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_rabidemo_free(ptr, 1));
const RamseyDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_ramseydemo_free(ptr, 1));
const RbDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_rbdemo_free(ptr, 1));
const ReadoutDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_readoutdemo_free(ptr, 1));
const ReadoutMitigateDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_readoutmitigatedemo_free(ptr, 1));
const RearrangeDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_rearrangedemo_free(ptr, 1));
const ReelSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_reelsink_free(ptr, 1));
const RenditionFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_rendition_free(ptr, 1));
const RobustDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_robustdemo_free(ptr, 1));
const RobustFFDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_robustffdemo_free(ptr, 1));
const ScoreSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_scoresink_free(ptr, 1));
const SealedSessionFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_sealedsession_free(ptr, 1));
const SessionHandleFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_sessionhandle_free(ptr, 1));
const ShadowDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_shadowdemo_free(ptr, 1));
const SkeletalActorFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_skeletalactor_free(ptr, 1));
const SkeletalSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_skeletalsink_free(ptr, 1));
const SpectroDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_spectrodemo_free(ptr, 1));
const Splat4dSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_splat4dsink_free(ptr, 1));
const StageBaseFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_stagebase_free(ptr, 1));
const StageSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_stagesink_free(ptr, 1));
const ToricDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_toricdemo_free(ptr, 1));
const WaiEnvelopeFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_waienvelope_free(ptr, 1));
const WaiMultiFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_waimulti_free(ptr, 1));
const WorldModelFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_worldmodel_free(ptr, 1));
const WorldReplayFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_worldreplay_free(ptr, 1));
const WorldSinkFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_worldsink_free(ptr, 1));
const ZneDemoFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_znedemo_free(ptr, 1));

function addHeapObject(obj) {
    if (heap_next === heap.length) heap.push(heap.length + 1);
    const idx = heap_next;
    heap_next = heap[idx];

    heap[idx] = obj;
    return idx;
}

function _assertClass(instance, klass) {
    if (!(instance instanceof klass)) {
        throw new Error(`expected instance of ${klass.name}`);
    }
}

function addBorrowedObject(obj) {
    if (stack_pointer == 1) throw new Error('out of js stack');
    heap[--stack_pointer] = obj;
    return stack_pointer;
}

function debugString(val) {
    // primitive types
    const type = typeof val;
    if (type == 'number' || type == 'boolean' || val == null) {
        return  `${val}`;
    }
    if (type == 'string') {
        return `"${val}"`;
    }
    if (type == 'symbol') {
        const description = val.description;
        if (description == null) {
            return 'Symbol';
        } else {
            return `Symbol(${description})`;
        }
    }
    if (type == 'function') {
        const name = val.name;
        if (typeof name == 'string' && name.length > 0) {
            return `Function(${name})`;
        } else {
            return 'Function';
        }
    }
    // objects
    if (Array.isArray(val)) {
        const length = val.length;
        let debug = '[';
        if (length > 0) {
            debug += debugString(val[0]);
        }
        for(let i = 1; i < length; i++) {
            debug += ', ' + debugString(val[i]);
        }
        debug += ']';
        return debug;
    }
    // Test for built-in
    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
    let className;
    if (builtInMatches && builtInMatches.length > 1) {
        className = builtInMatches[1];
    } else {
        // Failed to match the standard '[object ClassName]'
        return toString.call(val);
    }
    if (className == 'Object') {
        // we're a user defined class or Object
        // JSON.stringify avoids problems with cycles, and is generally much
        // easier than looping through ownProperties of `val`.
        try {
            return 'Object(' + JSON.stringify(val) + ')';
        } catch (_) {
            return 'Object';
        }
    }
    // errors
    if (val instanceof Error) {
        return `${val.name}: ${val.message}\n${val.stack}`;
    }
    // TODO we could test for more things here, like `Set`s and `Map`s.
    return className;
}

function dropObject(idx) {
    if (idx < 1028) return;
    heap[idx] = heap_next;
    heap_next = idx;
}

function getArrayF32FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
}

function getArrayF64FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
}

function getArrayI16FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getInt16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
}

function getArrayI32FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
}

function getArrayI64FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getBigInt64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
}

function getArrayJsValueFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    const mem = getDataViewMemory0();
    const result = [];
    for (let i = ptr; i < ptr + 4 * len; i += 4) {
        result.push(takeObject(mem.getUint32(i, true)));
    }
    return result;
}

function getArrayU32FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
}

function getArrayU8FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}

let cachedBigInt64ArrayMemory0 = null;
function getBigInt64ArrayMemory0() {
    if (cachedBigInt64ArrayMemory0 === null || cachedBigInt64ArrayMemory0.byteLength === 0) {
        cachedBigInt64ArrayMemory0 = new BigInt64Array(wasm.memory.buffer);
    }
    return cachedBigInt64ArrayMemory0;
}

let cachedBigUint64ArrayMemory0 = null;
function getBigUint64ArrayMemory0() {
    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
    }
    return cachedBigUint64ArrayMemory0;
}

let cachedDataViewMemory0 = null;
function getDataViewMemory0() {
    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
    }
    return cachedDataViewMemory0;
}

let cachedFloat32ArrayMemory0 = null;
function getFloat32ArrayMemory0() {
    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
    }
    return cachedFloat32ArrayMemory0;
}

let cachedFloat64ArrayMemory0 = null;
function getFloat64ArrayMemory0() {
    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
    }
    return cachedFloat64ArrayMemory0;
}

let cachedInt16ArrayMemory0 = null;
function getInt16ArrayMemory0() {
    if (cachedInt16ArrayMemory0 === null || cachedInt16ArrayMemory0.byteLength === 0) {
        cachedInt16ArrayMemory0 = new Int16Array(wasm.memory.buffer);
    }
    return cachedInt16ArrayMemory0;
}

let cachedInt32ArrayMemory0 = null;
function getInt32ArrayMemory0() {
    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
    }
    return cachedInt32ArrayMemory0;
}

function getStringFromWasm0(ptr, len) {
    return decodeText(ptr >>> 0, len);
}

let cachedUint16ArrayMemory0 = null;
function getUint16ArrayMemory0() {
    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
    }
    return cachedUint16ArrayMemory0;
}

let cachedUint32ArrayMemory0 = null;
function getUint32ArrayMemory0() {
    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
    }
    return cachedUint32ArrayMemory0;
}

let cachedUint8ArrayMemory0 = null;
function getUint8ArrayMemory0() {
    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachedUint8ArrayMemory0;
}

function getObject(idx) { return heap[idx]; }

function handleError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        wasm.__wbindgen_export3(addHeapObject(e));
    }
}

let heap = new Array(1024).fill(undefined);
heap.push(undefined, null, true, false);

let heap_next = heap.length;

function isLikeNone(x) {
    return x === undefined || x === null;
}

function passArray16ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 2, 2) >>> 0;
    getUint16ArrayMemory0().set(arg, ptr / 2);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArray32ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 4, 4) >>> 0;
    getUint32ArrayMemory0().set(arg, ptr / 4);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArray64ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 8, 8) >>> 0;
    getBigUint64ArrayMemory0().set(arg, ptr / 8);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArray8ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 1, 1) >>> 0;
    getUint8ArrayMemory0().set(arg, ptr / 1);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArrayF32ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 4, 4) >>> 0;
    getFloat32ArrayMemory0().set(arg, ptr / 4);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArrayF64ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 8, 8) >>> 0;
    getFloat64ArrayMemory0().set(arg, ptr / 8);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArrayJsValueToWasm0(array, malloc) {
    const ptr = malloc(array.length * 4, 4) >>> 0;
    const mem = getDataViewMemory0();
    for (let i = 0; i < array.length; i++) {
        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
    }
    WASM_VECTOR_LEN = array.length;
    return ptr;
}

function passStringToWasm0(arg, malloc, realloc) {
    if (realloc === undefined) {
        const buf = cachedTextEncoder.encode(arg);
        const ptr = malloc(buf.length, 1) >>> 0;
        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr;
    }

    let len = arg.length;
    let ptr = malloc(len, 1) >>> 0;

    const mem = getUint8ArrayMemory0();

    let offset = 0;

    for (; offset < len; offset++) {
        const code = arg.charCodeAt(offset);
        if (code > 0x7F) break;
        mem[ptr + offset] = code;
    }
    if (offset !== len) {
        if (offset !== 0) {
            arg = arg.slice(offset);
        }
        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
        const ret = cachedTextEncoder.encodeInto(arg, view);

        offset += ret.written;
        ptr = realloc(ptr, len, offset, 1) >>> 0;
    }

    WASM_VECTOR_LEN = offset;
    return ptr;
}

let stack_pointer = 1024;

function takeObject(idx) {
    const ret = getObject(idx);
    dropObject(idx);
    return ret;
}

let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
cachedTextDecoder.decode();
const MAX_SAFARI_DECODE_BYTES = 2146435072;
let numBytesDecoded = 0;
function decodeText(ptr, len) {
    numBytesDecoded += len;
    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
        cachedTextDecoder.decode();
        numBytesDecoded = len;
    }
    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}

const cachedTextEncoder = new TextEncoder();

if (!('encodeInto' in cachedTextEncoder)) {
    cachedTextEncoder.encodeInto = function (arg, view) {
        const buf = cachedTextEncoder.encode(arg);
        view.set(buf);
        return {
            read: arg.length,
            written: buf.length
        };
    };
}

let WASM_VECTOR_LEN = 0;

let wasmModule, wasmInstance, wasm;
function __wbg_finalize_init(instance, module) {
    wasmInstance = instance;
    wasm = instance.exports;
    wasmModule = module;
    cachedBigInt64ArrayMemory0 = null;
    cachedBigUint64ArrayMemory0 = null;
    cachedDataViewMemory0 = null;
    cachedFloat32ArrayMemory0 = null;
    cachedFloat64ArrayMemory0 = null;
    cachedInt16ArrayMemory0 = null;
    cachedInt32ArrayMemory0 = null;
    cachedUint16ArrayMemory0 = null;
    cachedUint32ArrayMemory0 = null;
    cachedUint8ArrayMemory0 = null;
    return wasm;
}

async function __wbg_load(module, imports) {
    if (typeof Response === 'function' && module instanceof Response) {
        if (!module.ok) {
            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
        }

        if (typeof WebAssembly.instantiateStreaming === 'function') {
            try {
                return await WebAssembly.instantiateStreaming(module, imports);
            } catch (e) {
                const validResponse = expectedResponseType(module.type);

                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

                } else { throw e; }
            }
        }

        const bytes = await module.arrayBuffer();
        return await WebAssembly.instantiate(bytes, imports);
    } else {
        const instance = await WebAssembly.instantiate(module, imports);

        if (instance instanceof WebAssembly.Instance) {
            return { instance, module };
        } else {
            return instance;
        }
    }

    function expectedResponseType(type) {
        switch (type) {
            case 'basic': case 'cors': case 'default': return true;
        }
        return false;
    }
}

function initSync(module) {
    if (wasm !== undefined) return wasm;


    if (module !== undefined) {
        if (Object.getPrototypeOf(module) === Object.prototype) {
            ({module} = module)
        } else {
            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
        }
    }

    const imports = __wbg_get_imports();
    if (!(module instanceof WebAssembly.Module)) {
        module = new WebAssembly.Module(module);
    }
    const instance = new WebAssembly.Instance(module, imports);
    return __wbg_finalize_init(instance, module);
}

async function __wbg_init(module_or_path) {
    if (wasm !== undefined) return wasm;


    if (module_or_path !== undefined) {
        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
            ({module_or_path} = module_or_path)
        } else {
            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
        }
    }

    if (module_or_path === undefined) {
        module_or_path = new URL('wai_web_bg.wasm', import.meta.url);
    }
    const imports = __wbg_get_imports();

    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
        module_or_path = fetch(module_or_path);
    }

    const { instance, module } = await __wbg_load(await module_or_path, imports);

    return __wbg_finalize_init(instance, module);
}

export { initSync, __wbg_init as default };