@blockcast/mmt-wasm 0.0.0-stage → 0.1.0

package/pkg-no-modules/mmt_wasm.js

@@ -0,0 +1,3018 @@
+let wasm_bindgen;
+(function() {
+    const __exports = {};
+    let script_src;
+    if (typeof document !== 'undefined' && document.currentScript !== null) {
+        script_src = new URL(document.currentScript.src, location.href).toString();
+    }
+    let wasm = undefined;
+
+    function addToExternrefTable0(obj) {
+        const idx = wasm.__externref_table_alloc();
+        wasm.__wbindgen_externrefs.set(idx, obj);
+        return idx;
+    }
+
+    function _assertClass(instance, klass) {
+        if (!(instance instanceof klass)) {
+            throw new Error(`expected instance of ${klass.name}`);
+        }
+    }
+
+    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 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 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;
+    }
+
+    function getStringFromWasm0(ptr, len) {
+        ptr = ptr >>> 0;
+        return decodeText(ptr, len);
+    }
+
+    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 handleError(f, args) {
+        try {
+            return f.apply(this, args);
+        } catch (e) {
+            const idx = addToExternrefTable0(e);
+            wasm.__wbindgen_exn_store(idx);
+        }
+    }
+
+    function isLikeNone(x) {
+        return x === undefined || x === null;
+    }
+
+    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 passArray8ToWasm0(arg, malloc) {
+        const ptr = malloc(arg.length * 1, 1) >>> 0;
+        getUint8ArrayMemory0().set(arg, ptr / 1);
+        WASM_VECTOR_LEN = arg.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;
+    }
+
+    function takeFromExternrefTable0(idx) {
+        const value = wasm.__wbindgen_externrefs.get(idx);
+        wasm.__externref_table_dealloc(idx);
+        return value;
+    }
+
+    let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    function decodeText(ptr, 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;
+
+    const CombinedSampleJsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_combinedsamplejs_free(ptr >>> 0, 1));
+
+    const FecStatsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_fecstats_free(ptr >>> 0, 1));
+
+    const MfuFragmentJsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_mfufragmentjs_free(ptr >>> 0, 1));
+
+    const MmtFecDecoderFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_mmtfecdecoder_free(ptr >>> 0, 1));
+
+    const MmtFecEncoderFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_mmtfecencoder_free(ptr >>> 0, 1));
+
+    const MmtPacketizerFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_mmtpacketizer_free(ptr >>> 0, 1));
+
+    const MmtReassemblerFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_mmtreassembler_free(ptr >>> 0, 1));
+
+    const MmtSampleCombinerFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_mmtsamplecombiner_free(ptr >>> 0, 1));
+
+    const MoqEncodedBlockFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_moqencodedblock_free(ptr >>> 0, 1));
+
+    const MoqFecConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_moqfecconfig_free(ptr >>> 0, 1));
+
+    const MoqFecDecoderFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_moqfecdecoder_free(ptr >>> 0, 1));
+
+    const MoqFecEncoderFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_moqfecencoder_free(ptr >>> 0, 1));
+
+    const MoqFecStatsJsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_moqfecstatsjs_free(ptr >>> 0, 1));
+
+    const ReassembledMfuJsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_reassembledmfujs_free(ptr >>> 0, 1));
+
+    const ReassemblerStatsJsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_reassemblerstatsjs_free(ptr >>> 0, 1));
+
+    const RecoveredSetFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_recoveredset_free(ptr >>> 0, 1));
+
+    const SampleCombinerStatsJsFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_samplecombinerstatsjs_free(ptr >>> 0, 1));
+
+    const ShredFecBufferFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_shredfecbuffer_free(ptr >>> 0, 1));
+
+    const ShredReassemblerFinalization = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(ptr => wasm.__wbg_shredreassembler_free(ptr >>> 0, 1));
+
+    /**
+     * A sample combined from its constituent subsample data unit(s) (moqcast
+     * #37), handed back to JS by [`MmtSampleCombiner::add_mfu`].
+     */
+    class CombinedSampleJs {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(CombinedSampleJs.prototype);
+            obj.__wbg_ptr = ptr;
+            CombinedSampleJsFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            CombinedSampleJsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_combinedsamplejs_free(ptr, 0);
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get attribution() {
+            const ret = wasm.combinedsamplejs_attribution(this.__wbg_ptr);
+            return ret === 0xFFFFFF ? undefined : ret;
+        }
+        /**
+         * @returns {number}
+         */
+        get sample_number() {
+            const ret = wasm.combinedsamplejs_sample_number(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get stream_identity() {
+            const ret = wasm.combinedsamplejs_stream_identity(this.__wbg_ptr);
+            return ret === 0x100000001 ? undefined : ret;
+        }
+        /**
+         * Number of subsample data units combined (1 for a whole-sample DU or a
+         * non-timed passthrough).
+         * @returns {number}
+         */
+        get subsample_count() {
+            const ret = wasm.combinedsamplejs_subsample_count(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get mpu_sequence_number() {
+            const ret = wasm.combinedsamplejs_mpu_sequence_number(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {Uint32Array | undefined}
+         */
+        get packet_sequence_numbers() {
+            const ret = wasm.combinedsamplejs_packet_sequence_numbers(this.__wbg_ptr);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            }
+            return v1;
+        }
+        /**
+         * @returns {number}
+         */
+        get movie_fragment_sequence_number() {
+            const ret = wasm.combinedsamplejs_movie_fragment_sequence_number(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {Uint32Array | undefined}
+         */
+        get repaired_packet_sequence_numbers() {
+            const ret = wasm.combinedsamplejs_repaired_packet_sequence_numbers(this.__wbg_ptr);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            }
+            return v1;
+        }
+        /**
+         * Same pattern as [`ReassembledMfuJs::data`].
+         * @returns {Uint8Array}
+         */
+        get data() {
+            const ret = wasm.combinedsamplejs_data(this.__wbg_ptr);
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get priority() {
+            const ret = wasm.combinedsamplejs_priority(this.__wbg_ptr);
+            return ret === 0xFFFFFF ? undefined : ret;
+        }
+        /**
+         * @returns {boolean}
+         */
+        get rap_flag() {
+            const ret = wasm.combinedsamplejs_rap_flag(this.__wbg_ptr);
+            return ret !== 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get timestamp() {
+            const ret = wasm.combinedsamplejs_timestamp(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+    }
+    if (Symbol.dispose) CombinedSampleJs.prototype[Symbol.dispose] = CombinedSampleJs.prototype.free;
+    __exports.CombinedSampleJs = CombinedSampleJs;
+
+    /**
+     * FEC statistics for monitoring
+     */
+    class FecStats {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(FecStats.prototype);
+            obj.__wbg_ptr = ptr;
+            FecStatsFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            FecStatsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_fecstats_free(ptr, 0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get source_packets() {
+            const ret = wasm.__wbg_get_fecstats_source_packets(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set source_packets(arg0) {
+            wasm.__wbg_set_fecstats_source_packets(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get repair_packets() {
+            const ret = wasm.__wbg_get_fecstats_repair_packets(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set repair_packets(arg0) {
+            wasm.__wbg_set_fecstats_repair_packets(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get blocks_complete() {
+            const ret = wasm.__wbg_get_fecstats_blocks_complete(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set blocks_complete(arg0) {
+            wasm.__wbg_set_fecstats_blocks_complete(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get blocks_recovered() {
+            const ret = wasm.__wbg_get_fecstats_blocks_recovered(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set blocks_recovered(arg0) {
+            wasm.__wbg_set_fecstats_blocks_recovered(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get blocks_failed() {
+            const ret = wasm.__wbg_get_fecstats_blocks_failed(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set blocks_failed(arg0) {
+            wasm.__wbg_set_fecstats_blocks_failed(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get bytes_recovered() {
+            const ret = wasm.__wbg_get_fecstats_bytes_recovered(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set bytes_recovered(arg0) {
+            wasm.__wbg_set_fecstats_bytes_recovered(this.__wbg_ptr, arg0);
+        }
+        /**
+         * Blocks that expired with fewer than K symbols (delivery issue, not FEC issue)
+         * @returns {bigint}
+         */
+        get blocks_delivery_failed() {
+            const ret = wasm.__wbg_get_fecstats_blocks_delivery_failed(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * Blocks that expired with fewer than K symbols (delivery issue, not FEC issue)
+         * @param {bigint} arg0
+         */
+        set blocks_delivery_failed(arg0) {
+            wasm.__wbg_set_fecstats_blocks_delivery_failed(this.__wbg_ptr, arg0);
+        }
+        /**
+         * Recovery rate as percentage (0-100)
+         * Counts all blocks: complete + recovered + FEC-failed + delivery-failed
+         * @returns {number}
+         */
+        recovery_rate() {
+            const ret = wasm.fecstats_recovery_rate(this.__wbg_ptr);
+            return ret;
+        }
+        constructor() {
+            const ret = wasm.fecstats_new();
+            this.__wbg_ptr = ret >>> 0;
+            FecStatsFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+    }
+    if (Symbol.dispose) FecStats.prototype[Symbol.dispose] = FecStats.prototype.free;
+    __exports.FecStats = FecStats;
+
+    /**
+     * A timed-MFU fragment fed to [`MmtReassembler::add_fragment`].
+     *
+     * Typed (decision D-6) rather than a positional arg list or a stringly-typed
+     * bag object, so the Closure-ADVANCED externs stay type-checked and the wasm
+     * surface cannot silently drift. Built in JS from the parsed MPU/MFU header,
+     * then optionally annotated with the timed-MFU DU-header sample identity via
+     * [`with_sample_identity`](Self::with_sample_identity) before hand-off.
+     */
+    class MfuFragmentJs {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MfuFragmentJsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_mfufragmentjs_free(ptr, 0);
+        }
+        /**
+         * Attach the non-timed MFU Item_ID.
+         * @param {number} item_id
+         */
+        set_item_id(item_id) {
+            wasm.mfufragmentjs_set_item_id(this.__wbg_ptr, item_id);
+        }
+        /**
+         * Attach timed-MFU DU priority metadata.
+         * @param {number} priority
+         */
+        set_priority(priority) {
+            wasm.mfufragmentjs_set_priority(this.__wbg_ptr, priority);
+        }
+        /**
+         * Attach an opaque host attribution tag that follows the accepted frame.
+         * @param {number} attribution
+         */
+        set_attribution(attribution) {
+            wasm.mfufragmentjs_set_attribution(this.__wbg_ptr, attribution);
+        }
+        /**
+         * Attach the authored source-header packet sequence and whether FEC
+         * reconstructed it. Recovered packets must retain the original u32 value.
+         * @param {number} packet_sequence_number
+         * @param {boolean} recovered
+         */
+        set_packet_delivery(packet_sequence_number, recovered) {
+            wasm.mfufragmentjs_set_packet_delivery(this.__wbg_ptr, packet_sequence_number, recovered);
+        }
+        /**
+         * Attach an opaque host stream identity used to isolate reassembly state.
+         * @param {number} stream_identity
+         */
+        set_stream_identity(stream_identity) {
+            wasm.mfufragmentjs_set_stream_identity(this.__wbg_ptr, stream_identity);
+        }
+        /**
+         * Attach the timed-MFU DU-header sample identity (offset mode / the IFC
+         * path): `movie_fragment_sequence`, `sample_number`, byte `offset`.
+         *
+         * `offset` is this DU's authored base byte position within its sample
+         * (moqcast #37): 0 for a whole-sample DU, nonzero for one subsample DU
+         * of a partitioned sample. One `SampleIdentity`, so a fragment built
+         * through this facade always carries movie + sample + offset together
+         * (the core's folded `Option<SampleIdentity>` makes the partial hybrid
+         * unrepresentable).
+         * @param {number} movie_fragment_sequence
+         * @param {number} sample_number
+         * @param {number} offset
+         */
+        with_sample_identity(movie_fragment_sequence, sample_number, offset) {
+            wasm.mfufragmentjs_with_sample_identity(this.__wbg_ptr, movie_fragment_sequence, sample_number, offset);
+        }
+        /**
+         * Build a fragment from the MPU/MFU header fields.
+         *
+         * `data` is the fragment payload AFTER the MPU/MFU (and any DU) header has
+         * been stripped by the caller; it is copied once across the wasm boundary
+         * into an owned `Bytes`. A fragmented FI=1 start must subsequently receive
+         * timed sample identity or a non-timed Item_ID before it is added.
+         * @param {number} mpu_sequence_number
+         * @param {number} fragmentation_indicator
+         * @param {number} fragment_counter
+         * @param {Uint8Array} data
+         * @param {number} timestamp
+         * @param {boolean} rap_flag
+         */
+        constructor(mpu_sequence_number, fragmentation_indicator, fragment_counter, data, timestamp, rap_flag) {
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mfufragmentjs_new(mpu_sequence_number, fragmentation_indicator, fragment_counter, ptr0, len0, timestamp, rap_flag);
+            this.__wbg_ptr = ret >>> 0;
+            MfuFragmentJsFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+    }
+    if (Symbol.dispose) MfuFragmentJs.prototype[Symbol.dispose] = MfuFragmentJs.prototype.free;
+    __exports.MfuFragmentJs = MfuFragmentJs;
+
+    /**
+     * MMT FEC Decoder with interleaving support
+     *
+     * Handles RaptorQ FEC decoding for MMT streams with interleaved blocks
+     * to protect against burst packet loss.
+     *
+     * Uses interior mutability (RefCell) so that wasm-bindgen exports use
+     * `&self` instead of `&mut self`, preventing "recursive use of an object"
+     * panics when source and repair tracks call methods concurrently.
+     */
+    class MmtFecDecoder {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MmtFecDecoderFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_mmtfecdecoder_free(ptr, 0);
+        }
+        /**
+         * Add a repair symbol per ISO 23008-1 §C.5.3.
+         *
+         * Repair carries (SS_Start, SSB_length, RS_ID).
+         * SS_Start = SS_ID of first source in block = SBN * K.
+         * SSB_length = the authored source-symbol count in this block (1..=K).
+         * SBN = SS_Start / configured K.
+         * Repair ESI = K + RS_ID.
+         *
+         * The decoder's configured K is the fixed RaptorQ geometry. A short
+         * authored block (`SSB_length < K`) is the producer's K-symbol RaptorQ
+         * block with ESIs `SSB_length..K` zero-filled and never transmitted
+         * (fec-raptorq `InterleavedEncoder::force_complete`). The block records
+         * `SSB_length`, completes once that many source symbols arrived, and
+         * recovers from `SSB_length` received symbols by supplying the known
+         * padding itself. A conflicting `SSB_length` for one block is rejected
+         * without changing that block.
+         *
+         * Under `iso-ssbg1-v1` the block is `[SS_Start, SS_Start + SSB_length)`
+         * with `1 <= SSB_length <= K` (K is only the maximum), its RaptorQ geometry
+         * is K' = SSB_length with no padding, and repair ESI = SSB_length + RS_ID
+         * (C.5.3). The first repair defines the block and claims every held source
+         * in range. A conflicting SSB_length, or a range overlapping a different
+         * known block, is refused without changing any block. Output is the K'*T
+         * concatenated ssbg_mode1 symbols: split by T and trim by the length field.
+         * @param {number} ss_start
+         * @param {number} ssb_length
+         * @param {number} rs_id
+         * @param {Uint8Array} data
+         * @param {number} timestamp
+         * @returns {Uint8Array | undefined}
+         */
+        add_repair(ss_start, ssb_length, rs_id, data, timestamp) {
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtfecdecoder_add_repair(this.__wbg_ptr, ss_start, ssb_length, rs_id, ptr0, len0, timestamp);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            let v2;
+            if (ret[0] !== 0) {
+                v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v2;
+        }
+        /**
+         * Add a source symbol by SS_ID per ISO 23008-1 §C.5.2.
+         *
+         * SS_ID is a flat 32-bit counter. An unconfigured decoder rejects the
+         * packet.
+         *
+         * - `k-padded-v1`: derives SBN = floor(SS_ID / K), ESI = SS_ID % K and
+         *   zero-pads `data` to T.
+         * - `iso-ssbg1-v1`: builds the C.3.3 ssbg_mode1 symbol
+         *   `u16be(len) || data || zero padding` (refusing `len + 2 > T`) and
+         *   places it at ESI = serial distance from the start of the known block
+         *   whose `[SS_Start, SS_Start + SSB_length)` contains SS_ID. A source
+         *   whose block no repair has defined yet is held by SS_ID until one does.
+         *
+         * # Arguments
+         * * `ss_id` - Source symbol ID (32-bit monotonic counter)
+         * * `data` - The protected MMTP packet, without its Source FEC Payload ID
+         * * `timestamp` - Current timestamp (performance.now())
+         * @param {number} ss_id
+         * @param {Uint8Array} data
+         * @param {number} timestamp
+         * @returns {Uint8Array | undefined}
+         */
+        add_source(ss_id, data, timestamp) {
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtfecdecoder_add_source(this.__wbg_ptr, ss_id, ptr0, len0, timestamp);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            let v2;
+            if (ret[0] !== 0) {
+                v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v2;
+        }
+        /**
+         * Reset statistics
+         */
+        reset_stats() {
+            wasm.mmtfecdecoder_reset_stats(this.__wbg_ptr);
+        }
+        /**
+         * Get alignment (Al) parameter from OTI
+         * @returns {number}
+         */
+        get_alignment() {
+            const ret = wasm.mmtfecdecoder_get_alignment(this.__wbg_ptr);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0];
+        }
+        /**
+         * `k-padded-v1` only: cleanup blocks more than `interleave_depth` blocks
+         * behind `current_sbn`. Refused under `iso-ssbg1-v1`, which has no SBN
+         * (use `cleanup_by_ss_start`).
+         *
+         * Blocks are ordered by RFC 1982 serial comparison of their first SS_ID
+         * (`sbn * K mod 2^32`, ISO/IEC 23008-1 C.5.2; BLO-35597 iso:5). For a
+         * stream that has not wrapped SS_ID that is exactly the old
+         * `sbn < current_sbn - interleave_depth`; after the wrap it still retires
+         * the pre-wrap blocks instead of keeping them forever.
+         * @param {number} current_sbn
+         * @returns {Uint32Array}
+         */
+        cleanup_by_sbn(current_sbn) {
+            const ret = wasm.mmtfecdecoder_cleanup_by_sbn(this.__wbg_ptr, current_sbn);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            return v1;
+        }
+        /**
+         * Get sub-blocks (N) parameter from OTI
+         * @returns {number}
+         */
+        get_sub_blocks() {
+            const ret = wasm.mmtfecdecoder_get_sub_blocks(this.__wbg_ptr);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0];
+        }
+        /**
+         * Get number of pending blocks
+         * @returns {number}
+         */
+        pending_blocks() {
+            const ret = wasm.mmtfecdecoder_pending_blocks(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Get symbol size (T) parameter from OTI
+         * @returns {number}
+         */
+        get_symbol_size() {
+            const ret = wasm.mmtfecdecoder_get_symbol_size(this.__wbg_ptr);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0];
+        }
+        /**
+         * `iso-ssbg1-v1` only: retire the held source symbols that no repair can
+         * place any more, by the same rule as `cleanup_by_ss_start`, without
+         * retiring any block. For a caller that retires blocks itself, by their
+         * deadlines (`cleanup_blocks_detailed`), and needs only this half. Returns
+         * how many it retired.
+         * @param {number} current
+         * @returns {number}
+         */
+        retire_unplaced(current) {
+            const ret = wasm.mmtfecdecoder_retire_unplaced(this.__wbg_ptr, current);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0] >>> 0;
+        }
+        /**
+         * Configure FEC directly from catalog parameters (K, T).
+         *
+         * Preferred over `configure()` when the player has catalog-level params
+         * (fecSourceSymbols, fecSymbolSize) rather than raw 12-byte OTI.
+         * Derives F = K * T (Z=1, N=1, Al=8) per RFC 6330.
+         * @param {number} k
+         * @param {number} symbol_size
+         */
+        configure_params(k, symbol_size) {
+            const ret = wasm.mmtfecdecoder_configure_params(this.__wbg_ptr, k, symbol_size);
+            if (ret[1]) {
+                throw takeFromExternrefTable0(ret[0]);
+            }
+        }
+        /**
+         * The `fec.blockProfile` token this decoder was built for.
+         * @returns {string}
+         */
+        get_block_profile() {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                const ret = wasm.mmtfecdecoder_get_block_profile(this.__wbg_ptr);
+                deferred1_0 = ret[0];
+                deferred1_1 = ret[1];
+                return getStringFromWasm0(ret[0], ret[1]);
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }
+        /**
+         * Get source blocks (Z) parameter from OTI
+         * @returns {number}
+         */
+        get_source_blocks() {
+            const ret = wasm.mmtfecdecoder_get_source_blocks(this.__wbg_ptr);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0];
+        }
+        /**
+         * `iso-ssbg1-v1` only: retire every block, and every held source symbol,
+         * lying more than `interleave_depth` blocks behind SS_ID `current`, the
+         * newest SS_ID the caller has seen (no block start or held source follows
+         * it). A block start or held source that `current` has moved at least
+         * half the SS_ID space past no longer precedes it and is retired too
+         * (`iso_past_horizon`).
+         *
+         * Blocks have no SBN under ssbg_mode1, so distance is measured on the
+         * first SS_ID: a block starting at `s` is
+         * `serial_precedes(s, current) ? floor(serial_distance(s, current) / K) : 0`
+         * blocks behind, a lower bound because no block exceeds the configured K
+         * (`iso_blocks_behind_lower_bound`, shared with the TypeScript worker and
+         * FECManager). Returns the retired block starts.
+         * @param {number} current
+         * @returns {Uint32Array}
+         */
+        cleanup_by_ss_start(current) {
+            const ret = wasm.mmtfecdecoder_cleanup_by_ss_start(this.__wbg_ptr, current);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            return v1;
+        }
+        /**
+         * Get current interleave depth
+         * @returns {number}
+         */
+        get_interleave_depth() {
+            const ret = wasm.mmtfecdecoder_get_interleave_depth(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Finalize only the source blocks whose host-owned deadlines fired.
+         * Keys are SBNs under `k-padded-v1` and SS_Starts under `iso-ssbg1-v1`.
+         *
+         * The JavaScript FEC manager owns per-block repair grace. A timeout for one
+         * block must therefore not run the decoder's global age scan and evict a
+         * peer block that is still waiting for fetched repair.
+         * @param {Uint32Array} sbns
+         */
+        cleanup_blocks_detailed(sbns) {
+            const ptr0 = passArray32ToWasm0(sbns, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.mmtfecdecoder_cleanup_blocks_detailed(this.__wbg_ptr, ptr0, len0);
+        }
+        /**
+         * Create a new FEC decoder
+         *
+         * # Arguments
+         * * `interleave_depth` - Explicit positive number of interleaved blocks.
+         * * `block_profile` - Catalog `fec.blockProfile`: `"k-padded-v1"` or
+         *   `"iso-ssbg1-v1"`. Required; any other value is refused.
+         * @param {number} interleave_depth
+         * @param {string} block_profile
+         */
+        constructor(interleave_depth, block_profile) {
+            const ptr0 = passStringToWasm0(block_profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtfecdecoder_new(interleave_depth, ptr0, len0);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MmtFecDecoderFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * Flush all pending decoder state while preserving configuration.
+         */
+        flush() {
+            wasm.mmtfecdecoder_flush(this.__wbg_ptr);
+        }
+        /**
+         * Get K (symbols per block) derived from OTI
+         * @returns {number}
+         */
+        get_k() {
+            const ret = wasm.mmtfecdecoder_get_k(this.__wbg_ptr);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0] >>> 0;
+        }
+        /**
+         * Configure FEC from 12-byte OTI
+         *
+         * # Arguments
+         * * `oti` - 12-byte Object Transmission Information from S-TSID fecOTI
+         * @param {Uint8Array} oti
+         */
+        configure(oti) {
+            const ptr0 = passArray8ToWasm0(oti, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtfecdecoder_configure(this.__wbg_ptr, ptr0, len0);
+            if (ret[1]) {
+                throw takeFromExternrefTable0(ret[0]);
+            }
+        }
+        /**
+         * Get current statistics
+         * @returns {FecStats}
+         */
+        get_stats() {
+            const ret = wasm.mmtfecdecoder_get_stats(this.__wbg_ptr);
+            return FecStats.__wrap(ret);
+        }
+    }
+    if (Symbol.dispose) MmtFecDecoder.prototype[Symbol.dispose] = MmtFecDecoder.prototype.free;
+    __exports.MmtFecDecoder = MmtFecDecoder;
+
+    /**
+     * RaptorQ FEC encoder for one MMT source block.
+     *
+     * This is the encode counterpart of [`MmtFecDecoder`]. It promotes the
+     * previously test-only RaptorQ encoder into a shipping `#[wasm_bindgen]`
+     * export so browser ingress (WHIP / ROUTE) can generate repair symbols and
+     * emit them in the **exact** wire framing the existing decoder + FFmpeg path
+     * already agree on.
+     *
+     * ## Wire framing (the important part)
+     *
+     * Repair packets carry the ISO/IEC 23008-1 §C.5.3 Repair FEC Payload ID, NOT
+     * the bare RaptorQ packet and NOT the legacy interleaved `[block_id][symbol_id]`
+     * header from `fec-raptorq/c-bindings/src/interleave.rs` (that helper uses a
+     * *raw* block_id and is not the on-wire format). The on-wire layout — the one
+     * `packages/mmt-base/src/mmtp.ts::extractRepairFecPayloadId` parses and feeds
+     * to [`MmtFecDecoder::add_repair`] — is:
+     *
+     * ```text
+     * [SS_Start:4][RSB_length:3][RS_ID:3][SSB_length:3][repair symbol: T]
+     * ```
+     *
+     * with, for a block with Source Block Number `sbn` and `K` source symbols:
+     * - `SS_Start  = sbn * K` (32-bit) — first SS_ID of the block. The decoder
+     *   derives `SBN = SS_Start / K`, so this MUST be `sbn * K`.
+     * - `RSB_length = P`       (repair count for this block)
+     * - `RS_ID      = i`       (0-based repair index) ⇒ RaptorQ ESI = `K + i`
+     * - `SSB_length <= K`      (authored source symbols in this block)
+     *
+     * OTI (Z=1, N=1, Al=8) is delivered out-of-band via the catalog / AL-FEC
+     * signaling message — see [`MmtFecEncoder::oti`] — never per-packet.
+     *
+     * That framing is the `k-padded-v1` profile. Under `iso-ssbg1-v1` the same
+     * fields carry ISO/IEC 23008-1 C.5.3 semantics: `SS_Start` is the first SS_ID
+     * of a block of consecutive SS_IDs, `SSB_length = K'` (`1..=K`), the RaptorQ
+     * block is K' symbols with no padding (F = K'*T), and RS_ID `i` is ESI
+     * `K' + i`.
+     */
+    class MmtFecEncoder {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MmtFecEncoderFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_mmtfecencoder_free(ptr, 0);
+        }
+        /**
+         * Symbol size (T) in bytes.
+         * @returns {number}
+         */
+        get symbol_size() {
+            const ret = wasm.mmtfecencoder_symbol_size(this.__wbg_ptr);
+            return ret;
+        }
+        /**
+         * The `fec.blockProfile` token this encoder was built for.
+         * @returns {string}
+         */
+        get block_profile() {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                const ret = wasm.mmtfecencoder_block_profile(this.__wbg_ptr);
+                deferred1_0 = ret[0];
+                deferred1_1 = ret[1];
+                return getStringFromWasm0(ret[0], ret[1]);
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }
+        /**
+         * Encode `repair_count` repair symbols for one source block and return them
+         * framed per ISO/IEC 23008-1 §C.5.3, concatenated into one flat buffer.
+         *
+         * Each entry is `REPAIR_FEC_PID_SIZE + symbol_size` bytes:
+         * `[SS_Start:4][RSB_length:3][RS_ID:3][SSB_length:3][symbol: T]`.
+         * Callers split on that stride; `entry i` is at `i * (13 + T)`.
+         *
+         * `k-padded-v1`: `block` is the Source Block Number and `source_block`
+         * MUST be exactly `K * symbol_size` bytes — the caller pads the final
+         * (short) block with zeros, mirroring `InterleavedEncoder` and the FFmpeg
+         * path. `SS_Start = block * K` (wrapping), `SSB_length = K`.
+         *
+         * `iso-ssbg1-v1`: `block` is the SS_Start (the block's first SS_ID) and
+         * `source_block` is the block's K' ssbg_mode1 symbols (`1 <= K' <= K`,
+         * `len % T == 0`, each a well-formed C.3.3 symbol). RaptorQ runs over K'
+         * symbols (F = K'*T) and `SSB_length = K'`.
+         *
+         * # Arguments
+         * * `block`        - SBN (`k-padded-v1`) or SS_Start (`iso-ssbg1-v1`).
+         * * `source_block` - The block's source symbols, as described above.
+         * * `repair_count` - Number of repair symbols (P) to generate.
+         * @param {number} block
+         * @param {Uint8Array} source_block
+         * @param {number} repair_count
+         * @returns {Uint8Array}
+         */
+        encode_repair(block, source_block, repair_count) {
+            const ptr0 = passArray8ToWasm0(source_block, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtfecencoder_encode_repair(this.__wbg_ptr, block, ptr0, len0, repair_count);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v2;
+        }
+        /**
+         * Source symbols per block (K).
+         * @returns {number}
+         */
+        get k() {
+            const ret = wasm.mmtfecencoder_k(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Create an encoder for a fixed `(K, symbol_size)` block geometry.
+         *
+         * Builds the OTI as `ObjectTransmissionInformation::new(K*T, T, 1, 1, 8)`
+         * (single source block, single sub-block, byte alignment) — matching the
+         * decoder's recovery model in [`FecBlock::try_decode`] — and pre-computes
+         * the shared `SourceBlockEncodingPlan` so per-block encoding is cheap.
+         *
+         * `block_profile` is the catalog `fec.blockProfile` (`"k-padded-v1"` or
+         * `"iso-ssbg1-v1"`); any other value is refused. Under `iso-ssbg1-v1`, K
+         * is the maximum SSB_length.
+         * @param {number} k
+         * @param {number} symbol_size
+         * @param {string} block_profile
+         */
+        constructor(k, symbol_size, block_profile) {
+            const ptr0 = passStringToWasm0(block_profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtfecencoder_new(k, symbol_size, ptr0, len0);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MmtFecEncoderFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * The configured 12-byte OTI (RFC 6330 §3.3.2 Common FEC OTI).
+         *
+         * Publishers (BLO-8975 / BLO-8990 catalog-gen) emit this so the player's
+         * [`MmtFecDecoder::configure`] reconstructs identical block geometry. The
+         * bytes round-trip exactly through `OtiParams::from_bytes`.
+         * @returns {Uint8Array}
+         */
+        oti() {
+            const ret = wasm.mmtfecencoder_oti(this.__wbg_ptr);
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+    }
+    if (Symbol.dispose) MmtFecEncoder.prototype[Symbol.dispose] = MmtFecEncoder.prototype.free;
+    __exports.MmtFecEncoder = MmtFecEncoder;
+
+    /**
+     * MMT MPU fragment type (ISO/IEC 23008-1 MPU fragmentation), exposed to JS as
+     * a u8-backed enum. Mirrors `mmt_core::header::FragmentType`.
+     * @enum {0 | 1 | 2}
+     */
+    const MmtFragmentType = Object.freeze({
+        /**
+         * Initialization segment (ftyp + moov).
+         */
+        Init: 0, "0": "Init",
+        /**
+         * Movie fragment (moof + mdat).
+         */
+        Fragment: 1, "1": "Fragment",
+        /**
+         * Media Fragment Unit (individual samples / NAL units).
+         */
+        Mfu: 2, "2": "Mfu",
+    });
+    __exports.MmtFragmentType = MmtFragmentType;
+
+    /**
+     * MMTP packetizer — the encode counterpart to the browser's MMTP receive path.
+     *
+     * Thin `#[wasm_bindgen]` wrapper over `mmt_core::MmtPacketizer` so browser
+     * ingress (WHIP / ROUTE — BLO-8975 / BLO-8990) and native producers use the
+     * same MMTP/MPU + MFU packet framing and MTU-fragmentation implementation.
+     */
+    class MmtPacketizer {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MmtPacketizerFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_mmtpacketizer_free(ptr, 0);
+        }
+        /**
+         * Maximum MFU payload bytes per packet at this MTU (MTU minus MMTP+MPU+MFU
+         * header overhead). Use this to size access-unit fragments before
+         * `build_mfu`.
+         * @returns {number}
+         */
+        get max_payload() {
+            const ret = wasm.mmtpacketizer_max_payload(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Configured MTU.
+         * @returns {number}
+         */
+        get mtu() {
+            const ret = wasm.mmtpacketizer_mtu(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Create a packetizer for the given link MTU (bytes).
+         *
+         * Errors if `mtu` is too small to leave any room for the MMTP/MPU/MFU
+         * header overhead (i.e. `max_payload` would be 0) — otherwise `fragment()`
+         * could never make progress. Callers in the ingress arms (BLO-8975 /
+         * BLO-8990) get a clear error here instead of a hung JS thread.
+         * @param {number} mtu
+         */
+        constructor(mtu) {
+            const ret = wasm.mmtpacketizer_new(mtu);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MmtPacketizerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * MTU-fragment `payload`, returning fragment boundary offsets as a flat
+         * `[0, b1, b2, ..., payload.len()]` (count + 1 entries). Fragment `i` is
+         * `payload[offsets[i]..offsets[i+1]]`.
+         *
+         * Returns offsets rather than `Vec<Vec<u8>>` so JS slices the original
+         * buffer zero-copy (`payload.subarray(offsets[i], offsets[i+1])`) instead
+         * of paying one copy per fragment across the wasm boundary. An empty
+         * payload yields `[0]` (zero fragments).
+         * @param {Uint8Array} payload
+         * @returns {Uint32Array}
+         */
+        fragment(payload) {
+            const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtpacketizer_fragment(this.__wbg_ptr, ptr0, len0);
+            var v2 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            return v2;
+        }
+        /**
+         * Build one complete MFU packet (MMTP + MPU + MFU headers + `sample_data`)
+         * and return its bytes.
+         * @param {number} packet_id
+         * @param {number} mpu_sequence
+         * @param {number} movie_fragment_sequence
+         * @param {number} sample_number
+         * @param {Uint8Array} sample_data
+         * @param {boolean} rap_flag
+         * @returns {Uint8Array}
+         */
+        build_mfu(packet_id, mpu_sequence, movie_fragment_sequence, sample_number, sample_data, rap_flag) {
+            const ptr0 = passArray8ToWasm0(sample_data, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtpacketizer_build_mfu(this.__wbg_ptr, packet_id, mpu_sequence, movie_fragment_sequence, sample_number, ptr0, len0, rap_flag);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v2;
+        }
+        /**
+         * Build one complete MPU packet (MMTP header + MPU header + `payload`) and
+         * return its bytes. `fragment_type` selects Init / Fragment / Mfu framing.
+         * @param {number} packet_id
+         * @param {number} mpu_sequence
+         * @param {MmtFragmentType} fragment_type
+         * @param {Uint8Array} payload
+         * @param {boolean} rap_flag
+         * @returns {Uint8Array}
+         */
+        build_mpu(packet_id, mpu_sequence, fragment_type, payload, rap_flag) {
+            const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.mmtpacketizer_build_mpu(this.__wbg_ptr, packet_id, mpu_sequence, fragment_type, ptr0, len0, rap_flag);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v2;
+        }
+    }
+    if (Symbol.dispose) MmtPacketizer.prototype[Symbol.dispose] = MmtPacketizer.prototype.free;
+    __exports.MmtPacketizer = MmtPacketizer;
+
+    /**
+     * MMT timed-MFU reassembler — a `#[wasm_bindgen]` facade over the generic IFC
+     * engine.
+     *
+     * Interior mutability (`RefCell`) so the exports take `&self` — required because
+     * the engine's `add_fragment` / `cleanup_timeouts` / `flush` are `&mut self`.
+     * Unlike [`MmtFecDecoder`] (two concurrent tracks → `try_borrow_mut` to skip a
+     * re-entrant overlap), the reassembler has a single sequential caller (the MMTP
+     * parse loop), so `borrow_mut` is used directly: a re-entrant call is a genuine
+     * bug and should panic loudly rather than silently drop a fragment
+     * (error-on-bad-state, no silent fallback).
+     */
+    class MmtReassembler {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(MmtReassembler.prototype);
+            obj.__wbg_ptr = ptr;
+            MmtReassemblerFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MmtReassemblerFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_mmtreassembler_free(ptr, 0);
+        }
+        /**
+         * Create a CLOCK-FREE reassembler — no timeout, with generic buffers and
+         * authored active and continuation-only run state bounded by `max_buffered`. For hosts with no
+         * monotonic clock that never call [`cleanup_timeouts`](Self::cleanup_timeouts),
+         * there is no `timeout_ms` to supply, so none is invented. `max_buffered` is
+         * REQUIRED, derived from the catalog (rejects `0`).
+         *
+         * Exposed to JS as the static `MmtReassembler.clock_free(max_buffered)`.
+         * @param {number} max_buffered
+         * @returns {MmtReassembler}
+         */
+        static clock_free(max_buffered) {
+            const ret = wasm.mmtreassembler_clock_free(max_buffered);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return MmtReassembler.__wrap(ret[0]);
+        }
+        /**
+         * Switch to a catalog/in-band-derived numeric deadline without dropping
+         * in-flight MFUs.
+         * @param {number} timeout_ms
+         */
+        set_timeout(timeout_ms) {
+            const ret = wasm.mmtreassembler_set_timeout(this.__wbg_ptr, timeout_ms);
+            if (ret[1]) {
+                throw takeFromExternrefTable0(ret[0]);
+            }
+        }
+        /**
+         * Add a fragment. A valid incomplete data unit returns `null`; a completed
+         * one returns its MFU. Malformed or conflicting authored state throws a JS
+         * `Error` whose stable `code` property is the core rejection code.
+         *
+         * `now` is `performance.now()` (ms), floored to the engine clock (D-1).
+         * Consumes `fragment`.
+         * @param {number} now
+         * @param {MfuFragmentJs} fragment
+         * @returns {ReassembledMfuJs | undefined}
+         */
+        add_fragment(now, fragment) {
+            _assertClass(fragment, MfuFragmentJs);
+            var ptr0 = fragment.__destroy_into_raw();
+            const ret = wasm.mmtreassembler_add_fragment(this.__wbg_ptr, now, ptr0);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0] === 0 ? undefined : ReassembledMfuJs.__wrap(ret[0]);
+        }
+        /**
+         * Drop one stream's buffered and dedup state without disturbing other
+         * tracks sharing this reassembler instance.
+         * @param {number} stream_identity
+         */
+        reset_stream(stream_identity) {
+            wasm.mmtreassembler_reset_stream(this.__wbg_ptr, stream_identity);
+        }
+        /**
+         * Number of incomplete objects currently buffered.
+         * @returns {number}
+         */
+        get buffered_count() {
+            const ret = wasm.mmtreassembler_buffered_count(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Switch to reliable-MoQ clock-free operation without dropping in-flight MFUs.
+         */
+        set_clock_free() {
+            wasm.mmtreassembler_set_clock_free(this.__wbg_ptr);
+        }
+        /**
+         * Earliest absolute `performance.now()` millisecond tick requiring cleanup.
+         * @returns {number | undefined}
+         */
+        next_timeout_at() {
+            const ret = wasm.mmtreassembler_next_timeout_at(this.__wbg_ptr);
+            return ret[0] === 0 ? undefined : ret[1];
+        }
+        /**
+         * Expire incomplete objects past the timeout and enforce the memory limit.
+         * The host drives this — see the constructor note.
+         * @param {number} now
+         */
+        cleanup_timeouts(now) {
+            wasm.mmtreassembler_cleanup_timeouts(this.__wbg_ptr, now);
+        }
+        /**
+         * Fragments retained across all incomplete objects.
+         * @returns {number}
+         */
+        get pending_fragment_count() {
+            const ret = wasm.mmtreassembler_pending_fragment_count(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Create a reassembler. Both args are REQUIRED — no defaults.
+         *
+         * The caller derives them from the catalog (timeout from the FEC interleave
+         * span; `max_buffered` from the count of concurrent in-flight samples),
+         * never a literal. The constructor rejects `0` for either: the engine's own
+         * `new` currently accepts `0` and then silently breaks reassembly
+         * (`max_buffered = 0` evicts every buffer on each `cleanup_timeouts`), so the
+         * facade refuses it at the boundary.
+         *
+         * * `timeout_ms` — incomplete-MFU timeout in ms (> 0).
+         * * `max_buffered` — max concurrent incomplete objects (> 0).
+         *
+         * `max_buffered` is enforced eagerly on every `add_fragment`; active and
+         * continuation-only producer runs share the bound, and a distinct new run
+         * throws `active-data-unit-limit` at capacity.
+         * `timeout_ms` adds time-based expiry of permanently-incomplete (tail-lost)
+         * MFUs, which the host activates by driving
+         * [`cleanup_timeouts`](Self::cleanup_timeouts) periodically. A host with no
+         * clock should use [`clock_free`](Self::clock_free).
+         * @param {number} timeout_ms
+         * @param {number} max_buffered
+         */
+        constructor(timeout_ms, max_buffered) {
+            const ret = wasm.mmtreassembler_new(timeout_ms, max_buffered);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MmtReassemblerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * Drop all buffered fragments and dedup state (call on stream end / seek).
+         */
+        flush() {
+            wasm.mmtreassembler_flush(this.__wbg_ptr);
+        }
+        /**
+         * Flush buffered state and zero statistics.
+         */
+        reset() {
+            wasm.mmtreassembler_reset(this.__wbg_ptr);
+        }
+        /**
+         * Statistics snapshot.
+         * @returns {ReassemblerStatsJs}
+         */
+        stats() {
+            const ret = wasm.mmtreassembler_stats(this.__wbg_ptr);
+            return ReassemblerStatsJs.__wrap(ret);
+        }
+    }
+    if (Symbol.dispose) MmtReassembler.prototype[Symbol.dispose] = MmtReassembler.prototype.free;
+    __exports.MmtReassembler = MmtReassembler;
+
+    /**
+     * Combines subsample data units of one sample (moqcast #37) into a
+     * contiguous whole — a `#[wasm_bindgen]` facade over
+     * [`mmt_core::reassembler::SampleCombiner`]. Each constituent data unit is
+     * first reassembled independently by [`MmtReassembler`]; feed its output
+     * here to combine subsample-partitioned samples back into one elementary
+     * stream sample.
+     *
+     * Interior mutability (`RefCell`) so the exports take `&self`, mirroring
+     * [`MmtReassembler`]. The host supplies `now` (`performance.now()` ms) for
+     * timeout bookkeeping, matching the reassembler's clock-injected shape --
+     * this module adds no independent timer tier.
+     */
+    class MmtSampleCombiner {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MmtSampleCombinerFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_mmtsamplecombiner_free(ptr, 0);
+        }
+        /**
+         * Drop one stream's buffered and registered-size state without
+         * disturbing other streams sharing this combiner instance.
+         * @param {number} stream_identity
+         */
+        reset_stream(stream_identity) {
+            wasm.mmtsamplecombiner_reset_stream(this.__wbg_ptr, stream_identity);
+        }
+        /**
+         * Number of incomplete samples currently buffered.
+         * @returns {number}
+         */
+        get pending_count() {
+            const ret = wasm.mmtsamplecombiner_pending_count(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Discard samples whose oldest held segment has waited past
+         * `timeout_ms`. The host drives this, mirroring
+         * [`MmtReassembler::cleanup_timeouts`].
+         * @param {number} now
+         * @param {number} timeout_ms
+         */
+        cleanup_timeouts(now, timeout_ms) {
+            wasm.mmtsamplecombiner_cleanup_timeouts(this.__wbg_ptr, now, timeout_ms);
+        }
+        /**
+         * Register the authored sample size from the host's own FT=1
+         * (movie-fragment-metadata) parse. `stream_identity` is `None` for a
+         * single-stream host.
+         * @param {number | null | undefined} stream_identity
+         * @param {number} mpu_sequence_number
+         * @param {number} movie_fragment_sequence_number
+         * @param {number} sample_number
+         * @param {number} size
+         * @returns {CombinedSampleJs | undefined}
+         */
+        register_authored_size(stream_identity, mpu_sequence_number, movie_fragment_sequence_number, sample_number, size) {
+            const ret = wasm.mmtsamplecombiner_register_authored_size(this.__wbg_ptr, isLikeNone(stream_identity) ? 0x100000001 : (stream_identity) >>> 0, mpu_sequence_number, movie_fragment_sequence_number, sample_number, size);
+            return ret === 0 ? undefined : CombinedSampleJs.__wrap(ret);
+        }
+        /**
+         * * `max_buffered` — max concurrent incomplete samples (> 0), derived from
+         *   the catalog (e.g. concurrent in-flight samples across tracks). A full
+         *   table evicts its oldest sample by insertion order, so one lost
+         *   subsample data unit cannot wedge every later sample.
+         * * `require_authored_size` — when true, an offset-zero data unit with no
+         *   registered authored size waits for one instead of passing through as
+         *   a whole sample. Pass true when the host always drives FT=1 into
+         *   `register_authored_size`; false keeps the pre-moqcast-#37
+         *   immediate-passthrough shape.
+         * * `max_segments_per_sample` — max subsample data units held for one
+         *   sample at once (> 0).
+         * @param {number} max_buffered
+         * @param {boolean} require_authored_size
+         * @param {number} max_segments_per_sample
+         */
+        constructor(max_buffered, require_authored_size, max_segments_per_sample) {
+            const ret = wasm.mmtsamplecombiner_new(max_buffered, require_authored_size, max_segments_per_sample);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MmtSampleCombinerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * Drop all buffered subsample state (call on stream end / seek).
+         */
+        flush() {
+            wasm.mmtsamplecombiner_flush(this.__wbg_ptr);
+        }
+        /**
+         * Statistics snapshot.
+         * @returns {SampleCombinerStatsJs}
+         */
+        stats() {
+            const ret = wasm.mmtsamplecombiner_stats(this.__wbg_ptr);
+            return SampleCombinerStatsJs.__wrap(ret);
+        }
+        /**
+         * Add one reassembled data unit (from [`MmtReassembler::add_fragment`]).
+         * Returns the combined sample once every constituent data unit has
+         * arrived and totals the authored size. `now` is `performance.now()`
+         * (ms), floored to the engine clock (D-1). Consumes `mfu`.
+         * @param {number} now
+         * @param {ReassembledMfuJs} mfu
+         * @returns {CombinedSampleJs | undefined}
+         */
+        add_mfu(now, mfu) {
+            _assertClass(mfu, ReassembledMfuJs);
+            var ptr0 = mfu.__destroy_into_raw();
+            const ret = wasm.mmtsamplecombiner_add_mfu(this.__wbg_ptr, now, ptr0);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return ret[0] === 0 ? undefined : CombinedSampleJs.__wrap(ret[0]);
+        }
+    }
+    if (Symbol.dispose) MmtSampleCombiner.prototype[Symbol.dispose] = MmtSampleCombiner.prototype.free;
+    __exports.MmtSampleCombiner = MmtSampleCombiner;
+
+    /**
+     * One encoded MoQ block and its immutable source/repair symbol fixtures.
+     */
+    class MoqEncodedBlock {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(MoqEncodedBlock.prototype);
+            obj.__wbg_ptr = ptr;
+            MoqEncodedBlockFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MoqEncodedBlockFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_moqencodedblock_free(ptr, 0);
+        }
+        /**
+         * @returns {number}
+         */
+        get original_len() {
+            const ret = wasm.moqencodedblock_original_len(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @param {number} index
+         * @returns {Uint8Array | undefined}
+         */
+        getRepairSymbol(index) {
+            const ret = wasm.moqencodedblock_getRepairSymbol(this.__wbg_ptr, index);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v1;
+        }
+        /**
+         * @param {number} index
+         * @returns {Uint8Array | undefined}
+         */
+        getSourceSymbol(index) {
+            const ret = wasm.moqencodedblock_getSourceSymbol(this.__wbg_ptr, index);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v1;
+        }
+        /**
+         * @returns {number}
+         */
+        repairSymbolCount() {
+            const ret = wasm.moqencodedblock_repairSymbolCount(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        sourceSymbolCount() {
+            const ret = wasm.moqencodedblock_sourceSymbolCount(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get k() {
+            const ret = wasm.moqencodedblock_k(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get p() {
+            const ret = wasm.combinedsamplejs_mpu_sequence_number(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {Uint8Array}
+         */
+        getOti() {
+            const ret = wasm.moqencodedblock_getOti(this.__wbg_ptr);
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+        /**
+         * @returns {number}
+         */
+        get block_id() {
+            const ret = wasm.moqencodedblock_block_id(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+    }
+    if (Symbol.dispose) MoqEncodedBlock.prototype[Symbol.dispose] = MoqEncodedBlock.prototype.free;
+    __exports.MoqEncodedBlock = MoqEncodedBlock;
+
+    /**
+     * Versioned MoQ FEC configuration exposed to browser consumers.
+     */
+    class MoqFecConfig {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MoqFecConfigFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_moqfecconfig_free(ptr, 0);
+        }
+        /**
+         * @returns {number}
+         */
+        get symbol_size() {
+            const ret = wasm.moqfecconfig_symbol_size(this.__wbg_ptr);
+            return ret;
+        }
+        /**
+         * @returns {number}
+         */
+        maxBlockSize() {
+            const ret = wasm.moqfecconfig_maxBlockSize(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        overheadRatio() {
+            const ret = wasm.moqfecconfig_overheadRatio(this.__wbg_ptr);
+            return ret;
+        }
+        /**
+         * @returns {number}
+         */
+        get interleaveDepth() {
+            const ret = wasm.moqfecconfig_interleaveDepth(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get k() {
+            const ret = wasm.moqfecconfig_k(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get p() {
+            const ret = wasm.moqfecconfig_p(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @param {number} symbol_size
+         * @param {number} k
+         * @param {number} p
+         * @param {number} interleave_depth
+         */
+        constructor(symbol_size, k, p, interleave_depth) {
+            const ret = wasm.moqfecconfig_new(symbol_size, k, p, interleave_depth);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MoqFecConfigFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+    }
+    if (Symbol.dispose) MoqFecConfig.prototype[Symbol.dispose] = MoqFecConfig.prototype.free;
+    __exports.MoqFecConfig = MoqFecConfig;
+
+    /**
+     * Versioned browser-side MoQ FEC decoder.
+     */
+    class MoqFecDecoder {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MoqFecDecoderFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_moqfecdecoder_free(ptr, 0);
+        }
+        /**
+         * @param {number} block_id
+         */
+        resetBlock(block_id) {
+            const ret = wasm.moqfecdecoder_resetBlock(this.__wbg_ptr, block_id);
+            if (ret[1]) {
+                throw takeFromExternrefTable0(ret[0]);
+            }
+        }
+        /**
+         * @param {number} block_id
+         * @returns {Uint8Array}
+         */
+        getBlockData(block_id) {
+            const ret = wasm.moqfecdecoder_getBlockData(this.__wbg_ptr, block_id);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+        /**
+         * @param {number} block_id
+         * @param {number} esi
+         * @param {Uint8Array} symbol
+         * @returns {Uint8Array | undefined}
+         */
+        addRepairSymbol(block_id, esi, symbol) {
+            const ptr0 = passArray8ToWasm0(symbol, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.moqfecdecoder_addRepairSymbol(this.__wbg_ptr, block_id, esi, ptr0, len0);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            let v2;
+            if (ret[0] !== 0) {
+                v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v2;
+        }
+        /**
+         * @param {number} block_id
+         * @param {number} esi
+         * @param {Uint8Array} symbol
+         * @param {number | null} [original_len]
+         * @returns {Uint8Array | undefined}
+         */
+        addSourceSymbol(block_id, esi, symbol, original_len) {
+            const ptr0 = passArray8ToWasm0(symbol, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.moqfecdecoder_addSourceSymbol(this.__wbg_ptr, block_id, esi, ptr0, len0, isLikeNone(original_len) ? 0x100000001 : (original_len) >>> 0);
+            if (ret[3]) {
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            let v2;
+            if (ret[0] !== 0) {
+                v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v2;
+        }
+        /**
+         * @param {number} block_id
+         * @returns {boolean}
+         */
+        isBlockComplete(block_id) {
+            const ret = wasm.moqfecdecoder_isBlockComplete(this.__wbg_ptr, block_id);
+            return ret !== 0;
+        }
+        /**
+         * @param {MoqFecConfig} config
+         * @param {Uint8Array} oti
+         */
+        constructor(config, oti) {
+            _assertClass(config, MoqFecConfig);
+            const ptr0 = passArray8ToWasm0(oti, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.moqfecdecoder_new(config.__wbg_ptr, ptr0, len0);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MoqFecDecoderFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * @returns {MoqFecStatsJs}
+         */
+        getStats() {
+            const ret = wasm.moqfecdecoder_getStats(this.__wbg_ptr);
+            return MoqFecStatsJs.__wrap(ret);
+        }
+    }
+    if (Symbol.dispose) MoqFecDecoder.prototype[Symbol.dispose] = MoqFecDecoder.prototype.free;
+    __exports.MoqFecDecoder = MoqFecDecoder;
+
+    /**
+     * Versioned browser-side MoQ FEC encoder.
+     */
+    class MoqFecEncoder {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MoqFecEncoderFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_moqfecencoder_free(ptr, 0);
+        }
+        /**
+         * @returns {number}
+         */
+        blockCount() {
+            const ret = wasm.moqfecencoder_blockCount(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @param {Uint8Array} data
+         * @returns {MoqEncodedBlock}
+         */
+        encodeBlock(data) {
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.moqfecencoder_encodeBlock(this.__wbg_ptr, ptr0, len0);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            return MoqEncodedBlock.__wrap(ret[0]);
+        }
+        /**
+         * @param {MoqFecConfig} config
+         */
+        constructor(config) {
+            _assertClass(config, MoqFecConfig);
+            const ret = wasm.moqfecencoder_new(config.__wbg_ptr);
+            if (ret[2]) {
+                throw takeFromExternrefTable0(ret[1]);
+            }
+            this.__wbg_ptr = ret[0] >>> 0;
+            MoqFecEncoderFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * @returns {Uint8Array}
+         */
+        getOti() {
+            const ret = wasm.moqfecencoder_getOti(this.__wbg_ptr);
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+    }
+    if (Symbol.dispose) MoqFecEncoder.prototype[Symbol.dispose] = MoqFecEncoder.prototype.free;
+    __exports.MoqFecEncoder = MoqFecEncoder;
+
+    /**
+     * Snapshot of MoQ FEC decoder counters.
+     */
+    class MoqFecStatsJs {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(MoqFecStatsJs.prototype);
+            obj.__wbg_ptr = ptr;
+            MoqFecStatsJsFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            MoqFecStatsJsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_moqfecstatsjs_free(ptr, 0);
+        }
+        /**
+         * @returns {number}
+         */
+        recoveryRate() {
+            const ret = wasm.moqfecstatsjs_recoveryRate(this.__wbg_ptr);
+            return ret;
+        }
+        /**
+         * @returns {number}
+         */
+        get blocksComplete() {
+            const ret = wasm.moqfecconfig_k(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get interleaveDepth() {
+            const ret = wasm.moqfecstatsjs_interleaveDepth(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get blocksIncomplete() {
+            const ret = wasm.moqfecconfig_p(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        effectiveLossRate() {
+            const ret = wasm.moqfecstatsjs_effectiveLossRate(this.__wbg_ptr);
+            return ret;
+        }
+        /**
+         * @returns {number}
+         */
+        get k() {
+            const ret = wasm.moqfecstatsjs_k(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get p() {
+            const ret = wasm.moqfecstatsjs_p(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get totalSymbolsReceived() {
+            const ret = wasm.moqfecconfig_interleaveDepth(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+    }
+    if (Symbol.dispose) MoqFecStatsJs.prototype[Symbol.dispose] = MoqFecStatsJs.prototype.free;
+    __exports.MoqFecStatsJs = MoqFecStatsJs;
+
+    /**
+     * A reassembled MFU handed back to JS.
+     */
+    class ReassembledMfuJs {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(ReassembledMfuJs.prototype);
+            obj.__wbg_ptr = ptr;
+            ReassembledMfuJsFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            ReassembledMfuJsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_reassembledmfujs_free(ptr, 0);
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get attribution() {
+            const ret = wasm.reassembledmfujs_attribution(this.__wbg_ptr);
+            return ret === 0xFFFFFF ? undefined : ret;
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get sample_number() {
+            const ret = wasm.reassembledmfujs_sample_number(this.__wbg_ptr);
+            return ret === 0x100000001 ? undefined : ret;
+        }
+        /**
+         * @returns {number}
+         */
+        get fragment_count() {
+            const ret = wasm.reassembledmfujs_fragment_count(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get stream_identity() {
+            const ret = wasm.reassembledmfujs_stream_identity(this.__wbg_ptr);
+            return ret === 0x100000001 ? undefined : ret;
+        }
+        /**
+         * @returns {number}
+         */
+        get mpu_sequence_number() {
+            const ret = wasm.reassembledmfujs_mpu_sequence_number(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @returns {Uint32Array | undefined}
+         */
+        get packet_sequence_numbers() {
+            const ret = wasm.reassembledmfujs_packet_sequence_numbers(this.__wbg_ptr);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            }
+            return v1;
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get movie_fragment_sequence_number() {
+            const ret = wasm.reassembledmfujs_movie_fragment_sequence_number(this.__wbg_ptr);
+            return ret === 0x100000001 ? undefined : ret;
+        }
+        /**
+         * @returns {Uint32Array | undefined}
+         */
+        get repaired_packet_sequence_numbers() {
+            const ret = wasm.reassembledmfujs_repaired_packet_sequence_numbers(this.__wbg_ptr);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+            }
+            return v1;
+        }
+        /**
+         * The reassembled bytes. Two copies per access (a Rust-side clone — a
+         * `&self` getter cannot move out of `Bytes` — plus the boundary
+         * `Uint8Array` copy), re-incurred on every read: read once and cache.
+         * A zero-copy linear-memory view is not an option — it cannot safely
+         * outlive the next reassembler call.
+         * @returns {Uint8Array}
+         */
+        get data() {
+            const ret = wasm.reassembledmfujs_data(this.__wbg_ptr);
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+        /**
+         * This DU's authored base byte offset within its sample (moqcast #37).
+         * 0 for a whole-sample DU; nonzero identifies one subsample DU among
+         * siblings partitioning an oversized sample. Feed into
+         * [`MmtSampleCombiner`] to reassemble the full sample.
+         * @returns {number | undefined}
+         */
+        get offset() {
+            const ret = wasm.reassembledmfujs_offset(this.__wbg_ptr);
+            return ret === 0x100000001 ? undefined : ret;
+        }
+        /**
+         * @returns {number | undefined}
+         */
+        get priority() {
+            const ret = wasm.reassembledmfujs_priority(this.__wbg_ptr);
+            return ret === 0xFFFFFF ? undefined : ret;
+        }
+        /**
+         * @returns {boolean}
+         */
+        get rap_flag() {
+            const ret = wasm.reassembledmfujs_rap_flag(this.__wbg_ptr);
+            return ret !== 0;
+        }
+        /**
+         * @returns {number}
+         */
+        get timestamp() {
+            const ret = wasm.reassembledmfujs_timestamp(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+    }
+    if (Symbol.dispose) ReassembledMfuJs.prototype[Symbol.dispose] = ReassembledMfuJs.prototype.free;
+    __exports.ReassembledMfuJs = ReassembledMfuJs;
+
+    /**
+     * Snapshot of [`MmtReassembler`] statistics. `u64` fields surface to JS as
+     * `BigInt`, matching the existing [`FecStats`] convention.
+     */
+    class ReassemblerStatsJs {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(ReassemblerStatsJs.prototype);
+            obj.__wbg_ptr = ptr;
+            ReassemblerStatsJsFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            ReassemblerStatsJsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_reassemblerstatsjs_free(ptr, 0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get total_fragments() {
+            const ret = wasm.__wbg_get_fecstats_source_packets(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set total_fragments(arg0) {
+            wasm.__wbg_set_fecstats_source_packets(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get reassembled_mfus() {
+            const ret = wasm.__wbg_get_fecstats_repair_packets(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set reassembled_mfus(arg0) {
+            wasm.__wbg_set_fecstats_repair_packets(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get timed_out_mfus() {
+            const ret = wasm.__wbg_get_fecstats_blocks_complete(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set timed_out_mfus(arg0) {
+            wasm.__wbg_set_fecstats_blocks_complete(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get evicted_memory_limit() {
+            const ret = wasm.__wbg_get_fecstats_blocks_recovered(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set evicted_memory_limit(arg0) {
+            wasm.__wbg_set_fecstats_blocks_recovered(this.__wbg_ptr, arg0);
+        }
+        /**
+         * Incomplete data units released by the MMT policy's clock-free
+         * replacement at `max_buffered` (BLO-31513). Distinct from
+         * `evicted_memory_limit`, which counts the generic engine's own
+         * memory-limit eviction; a host wanting every bound-driven drop sums the
+         * two. Surfaced here because the wasm facade is a host surface: without
+         * it, sustained head loss is silent on wasm-backed engines.
+         * @returns {bigint}
+         */
+        get evicted_data_units() {
+            const ret = wasm.__wbg_get_fecstats_blocks_failed(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * Incomplete data units released by the MMT policy's clock-free
+         * replacement at `max_buffered` (BLO-31513). Distinct from
+         * `evicted_memory_limit`, which counts the generic engine's own
+         * memory-limit eviction; a host wanting every bound-driven drop sums the
+         * two. Surfaced here because the wasm facade is a host surface: without
+         * it, sustained head loss is silent on wasm-backed engines.
+         * @param {bigint} arg0
+         */
+        set evicted_data_units(arg0) {
+            wasm.__wbg_set_fecstats_blocks_failed(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get out_of_order_fragments() {
+            const ret = wasm.__wbg_get_fecstats_bytes_recovered(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set out_of_order_fragments(arg0) {
+            wasm.__wbg_set_fecstats_bytes_recovered(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get duplicate_fragments() {
+            const ret = wasm.__wbg_get_fecstats_blocks_delivery_failed(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set duplicate_fragments(arg0) {
+            wasm.__wbg_set_fecstats_blocks_delivery_failed(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get ambiguous_fallback_fragments() {
+            const ret = wasm.__wbg_get_reassemblerstatsjs_ambiguous_fallback_fragments(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set ambiguous_fallback_fragments(arg0) {
+            wasm.__wbg_set_reassemblerstatsjs_ambiguous_fallback_fragments(this.__wbg_ptr, arg0);
+        }
+    }
+    if (Symbol.dispose) ReassemblerStatsJs.prototype[Symbol.dispose] = ReassemblerStatsJs.prototype.free;
+    __exports.ReassemblerStatsJs = ReassemblerStatsJs;
+
+    /**
+     * Identity-carrying result of [`ShredFecBuffer::try_recover_all_with_identity`]:
+     * the recovered FEC set's `(slot, fec_set_index)` key plus the reassembled bytes.
+     *
+     * `slot` surfaces to JS as `BigInt` — wasm-bindgen's native `u64` mapping — which
+     * matches the buffer's existing surface (`add_shred` already takes `slot: u64`,
+     * i.e. a `BigInt` from JS) and the repo convention for u64 fields
+     * ([`FecStats`], [`ReassemblerStatsJs`]). An `f64` slot was rejected: mainnet
+     * slots fit in 53 bits today, but the lossless representation costs nothing here.
+     *
+     * JS ownership: unlike the plain `Uint8Array` from `try_recover_all`, a
+     * `RecoveredSet` is a wasm-owned object — its allocation (payload included)
+     * stays in wasm linear memory until JS calls `.free()` (or the
+     * nondeterministic `FinalizationRegistry` runs). Call `.free()` after
+     * consuming each set in the drain loop; linear memory never shrinks, so
+     * unfreed sets accumulate as permanent module growth.
+     */
+    class RecoveredSet {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(RecoveredSet.prototype);
+            obj.__wbg_ptr = ptr;
+            RecoveredSetFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            RecoveredSetFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_recoveredset_free(ptr, 0);
+        }
+        /**
+         * FEC set index within the slot.
+         * @returns {number}
+         */
+        get fec_set_index() {
+            const ret = wasm.recoveredset_fec_set_index(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Solana slot of the recovered FEC set (JS: `BigInt`).
+         * @returns {bigint}
+         */
+        get slot() {
+            const ret = wasm.recoveredset_slot(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * The reassembled FEC-set bytes. Two copies per access (a Rust-side clone
+         * — a `&self` getter cannot move the `Box` — plus the boundary
+         * `Uint8Array` copy), re-incurred on every read: read once and cache.
+         * Same pattern as [`ReassembledMfuJs::data`].
+         * @returns {Uint8Array}
+         */
+        get payload() {
+            const ret = wasm.recoveredset_payload(this.__wbg_ptr);
+            var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            return v1;
+        }
+    }
+    if (Symbol.dispose) RecoveredSet.prototype[Symbol.dispose] = RecoveredSet.prototype.free;
+    __exports.RecoveredSet = RecoveredSet;
+
+    /**
+     * Snapshot of [`MmtSampleCombiner`] statistics.
+     */
+    class SampleCombinerStatsJs {
+        static __wrap(ptr) {
+            ptr = ptr >>> 0;
+            const obj = Object.create(SampleCombinerStatsJs.prototype);
+            obj.__wbg_ptr = ptr;
+            SampleCombinerStatsJsFinalization.register(obj, obj.__wbg_ptr, obj);
+            return obj;
+        }
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            SampleCombinerStatsJsFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_samplecombinerstatsjs_free(ptr, 0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get combined_samples() {
+            const ret = wasm.__wbg_get_fecstats_source_packets(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set combined_samples(arg0) {
+            wasm.__wbg_set_fecstats_source_packets(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get passthrough_samples() {
+            const ret = wasm.__wbg_get_fecstats_repair_packets(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set passthrough_samples(arg0) {
+            wasm.__wbg_set_fecstats_repair_packets(this.__wbg_ptr, arg0);
+        }
+        /**
+         * @returns {bigint}
+         */
+        get timed_out_samples() {
+            const ret = wasm.__wbg_get_fecstats_blocks_complete(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * @param {bigint} arg0
+         */
+        set timed_out_samples(arg0) {
+            wasm.__wbg_set_fecstats_blocks_complete(this.__wbg_ptr, arg0);
+        }
+        /**
+         * Incomplete samples discarded to enforce `max_buffered`.
+         * @returns {bigint}
+         */
+        get evicted_samples() {
+            const ret = wasm.__wbg_get_fecstats_blocks_recovered(this.__wbg_ptr);
+            return BigInt.asUintN(64, ret);
+        }
+        /**
+         * Incomplete samples discarded to enforce `max_buffered`.
+         * @param {bigint} arg0
+         */
+        set evicted_samples(arg0) {
+            wasm.__wbg_set_fecstats_blocks_recovered(this.__wbg_ptr, arg0);
+        }
+    }
+    if (Symbol.dispose) SampleCombinerStatsJs.prototype[Symbol.dispose] = SampleCombinerStatsJs.prototype.free;
+    __exports.SampleCombinerStatsJs = SampleCombinerStatsJs;
+
+    /**
+     * Solana FEC-set buffer with Reed-Solomon erasure recovery (wire v3).
+     *
+     * Accepts both data and coding shreds as agave *erasure shards* (equal length within
+     * a set). Happy path: once all `num_data` data shreds are present the set completes
+     * immediately (num_data known from the DATA_COMPLETE data shred or any coding shred).
+     * Loss path: buffer whatever arrives and call `try_recover_all()` periodically —
+     * when `received_data + received_coding >= num_data`, RS reconstructs the missing
+     * data shards. On completion the real data is extracted from each data shard's
+     * embedded `size` field and concatenated in order.
+     */
+    class ShredFecBuffer {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            ShredFecBufferFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_shredfecbuffer_free(ptr, 0);
+        }
+        /**
+         * Call periodically (every ~50ms) to attempt RS recovery on a stale FEC set.
+         * Returns one recovered set's bytes or null — the caller should loop until null
+         * to drain a backlog (a single set per tick cannot keep up with the shred rate).
+         *
+         * The payload alone carries no set identity; use
+         * [`try_recover_all_with_identity`](Self::try_recover_all_with_identity) when
+         * the caller needs to attribute the bytes to a `(slot, fec_set_index)`. Both
+         * methods drain the SAME backlog (a set is returned by whichever is called
+         * first, never both), and every call advances the staleness clock — run
+         * exactly one variant per buffer, not both interleaved.
+         * @param {number} _now_ms
+         * @returns {Uint8Array | undefined}
+         */
+        try_recover_all(_now_ms) {
+            const ret = wasm.shredfecbuffer_try_recover_all(this.__wbg_ptr, _now_ms);
+            let v1;
+            if (ret[0] !== 0) {
+                v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v1;
+        }
+        /**
+         * Number of incomplete (non-tombstone) FEC sets buffered.
+         * @returns {number}
+         */
+        pending_fec_sets() {
+            const ret = wasm.shredfecbuffer_pending_fec_sets(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * Identity-carrying variant of [`try_recover_all`](Self::try_recover_all):
+         * same recovery pass, same drain semantics (loop until null), but the result
+         * also carries the recovered set's `(slot, fec_set_index)` key. ADDITIVE —
+         * `try_recover_all` is unchanged (the in-flight pim player uses it); both
+         * methods drain the same underlying backlog, so a set is returned by
+         * whichever is called first, never both. They are alternatives for a single
+         * consumer — interleaving them doubles the tick rate, aging pending sets out
+         * of the recovery window in half the wall-clock time.
+         *
+         * JS ownership: the returned [`RecoveredSet`] is wasm-owned — call `.free()`
+         * after consuming each set (see the type's docs), unlike `try_recover_all`'s
+         * auto-freed `Uint8Array`.
+         * @param {number} _now_ms
+         * @returns {RecoveredSet | undefined}
+         */
+        try_recover_all_with_identity(_now_ms) {
+            const ret = wasm.shredfecbuffer_try_recover_all_with_identity(this.__wbg_ptr, _now_ms);
+            return ret === 0 ? undefined : RecoveredSet.__wrap(ret);
+        }
+        /**
+         * @param {bigint} timeout_ms
+         * @param {number} max_buffered
+         */
+        constructor(timeout_ms, max_buffered) {
+            const ret = wasm.shredfecbuffer_new(timeout_ms, max_buffered);
+            this.__wbg_ptr = ret >>> 0;
+            ShredFecBufferFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * Feed a data or coding shred (wire-v3 erasure shard).
+         * Returns reassembled FEC-set bytes if the set just completed, null otherwise.
+         * @param {bigint} slot
+         * @param {number} fec_set_index
+         * @param {number} local_index
+         * @param {number} num_data
+         * @param {number} num_coding
+         * @param {boolean} is_coding
+         * @param {Uint8Array} payload
+         * @param {boolean} last_in_set
+         * @returns {Uint8Array | undefined}
+         */
+        add_shred(slot, fec_set_index, local_index, num_data, num_coding, is_coding, payload, last_in_set) {
+            const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.shredfecbuffer_add_shred(this.__wbg_ptr, slot, fec_set_index, local_index, num_data, num_coding, is_coding, ptr0, len0, last_in_set);
+            let v2;
+            if (ret[0] !== 0) {
+                v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v2;
+        }
+    }
+    if (Symbol.dispose) ShredFecBuffer.prototype[Symbol.dispose] = ShredFecBuffer.prototype.free;
+    __exports.ShredFecBuffer = ShredFecBuffer;
+
+    /**
+     * Browser-side Solana FEC-set reassembler.
+     *
+     * Feed data shreds as they arrive from a multicast subscription. Returns the
+     * reassembled FEC-set payload when all shreds for a (slot, fec_set_index) group
+     * have been received in order, or null if the set is still incomplete.
+     */
+    class ShredReassembler {
+        __destroy_into_raw() {
+            const ptr = this.__wbg_ptr;
+            this.__wbg_ptr = 0;
+            ShredReassemblerFinalization.unregister(this);
+            return ptr;
+        }
+        free() {
+            const ptr = this.__destroy_into_raw();
+            wasm.__wbg_shredreassembler_free(ptr, 0);
+        }
+        /**
+         * Number of FEC sets currently buffered (incomplete).
+         * @returns {number}
+         */
+        pending_fec_sets() {
+            const ret = wasm.combinedsamplejs_mpu_sequence_number(this.__wbg_ptr);
+            return ret >>> 0;
+        }
+        /**
+         * @param {bigint} timeout_ms
+         * @param {number} max_buffered
+         */
+        constructor(timeout_ms, max_buffered) {
+            const ret = wasm.shredreassembler_new(timeout_ms, max_buffered);
+            this.__wbg_ptr = ret >>> 0;
+            ShredReassemblerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        }
+        /**
+         * Feed one data shred.
+         * Returns the reassembled FEC-set bytes when the set is complete, otherwise null.
+         * @param {bigint} slot
+         * @param {number} fec_set_index
+         * @param {number} local_index
+         * @param {Uint8Array} payload
+         * @param {boolean} last_in_set
+         * @returns {Uint8Array | undefined}
+         */
+        add_shred(slot, fec_set_index, local_index, payload, last_in_set) {
+            const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.shredreassembler_add_shred(this.__wbg_ptr, slot, fec_set_index, local_index, ptr0, len0, last_in_set);
+            let v2;
+            if (ret[0] !== 0) {
+                v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+                wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+            }
+            return v2;
+        }
+    }
+    if (Symbol.dispose) ShredReassembler.prototype[Symbol.dispose] = ShredReassembler.prototype.free;
+    __exports.ShredReassembler = ShredReassembler;
+
+    /**
+     * True when an Annex B access unit contains a keyframe slice for the
+     * catalog codec's family. Every NAL unit header is validated.
+     * @param {string} codec
+     * @param {Uint8Array} access_unit
+     * @returns {boolean}
+     */
+    function annexb_access_unit_is_keyframe(codec, access_unit) {
+        const ptr0 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(access_unit, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.annexb_access_unit_is_keyframe(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    __exports.annexb_access_unit_is_keyframe = annexb_access_unit_is_keyframe;
+
+    /**
+     * The RFC 6381 codec string of an HEVC stream derived from its SPS NAL unit
+     * (ISO/IEC 14496-15 Annex E.3), using the sample entry (`hev1`/`hvc1`) of
+     * the catalog codec string.
+     * @param {string} codec
+     * @param {Uint8Array} sps
+     * @returns {string}
+     */
+    function hevc_codec_string(codec, sps) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(sps, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.hevc_codec_string(ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    __exports.hevc_codec_string = hevc_codec_string;
+
+    /**
+     * The `hvcC` HEVCDecoderConfigurationRecord (ISO/IEC 14496-15 8.3.3.1)
+     * built from the VPS, SPS and PPS carried in an Annex B IRAP access unit;
+     * usable as the fMP4 `hvcC` box payload and the WebCodecs `description`.
+     * Samples must then be 4-byte length-prefixed (`lengthSizeMinusOne` = 3).
+     * @param {string} codec
+     * @param {Uint8Array} access_unit
+     * @returns {Uint8Array}
+     */
+    function hevc_hvcc_from_annexb(codec, access_unit) {
+        const ptr0 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(access_unit, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.hevc_hvcc_from_annexb(ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+    }
+    __exports.hevc_hvcc_from_annexb = hevc_hvcc_from_annexb;
+
+    /**
+     * Initialize the WASM module
+     */
+    function init() {
+        wasm.init();
+    }
+    __exports.init = init;
+
+    /**
+     * True when one NAL unit (no start code or length prefix) is a keyframe
+     * slice for the catalog codec's family: an AVC IDR slice (H.264 Table 7-1)
+     * or an HEVC IRAP picture (H.265 Table 7-1, `nal_unit_type` 16..=23).
+     * Throws for an unknown family or a malformed NAL unit header.
+     * @param {string} codec
+     * @param {Uint8Array} nal
+     * @returns {boolean}
+     */
+    function is_keyframe_nal(codec, nal) {
+        const ptr0 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(nal, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.is_keyframe_nal(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    __exports.is_keyframe_nal = is_keyframe_nal;
+
+    /**
+     * Exact browser-facing MoQ FEC contract implemented by this module.
+     * @returns {string}
+     */
+    function moq_fec_contract_version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.moq_fec_contract_version();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    __exports.moq_fec_contract_version = moq_fec_contract_version;
+
+    /**
+     * Hash one authenticated object on the browser main thread.
+     * @param {Uint8Array} object
+     * @returns {Uint8Array}
+     */
+    function source_auth_blake3(object) {
+        const ptr0 = passArray8ToWasm0(object, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.source_auth_blake3(ptr0, len0);
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    __exports.source_auth_blake3 = source_auth_blake3;
+
+    /**
+     * Build one `iso-ssbg1-v1` source symbol (ISO/IEC 23008-1 C.3.3
+     * ssbg_mode1): `u16be(len) || packet || zero padding` to `symbol_size` bytes.
+     * `packet` is the protected MMTP packet without its Source FEC Payload ID;
+     * a packet with `len + 2 > symbol_size` is refused.
+     * @param {Uint8Array} packet
+     * @param {number} symbol_size
+     * @returns {Uint8Array}
+     */
+    function ssbg1_source_symbol(packet, symbol_size) {
+        const ptr0 = passArray8ToWasm0(packet, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ssbg1_source_symbol(ptr0, len0, symbol_size);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    __exports.ssbg1_source_symbol = ssbg1_source_symbol;
+
+    /**
+     * The sample entry four-character code (`avc1`, `avc3`, `hev1`, `hvc1`)
+     * named by a catalog codec string. Throws for any other codec family.
+     * @param {string} codec
+     * @returns {string}
+     */
+    function video_sample_entry_from_codec_string(codec) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(codec, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.video_sample_entry_from_codec_string(ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    __exports.video_sample_entry_from_codec_string = video_sample_entry_from_codec_string;
+
+    const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+    async function __wbg_load(module, imports) {
+        if (typeof Response === 'function' && module instanceof Response) {
+            if (typeof WebAssembly.instantiateStreaming === 'function') {
+                try {
+                    return await WebAssembly.instantiateStreaming(module, imports);
+                } catch (e) {
+                    const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(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 __wbg_get_imports() {
+        const imports = {};
+        imports.wbg = {};
+        imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        };
+        imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        };
+        imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        };
+        imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_log_443cb9527570529b = function(arg0, arg1) {
+            console.log(getStringFromWasm0(arg0, arg1));
+        };
+        imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+            const ret = new Error();
+            return ret;
+        };
+        imports.wbg.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+            const ret = new Function(getStringFromWasm0(arg0, arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_now_8cf15d6e317793e1 = function(arg0) {
+            const ret = arg0.now();
+            return ret;
+        };
+        imports.wbg.__wbg_set_781438a03c0c3c81 = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        };
+        imports.wbg.__wbg_warn_620e34c9218c1711 = function(arg0, arg1) {
+            console.warn(getStringFromWasm0(arg0, arg1));
+        };
+        imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        };
+        imports.wbg.__wbindgen_init_externref_table = function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        };
+
+        return imports;
+    }
+
+    function __wbg_finalize_init(instance, module) {
+        wasm = instance.exports;
+        __wbg_init.__wbindgen_wasm_module = module;
+        cachedDataViewMemory0 = null;
+        cachedUint32ArrayMemory0 = null;
+        cachedUint8ArrayMemory0 = null;
+
+
+        wasm.__wbindgen_start();
+        return wasm;
+    }
+
+    function initSync(module) {
+        if (wasm !== undefined) return wasm;
+
+
+        if (typeof 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 (typeof 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 (typeof module_or_path === 'undefined' && typeof script_src !== 'undefined') {
+            module_or_path = script_src.replace(/\.js$/, '_bg.wasm');
+        }
+        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);
+    }
+
+    wasm_bindgen = Object.assign(__wbg_init, { initSync }, __exports);
+})();