@blockcast/mmt-wasm 0.0.0-stage → 0.1.0

package/pkg/mmt_wasm.js

@@ -0,0 +1,2990 @@
+let wasm;
+
+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();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+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`].
+ */
+export 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;
+
+/**
+ * FEC statistics for monitoring
+ */
+export 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;
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * 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`.
+ */
+export 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;
+
+/**
+ * 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}
+ */
+export 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",
+});
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * 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).
+ */
+export 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;
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * One encoded MoQ block and its immutable source/repair symbol fixtures.
+ */
+export 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;
+
+/**
+ * Versioned MoQ FEC configuration exposed to browser consumers.
+ */
+export 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;
+
+/**
+ * Versioned browser-side MoQ FEC decoder.
+ */
+export 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;
+
+/**
+ * Versioned browser-side MoQ FEC encoder.
+ */
+export 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;
+
+/**
+ * Snapshot of MoQ FEC decoder counters.
+ */
+export 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;
+
+/**
+ * A reassembled MFU handed back to JS.
+ */
+export 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;
+
+/**
+ * Snapshot of [`MmtReassembler`] statistics. `u64` fields surface to JS as
+ * `BigInt`, matching the existing [`FecStats`] convention.
+ */
+export 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;
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * Snapshot of [`MmtSampleCombiner`] statistics.
+ */
+export 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;
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * 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}
+ */
+export 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;
+}
+
+/**
+ * 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}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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}
+ */
+export 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;
+}
+
+/**
+ * Initialize the WASM module
+ */
+export function init() {
+    wasm.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}
+ */
+export 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;
+}
+
+/**
+ * Exact browser-facing MoQ FEC contract implemented by this module.
+ * @returns {string}
+ */
+export 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);
+    }
+}
+
+/**
+ * Hash one authenticated object on the browser main thread.
+ * @param {Uint8Array} object
+ * @returns {Uint8Array}
+ */
+export 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;
+}
+
+/**
+ * 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}
+ */
+export 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;
+}
+
+/**
+ * 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}
+ */
+export 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);
+    }
+}
+
+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') {
+        module_or_path = new URL('mmt_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;