@blockcast/mmt-container 0.1.0 → 0.3.0

package/dist/wasm-mfu-reassembler.js

@@ -0,0 +1,2133 @@
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+
+// ../mmt-base/dist/mmtp.js
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+
+// src/mfu-reassembler.ts
+var MFU_REASSEMBLY_ERROR_CODES = [
+  "invalid-fragment-state",
+  "missing-data-unit-identity",
+  "missing-packet-sequence",
+  "conflicting-data-unit-identity",
+  "overlapping-data-unit",
+  "fragment-counter-mismatch",
+  "data-unit-identity-mismatch",
+  "offset-overflow",
+  "active-data-unit-limit",
+  "incomplete-terminal-fragment",
+  "ambiguous-continuation"
+];
+var mfuReassemblyErrorCodes = new Set(MFU_REASSEMBLY_ERROR_CODES);
+function isMfuReassemblyErrorCode(value) {
+  return typeof value === "string" && mfuReassemblyErrorCodes.has(value);
+}
+var MfuReassemblyError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "MfuReassemblyError";
+  }
+};
+if (void 0) {
+  const { describe, test, expect, vi } = void 0;
+  const expectRejection = (call, code) => {
+    let rejection;
+    try {
+      call();
+    } catch (error) {
+      rejection = error;
+    }
+    expect(rejection).toBeInstanceOf(MfuReassemblyError);
+    expect(rejection.code).toBe(code);
+  };
+  const testPacketSequence = (mpu, counter, run = 0) => (mpu * 1e3 + run - counter + 4294967296) % 4294967296;
+  describe("MFUReassembler", () => {
+    test("should return complete MFU for FI=0", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        itemId: 1,
+        data: new Uint8Array([1, 2, 3, 4]),
+        timestamp: 1000n,
+        rapFlag: true
+      });
+      expect(result).not.toBeNull();
+      expect(result?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(result?.fragmentCount).toBe(1);
+      expect(result?.rapFlag).toBe(true);
+    });
+    test("rejects a complete MFU without a valid sample identity", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const complete = (identity) => ({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: true,
+        ...identity
+      });
+      expectRejection(() => reassembler.addFragment(complete({})), "missing-data-unit-identity");
+      expectRejection(
+        () => reassembler.addFragment(
+          complete({
+            movieFragmentSequenceNumber: 2,
+            sampleNumber: 1
+          })
+        ),
+        "missing-data-unit-identity"
+      );
+    });
+    test("accepts a complete subsample MFU with a nonzero authored offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        movieFragmentSequenceNumber: 2,
+        sampleNumber: 1,
+        sampleOffset: 4,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: true
+      });
+      expect(result).not.toBeNull();
+      expect(result?.sampleOffset).toBe(4);
+    });
+    test("accepts a fragmented subsample DU whose first fragment has a nonzero authored offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 2,
+          fragmentCounter: 1,
+          movieFragmentSequenceNumber: 2,
+          sampleNumber: 1,
+          sampleOffset: 4,
+          packetSequenceNumber: testPacketSequence(2, 1),
+          data: new Uint8Array([161]),
+          timestamp: 1000n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      expect(reassembler.getStatus().pendingFragments).toBe(1);
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 0,
+        data: new Uint8Array([162]),
+        timestamp: 1001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(2, 0)
+      });
+      expect(out?.data).toEqual(new Uint8Array([161, 162]));
+      expect(out?.sampleOffset).toBe(4);
+    });
+    test("a mid-data-unit packet sequence gap strands the data unit", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null, maxBuffered: 10 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 7,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          packetSequenceNumber: 100,
+          data: new Uint8Array([161]),
+          timestamp: 1100n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      const interleaved = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 7,
+        fragmentCounter: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        packetSequenceNumber: 101,
+        data: new Uint8Array([255]),
+        timestamp: 1101n,
+        rapFlag: true
+      });
+      expect(interleaved?.data).toEqual(new Uint8Array([255]));
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 7,
+          fragmentCounter: 1,
+          packetSequenceNumber: 102,
+          data: new Uint8Array([162]),
+          timestamp: 1102n,
+          rapFlag: false
+        })
+      ).toBeNull();
+      const output = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 7,
+        fragmentCounter: 0,
+        packetSequenceNumber: 103,
+        data: new Uint8Array([163]),
+        timestamp: 1103n,
+        rapFlag: false
+      });
+      expect(output).toBeNull();
+      expect(reassembler.stats.reassembledMFUs).toBe(1);
+      expect(reassembler.stats.rejectedFragments).toBe(0);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(0);
+      expect(reassembler.getStatus().bufferedMFUs).toBe(2);
+      expect(reassembler.getStatus().pendingFragments).toBe(3);
+    });
+    test("sibling subsample DUs of one sample reassemble independently by offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          mpuSequenceNumber: 3,
+          movieFragmentSequenceNumber: 5,
+          sampleNumber: 9,
+          fragmentationIndicator: 1,
+          fragmentCounter: 1,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp: 2000n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(3, 1, 0)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          mpuSequenceNumber: 3,
+          movieFragmentSequenceNumber: 5,
+          sampleNumber: 9,
+          fragmentationIndicator: 1,
+          fragmentCounter: 2,
+          sampleOffset: 3,
+          data: new Uint8Array([177]),
+          timestamp: 2001n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(3, 1, 1)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      const first = reassembler.addFragment({
+        mpuSequenceNumber: 3,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        data: new Uint8Array([162]),
+        timestamp: 2000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(3, 0, 0)
+      });
+      expect(first?.data).toEqual(new Uint8Array([161, 162]));
+      expect(first?.sampleOffset).toBe(0);
+      expect(
+        reassembler.addFragment({
+          mpuSequenceNumber: 3,
+          fragmentationIndicator: 2,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp: 2001n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(3, 0, 1)
+        })
+      ).toBeNull();
+      const second = reassembler.addFragment({
+        mpuSequenceNumber: 3,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        data: new Uint8Array([179]),
+        timestamp: 2001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(3, 0, 2)
+      });
+      expect(second?.data).toEqual(new Uint8Array([177, 178, 179]));
+      expect(second?.sampleOffset).toBe(3);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("isolates colliding fragment coordinates by catalog track identity", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const fragment = (catalogTrackName, fragmentationIndicator, fragmentCounter, byte) => ({
+        itemId: 1,
+        fragmentationIndicator,
+        fragmentCounter,
+        mpuSequenceNumber: 1,
+        data: new Uint8Array([byte]),
+        timestamp: 1000n,
+        rapFlag: fragmentationIndicator === 1,
+        catalogTrackName,
+        packetSequenceNumber: testPacketSequence(1, fragmentCounter)
+      });
+      expect(reassembler.addFragment(fragment("video/720p", 1, 1, 113))).toBeNull();
+      expect(reassembler.addFragment(fragment("video/540p", 1, 1, 81))).toBeNull();
+      const high = reassembler.addFragment(fragment("video/720p", 3, 0, 114));
+      const low = reassembler.addFragment(fragment("video/540p", 3, 0, 82));
+      expect(high?.data).toEqual(new Uint8Array([113, 114]));
+      expect(high?.catalogTrackName).toBe("video/720p");
+      expect(low?.data).toEqual(new Uint8Array([81, 82]));
+      expect(low?.catalogTrackName).toBe("video/540p");
+    });
+    test("rejects an overlapping non-timed item without replacing the active run", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const fragment = (itemId, fragmentationIndicator, fragmentCounter, byte) => ({
+        itemId,
+        fragmentationIndicator,
+        fragmentCounter,
+        mpuSequenceNumber: 1,
+        data: new Uint8Array([byte]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, fragmentCounter)
+      });
+      expect(reassembler.addFragment(fragment(10, 1, 1, 16))).toBeNull();
+      expectRejection(() => reassembler.addFragment(fragment(20, 1, 1, 32)), "overlapping-data-unit");
+      expect(reassembler.pendingCount).toBe(1);
+      expect(reassembler.addFragment(fragment(10, 3, 0, 17))?.data).toEqual(new Uint8Array([16, 17]));
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("associates continuations by authored state when packet timestamps change", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const fragment = (itemId, fragmentationIndicator, fragmentCounter, byte, timestamp) => ({
+        ...itemId === void 0 ? {} : { itemId },
+        fragmentationIndicator,
+        fragmentCounter,
+        mpuSequenceNumber: 1,
+        data: new Uint8Array([byte]),
+        timestamp,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, fragmentCounter)
+      });
+      expect(reassembler.addFragment(fragment(10, 1, 2, 16, 1000n))).toBeNull();
+      expect(reassembler.addFragment(fragment(void 0, 2, 1, 17, 1001n))).toBeNull();
+      const out = reassembler.addFragment(fragment(void 0, 3, 0, 18, 1002n));
+      expect(out?.data).toEqual(new Uint8Array([16, 17, 18]));
+      expect(out?.timestamp).toBe(1000n);
+    });
+    test("should buffer and reassemble 2 fragments", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result1 = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1, 2]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(result1).toBeNull();
+      const result2 = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([3, 4]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result2).not.toBeNull();
+      expect(result2?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(result2?.fragmentCount).toBe(2);
+      expect(result2?.rapFlag).toBe(true);
+    });
+    test("buffers a terminal continuation until its authored first fragment arrives", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 1,
+          fragmentCounter: 0,
+          data: new Uint8Array([3, 4]),
+          timestamp: 1000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(1, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      const completed = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1, 2]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(completed?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(completed?.rapFlag).toBe(true);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("clock-free mode keeps an admitted MFU until completion", async () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1, 2]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([3, 4]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(reassembler.stats.timedOutMFUs).toBe(0);
+    });
+    test("should track pending count", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(reassembler.pendingCount).toBe(0);
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(reassembler.pendingCount).toBe(1);
+      reassembler.flush();
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("should reassemble 3 fragments (FI=1, FI=2, FI=3)", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 10,
+          fragmentCounter: 2,
+          itemId: 1,
+          data: new Uint8Array([170, 187]),
+          timestamp: 5000n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(10, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 10,
+          fragmentCounter: 1,
+          data: new Uint8Array([204, 221]),
+          timestamp: 5000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(10, 1)
+        })
+      ).toBeNull();
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 10,
+        fragmentCounter: 0,
+        data: new Uint8Array([238, 255]),
+        timestamp: 5000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(10, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.data).toEqual(new Uint8Array([170, 187, 204, 221, 238, 255]));
+      expect(result.fragmentCount).toBe(3);
+      expect(result.rapFlag).toBe(true);
+      expect(result.mpuSequenceNumber).toBe(10);
+    });
+    test("should handle interleaved MPU sequences", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 100n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      const r2 = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 0,
+        itemId: 2,
+        data: new Uint8Array([2]),
+        timestamp: 200n,
+        rapFlag: false
+      });
+      expect(r2).not.toBeNull();
+      expect(r2.mpuSequenceNumber).toBe(2);
+      const r1 = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([3]),
+        timestamp: 100n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(r1).not.toBeNull();
+      expect(r1.data).toEqual(new Uint8Array([1, 3]));
+    });
+    test("rejects overlapping fragmented MFUs sharing one stream and MPU", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const mpuSeq = 5;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: mpuSeq,
+          fragmentCounter: 1,
+          itemId: 10,
+          data: new Uint8Array([161]),
+          timestamp: 100n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(mpuSeq, 1)
+        })
+      ).toBeNull();
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: mpuSeq,
+          fragmentCounter: 1,
+          itemId: 20,
+          data: new Uint8Array([177]),
+          timestamp: 200n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(mpuSeq, 1)
+        }),
+        "overlapping-data-unit"
+      );
+      expect(reassembler.pendingCount).toBe(1);
+      const a = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: mpuSeq,
+        fragmentCounter: 0,
+        data: new Uint8Array([162]),
+        timestamp: 101n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(mpuSeq, 0)
+      });
+      expect(a).not.toBeNull();
+      expect(a.data).toEqual(new Uint8Array([161, 162]));
+      expect(a.rapFlag).toBe(true);
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: mpuSeq,
+          fragmentCounter: 1,
+          itemId: 20,
+          data: new Uint8Array([177]),
+          timestamp: 200n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(mpuSeq, 1, 10)
+        })
+      ).toBeNull();
+      const b = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: mpuSeq,
+        fragmentCounter: 0,
+        data: new Uint8Array([178]),
+        timestamp: 201n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(mpuSeq, 0, 10)
+      });
+      expect(b).not.toBeNull();
+      expect(b.data).toEqual(new Uint8Array([177, 178]));
+    });
+    test("reassembles FFmpeg timed MFU fragments by sample number and byte offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const common = {
+        mpuSequenceNumber: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 17
+      };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 2,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp: 1000n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(0, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 2,
+          fragmentCounter: 1,
+          sampleOffset: 1,
+          data: new Uint8Array([178]),
+          timestamp: 1001n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(0, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        sampleOffset: 2,
+        data: new Uint8Array([195]),
+        timestamp: 1002n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(0, 0)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(out.timestamp).toBe(1000n);
+      expect(out.sampleNumber).toBe(17);
+      expect(out.movieFragmentSequenceNumber).toBe(9);
+    });
+    test("buffers a counter gap without advancing the active data unit", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const common = {
+        mpuSequenceNumber: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 17,
+        timestamp: 1000n,
+        rapFlag: true
+      };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 2,
+          sampleOffset: 0,
+          data: new Uint8Array([161, 162]),
+          packetSequenceNumber: testPacketSequence(0, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 3,
+          fragmentCounter: 0,
+          sampleOffset: 4,
+          data: new Uint8Array([193, 194]),
+          packetSequenceNumber: testPacketSequence(0, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      const out = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 2,
+        fragmentCounter: 1,
+        sampleOffset: 2,
+        data: new Uint8Array([177, 178]),
+        packetSequenceNumber: testPacketSequence(0, 1)
+      });
+      expect(out?.data).toEqual(new Uint8Array([161, 162, 177, 178, 193, 194]));
+    });
+    test("reassembles first-only DU-header fragments across changing packet timestamps", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp: 12345n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(44, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp: 12346n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(44, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 44,
+        fragmentCounter: 0,
+        data: new Uint8Array([195]),
+        timestamp: 12347n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(44, 0)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(out.timestamp).toBe(12345n);
+      expect(out.sampleNumber).toBe(17);
+      expect(out.movieFragmentSequenceNumber).toBe(9);
+    });
+    test("reassembles first-only DU-header fragments with an ISO countdown", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 12345n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 3,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(44, 3)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 2,
+          data: new Uint8Array([178]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(44, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 1,
+          data: new Uint8Array([195]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(44, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 44,
+        fragmentCounter: 0,
+        data: new Uint8Array([212]),
+        timestamp,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(44, 0)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195, 212]));
+      expect(out.sampleNumber).toBe(17);
+      expect(out.movieFragmentSequenceNumber).toBe(9);
+    });
+    test("rejects fragmented MFUs without an authored DU identity", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 22222n;
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 55,
+          fragmentCounter: 2,
+          data: new Uint8Array([161]),
+          timestamp,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(55, 2)
+        }),
+        "missing-data-unit-identity"
+      );
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects fragmented MFUs without an authored packet sequence", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 55,
+          fragmentCounter: 1,
+          itemId: 1,
+          data: new Uint8Array([161]),
+          timestamp: 22222n,
+          rapFlag: true
+        }),
+        "missing-packet-sequence"
+      );
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects fragmented MFUs whose authored packet sequence is not u32", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      for (const packetSequenceNumber of [-1, 4294967296, 1.5, Number.NaN]) {
+        expectRejection(
+          () => reassembler.addFragment({
+            fragmentationIndicator: 1,
+            mpuSequenceNumber: 55,
+            fragmentCounter: 1,
+            itemId: 1,
+            data: new Uint8Array([161]),
+            timestamp: 22222n,
+            rapFlag: true,
+            packetSequenceNumber
+          }),
+          "missing-packet-sequence"
+        );
+      }
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("a packet sequence gap inside a fragmented DU splits it and never completes", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 66666n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 80,
+          fragmentCounter: 3,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 1e3,
+          data: new Uint8Array([160]),
+          timestamp,
+          rapFlag: true
+        })
+      ).toBeNull();
+      for (const [counter, psn] of [
+        [2, 1002],
+        [1, 1003]
+      ]) {
+        expect(
+          reassembler.addFragment({
+            fragmentationIndicator: 2,
+            mpuSequenceNumber: 80,
+            fragmentCounter: counter,
+            packetSequenceNumber: psn,
+            data: new Uint8Array([160 + counter]),
+            timestamp,
+            rapFlag: false
+          })
+        ).toBeNull();
+      }
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 80,
+          fragmentCounter: 0,
+          packetSequenceNumber: 1004,
+          data: new Uint8Array([177]),
+          timestamp,
+          rapFlag: false
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      expect(reassembler.getStatus().pendingFragments).toBe(4);
+      expect(reassembler.stats.reassembledMFUs).toBe(0);
+      expect(reassembler.stats.rejectedFragments).toBe(0);
+    });
+    test("keeps adjacent MFUs with equal countdowns in one MPU separate", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const common = { mpuSequenceNumber: 80, packetId: 7, timestamp: 66666n };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 1,
+          packetSequenceNumber: 100,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 1,
+          packetSequenceNumber: 102,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 2,
+          sampleOffset: 0,
+          data: new Uint8Array([177]),
+          rapFlag: false
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      const earlier = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        packetSequenceNumber: 101,
+        data: new Uint8Array([162]),
+        rapFlag: false
+      });
+      expect(earlier?.data).toEqual(new Uint8Array([161, 162]));
+      expect(earlier?.packetSequenceNumbers).toEqual([100, 101]);
+      const later = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        packetSequenceNumber: 103,
+        data: new Uint8Array([178]),
+        rapFlag: false
+      });
+      expect(later?.data).toEqual(new Uint8Array([177, 178]));
+      expect(later?.packetSequenceNumbers).toEqual([102, 103]);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("wraps the fragmented run coordinate at u32 packet sequence", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 81,
+          fragmentCounter: 1,
+          packetSequenceNumber: 4294967295,
+          itemId: 1,
+          data: new Uint8Array([161]),
+          timestamp: 66666n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 81,
+          fragmentCounter: 0,
+          packetSequenceNumber: 0,
+          data: new Uint8Array([162]),
+          timestamp: 66667n,
+          rapFlag: false
+        })?.data
+      ).toEqual(new Uint8Array([161, 162]));
+    });
+    test("dedupes recovered copies by ISO fragment-counter position", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 44444n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 77,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 12,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 2e3,
+          data: new Uint8Array([161]),
+          timestamp,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 77,
+          fragmentCounter: 1,
+          packetSequenceNumber: 2001,
+          data: new Uint8Array([178]),
+          timestamp,
+          rapFlag: false
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 77,
+          fragmentCounter: 0,
+          packetSequenceNumber: 2002,
+          data: new Uint8Array([195]),
+          timestamp,
+          rapFlag: false
+        })
+      ).not.toBeNull();
+      reassembler.flush();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 78,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 13,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 3e3,
+          data: new Uint8Array([212]),
+          timestamp,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 78,
+          fragmentCounter: 1,
+          packetSequenceNumber: 3001,
+          data: new Uint8Array([229]),
+          timestamp,
+          rapFlag: false
+        })
+      ).toBeNull();
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 78,
+          fragmentCounter: 1,
+          packetSequenceNumber: 3001,
+          data: new Uint8Array([229]),
+          timestamp,
+          rapFlag: false
+        }),
+        "fragment-counter-mismatch"
+      );
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 78,
+        fragmentCounter: 0,
+        packetSequenceNumber: 3002,
+        data: new Uint8Array([246]),
+        timestamp,
+        rapFlag: false
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([212, 229, 246]));
+    });
+    test("reassembles middle and terminal continuations that arrive before first", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 54321n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 45,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(45, 1)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 45,
+          fragmentCounter: 0,
+          data: new Uint8Array([195]),
+          timestamp: timestamp + 1n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(45, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 45,
+        fragmentCounter: 2,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(45, 2)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(out.sampleNumber).toBe(18);
+      expect(out.movieFragmentSequenceNumber).toBe(10);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects a duplicate continuation before first without replacing retained media", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 54322n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 46,
+          fragmentCounter: 0,
+          data: new Uint8Array([195]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(46, 0)
+        })
+      ).toBeNull();
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 46,
+          fragmentCounter: 0,
+          data: new Uint8Array([255]),
+          timestamp: timestamp + 1n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(46, 0)
+        }),
+        "fragment-counter-mismatch"
+      );
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 46,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp: timestamp + 2n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(46, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 46,
+        fragmentCounter: 2,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 19,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp: timestamp + 3n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(46, 2)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects invalid ISO fragmentation-indicator and counter combinations", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const invalidHeaders = [
+        { fragmentationIndicator: 0, fragmentCounter: 1 },
+        { fragmentationIndicator: 3, fragmentCounter: 1 },
+        { fragmentationIndicator: 1, fragmentCounter: 0 },
+        { fragmentationIndicator: 2, fragmentCounter: 0 },
+        { fragmentationIndicator: -1, fragmentCounter: 1 },
+        { fragmentationIndicator: 4, fragmentCounter: 1 },
+        { fragmentationIndicator: 1.5, fragmentCounter: 1 },
+        { fragmentationIndicator: 1, fragmentCounter: -1 },
+        { fragmentationIndicator: 1, fragmentCounter: 256 },
+        { fragmentationIndicator: 1, fragmentCounter: 1.5 },
+        { fragmentationIndicator: 1, fragmentCounter: Number.NaN }
+      ];
+      for (const header of invalidHeaders) {
+        expectRejection(
+          () => reassembler.addFragment({
+            ...header,
+            mpuSequenceNumber: 48,
+            data: new Uint8Array([161]),
+            timestamp: 54324n,
+            rapFlag: false
+          }),
+          "invalid-fragment-state"
+        );
+      }
+      expect(reassembler.pendingCount).toBe(0);
+      expect(reassembler.stats.reassembledMFUs).toBe(0);
+    });
+    test("reassembles the maximum ISO chain of 256 payloads", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null });
+      const common = {
+        mpuSequenceNumber: 47,
+        timestamp: 54323n,
+        rapFlag: false
+      };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 255,
+          itemId: 1,
+          data: new Uint8Array([0]),
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(47, 255)
+        })
+      ).toBeNull();
+      for (let counter = 254; counter > 0; counter--) {
+        expect(
+          reassembler.addFragment({
+            ...common,
+            fragmentationIndicator: 2,
+            fragmentCounter: counter,
+            data: new Uint8Array([255 - counter]),
+            packetSequenceNumber: testPacketSequence(47, counter)
+          })
+        ).toBeNull();
+      }
+      const out = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        data: new Uint8Array([255]),
+        packetSequenceNumber: testPacketSequence(47, 0)
+      });
+      expect(out?.fragmentCount).toBe(256);
+      expect(out?.data).toEqual(Uint8Array.from({ length: 256 }, (_, index) => index));
+    });
+    test("should not reassemble without last fragment (FI=3)", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 2,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 2)
+      });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([2]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(result).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+    });
+    test("bounds continuations that arrive before their first fragments", () => {
+      const reassembler = new MFUReassembler({
+        timeoutMs: null,
+        maxBuffered: 1
+      });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 1,
+          fragmentCounter: 0,
+          data: new Uint8Array([1]),
+          timestamp: 1000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(1, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 2,
+          fragmentCounter: 0,
+          data: new Uint8Array([2]),
+          timestamp: 1000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(2, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      expect(reassembler.getStatus().pendingFragments).toBe(1);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(1);
+      const completed = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 1,
+        itemId: 2,
+        data: new Uint8Array([4]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(2, 1)
+      });
+      expect(completed?.data).toEqual(new Uint8Array([4, 2]));
+      expect(reassembler.stats.evictedMemoryLimit).toBe(1);
+      expect(reassembler.pendingCount).toBe(0);
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([3]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(result).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+    });
+    test("expires a continuation that never receives its first fragment", () => {
+      vi.useFakeTimers();
+      try {
+        const reassembler = new MFUReassembler({
+          timeoutMs: 50,
+          maxBuffered: 1
+        });
+        expect(
+          reassembler.addFragment({
+            fragmentationIndicator: 3,
+            mpuSequenceNumber: 1,
+            fragmentCounter: 0,
+            data: new Uint8Array([1]),
+            timestamp: 1000n,
+            rapFlag: false,
+            packetSequenceNumber: testPacketSequence(1, 0)
+          })
+        ).toBeNull();
+        vi.advanceTimersByTime(50);
+        expect(reassembler.pendingCount).toBe(0);
+        expect(reassembler.stats.timedOutMFUs).toBe(1);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+    test("retimes retained continuations when the timeout policy changes", () => {
+      vi.useFakeTimers();
+      try {
+        const enabled = new MFUReassembler({ timeoutMs: null, maxBuffered: 1 });
+        expect(
+          enabled.addFragment({
+            fragmentationIndicator: 3,
+            mpuSequenceNumber: 1,
+            fragmentCounter: 0,
+            data: new Uint8Array([1]),
+            timestamp: 1000n,
+            rapFlag: false,
+            packetSequenceNumber: testPacketSequence(1, 0)
+          })
+        ).toBeNull();
+        enabled.timeoutMs = 10;
+        vi.advanceTimersByTime(10);
+        expect(enabled.pendingCount).toBe(0);
+        const disabled = new MFUReassembler({ timeoutMs: 10, maxBuffered: 1 });
+        expect(
+          disabled.addFragment({
+            fragmentationIndicator: 3,
+            mpuSequenceNumber: 2,
+            fragmentCounter: 0,
+            data: new Uint8Array([2]),
+            timestamp: 1000n,
+            rapFlag: false,
+            packetSequenceNumber: testPacketSequence(2, 0)
+          })
+        ).toBeNull();
+        disabled.timeoutMs = null;
+        vi.advanceTimersByTime(10);
+        expect(disabled.pendingCount).toBe(1);
+        disabled.flush();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+    test("bounds active data units by evicting the oldest at maxBuffered", () => {
+      const reassembler = new MFUReassembler({
+        timeoutMs: 1e3,
+        maxBuffered: 2
+      });
+      for (let i = 0; i < 2; i++) {
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: i,
+          fragmentCounter: 1,
+          itemId: i,
+          data: new Uint8Array([i]),
+          timestamp: BigInt(i * 100),
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(i, 1)
+        });
+      }
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 2,
+          fragmentCounter: 1,
+          itemId: 2,
+          data: new Uint8Array([2]),
+          timestamp: 200n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(2, 1)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      expect(reassembler.stats.timedOutMFUs).toBe(0);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(1);
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 0,
+          fragmentCounter: 0,
+          data: new Uint8Array([9]),
+          timestamp: 300n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(0, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(2);
+      expect(reassembler.stats.timedOutMFUs).toBe(0);
+    });
+    test("should report stats correctly", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: false
+      });
+      const status = reassembler.getStatus();
+      expect(status.bufferedMFUs).toBe(0);
+      expect(status.stats.totalFragments).toBe(1);
+      expect(status.stats.reassembledMFUs).toBe(1);
+    });
+    test("rejects an overlapping first without replacing the original fragment", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 1000n,
+        rapFlag: true,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 1,
+          fragmentCounter: 1,
+          itemId: 2,
+          data: new Uint8Array([187]),
+          timestamp: 1000n,
+          rapFlag: true,
+          source: "moq",
+          packetSequenceNumber: testPacketSequence(1, 1)
+        }),
+        "overlapping-data-unit"
+      );
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.data).toEqual(new Uint8Array([170, 204]));
+      expect(result.fragmentCount).toBe(2);
+      expect(result.source).toBe("multicast");
+    });
+  });
+  test("should retain an assembly with a gap in fragment counters", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 1,
+      fragmentCounter: 3,
+      itemId: 1,
+      data: new Uint8Array([170]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(1, 3)
+    });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([221]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(1);
+    expect(reassembler.getStatus().pendingFragments).toBe(3);
+  });
+  test("accepts a reordered countdown and rejects a stale duplicate", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 1,
+      fragmentCounter: 3,
+      itemId: 1,
+      data: new Uint8Array([170]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(1, 3)
+    });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 2,
+        data: new Uint8Array([187]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 2)
+      })
+    ).toBeNull();
+    expectRejection(
+      () => reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      }),
+      "fragment-counter-mismatch"
+    );
+    const result = reassembler.addFragment({
+      fragmentationIndicator: 3,
+      mpuSequenceNumber: 1,
+      fragmentCounter: 0,
+      data: new Uint8Array([221]),
+      timestamp: 1002n,
+      rapFlag: false,
+      packetSequenceNumber: testPacketSequence(1, 0)
+    });
+    expect(result).not.toBeNull();
+    expect(result.data).toEqual(new Uint8Array([170, 187, 204, 221]));
+    expect(result.fragmentCount).toBe(4);
+  });
+  test("rejects an overlapping first without discarding queued continuations", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    const fragment = (fragmentationIndicator, fragmentCounter, byte) => ({
+      fragmentationIndicator,
+      mpuSequenceNumber: 2,
+      fragmentCounter,
+      data: new Uint8Array([byte]),
+      timestamp: 1000n,
+      rapFlag: fragmentationIndicator === 1,
+      packetSequenceNumber: testPacketSequence(2, fragmentCounter),
+      ...fragmentationIndicator === 1 ? { itemId: 9 } : {}
+    });
+    expect(reassembler.addFragment(fragment(1, 3, 170))).toBeNull();
+    expect(reassembler.addFragment(fragment(2, 1, 204))).toBeNull();
+    expectRejection(() => reassembler.addFragment(fragment(1, 1, 238)), "overlapping-data-unit");
+    expect(reassembler.addFragment(fragment(2, 2, 187))).toBeNull();
+    expect(reassembler.addFragment(fragment(3, 0, 221))?.data).toEqual(new Uint8Array([170, 187, 204, 221]));
+  });
+  test("rejects a duplicate emitted intrinsic identity", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(42, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 0,
+        data: new Uint8Array([171]),
+        timestamp: 1001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(42, 0)
+      })
+    ).not.toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 0,
+        data: new Uint8Array([188]),
+        timestamp: 1002n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(42, 0, 10)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(1);
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([187]),
+        timestamp: 2000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(42, 1, 10)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(1);
+    const result = reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 43,
+      fragmentCounter: 1,
+      itemId: 1,
+      data: new Uint8Array([204]),
+      timestamp: 2000n,
+      rapFlag: false,
+      packetSequenceNumber: testPacketSequence(43, 1)
+    });
+    expect(result).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 43,
+        fragmentCounter: 0,
+        data: new Uint8Array([221]),
+        timestamp: 2001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(43, 0)
+      })?.data
+    ).toEqual(new Uint8Array([204, 221]));
+  });
+  test("does not create active state for an emitted identity duplicate", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 50,
+        fragmentCounter: 1,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(50, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 50,
+        fragmentCounter: 0,
+        data: new Uint8Array([178]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(50, 0)
+      })?.data
+    ).toEqual(new Uint8Array([161, 178]));
+    expect(reassembler.pendingCount).toBe(0);
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 50,
+        fragmentCounter: 1,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp: 2000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(50, 1, 10)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(0);
+  });
+  test("flush should clear emitted set and allow re-assembly", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    const first = reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 1,
+      itemId: 1,
+      data: new Uint8Array([170]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 1)
+    });
+    expect(first).toBeNull();
+    const assembled = reassembler.addFragment({
+      fragmentationIndicator: 3,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 0,
+      data: new Uint8Array([187]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 0)
+    });
+    expect(assembled).not.toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(42, 1, 10)
+      })
+    ).toBeNull();
+    reassembler.flush();
+    const r2 = reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 1,
+      itemId: 1,
+      data: new Uint8Array([221]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 1)
+    });
+    expect(r2).toBeNull();
+    const r3 = reassembler.addFragment({
+      fragmentationIndicator: 3,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 0,
+      data: new Uint8Array([238]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 0)
+    });
+    expect(r3).not.toBeNull();
+    expect(r3.data).toEqual(new Uint8Array([221, 238]));
+  });
+  describe("createFragment", () => {
+    test("should create fragment from complete timed MMTP packet", () => {
+      const packet = new Uint8Array(12 + 8 + 14 + 5);
+      packet[0] = 1;
+      packet[1] = 0;
+      const view = new DataView(packet.buffer);
+      view.setUint16(2, 1, false);
+      view.setUint32(4, 42, false);
+      view.setUint32(8, 100, false);
+      view.setUint16(12, 25, false);
+      packet[14] = 40;
+      packet[15] = 0;
+      view.setUint32(16, 999, false);
+      view.setUint32(20, 7, false);
+      view.setUint32(24, 1, false);
+      packet[34] = 222;
+      packet[35] = 173;
+      packet[36] = 190;
+      packet[37] = 239;
+      packet[38] = 1;
+      const frag = createFragment(packet);
+      expect(frag.mpuSequenceNumber).toBe(999);
+      expect(frag.fragmentationIndicator).toBe(0);
+      expect(frag.rapFlag).toBe(true);
+      expect(frag.movieFragmentSequenceNumber).toBe(7);
+      expect(frag.sampleNumber).toBe(1);
+      expect(frag.sampleOffset).toBe(0);
+      expect(frag.data.length).toBe(5);
+    });
+    test("reads Item_ID from a non-timed MFU DU header", () => {
+      const packet = new Uint8Array(12 + 8 + 4 + 2);
+      const view = new DataView(packet.buffer);
+      view.setUint16(2, 1, false);
+      view.setUint32(4, 42, false);
+      view.setUint32(8, 100, false);
+      view.setUint16(12, 12, false);
+      packet[14] = 32;
+      view.setUint32(16, 999, false);
+      view.setUint32(20, 16909060, false);
+      packet.set([222, 173], 24);
+      const fragment = createFragment(packet);
+      expect(fragment.itemId).toBe(16909060);
+      expect(fragment.data).toEqual(new Uint8Array([222, 173]));
+    });
+  });
+  describe("processMMTPWithReassembly", () => {
+    test("should skip FEC repair packets", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const packet = new Uint8Array(12 + 8 + 14 + 4);
+      packet[0] = 16;
+      const result = processMMTPWithReassembly(packet, reassembler);
+      expect(result).toBeNull();
+    });
+    test("should return reassembled MFU for complete packet", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const packet = new Uint8Array(12 + 8 + 14 + 4);
+      packet[0] = 1;
+      packet[1] = 0;
+      const view = new DataView(packet.buffer);
+      view.setUint16(2, 1, false);
+      view.setUint32(4, 100, false);
+      view.setUint32(8, 1, false);
+      view.setUint16(12, 24, false);
+      packet[14] = 40;
+      view.setUint32(16, 42, false);
+      view.setUint32(20, 7, false);
+      view.setUint32(24, 1, false);
+      packet[34] = 0;
+      packet[35] = 0;
+      packet[36] = 0;
+      packet[37] = 1;
+      const result = processMMTPWithReassembly(packet, reassembler);
+      expect(result).not.toBeNull();
+      expect(result.mpuSequenceNumber).toBe(42);
+      expect(result.rapFlag).toBe(true);
+    });
+  });
+  describe("strict delivery provenance", () => {
+    test("folds to multicast only when every fragment is explicitly multicast", () => {
+      expect(deliveryProvenanceOf([{ source: "multicast" }, { source: "multicast" }])).toBe("multicast");
+    });
+    test("a single moq fragment makes the whole frame mixed", () => {
+      expect(deliveryProvenanceOf([{ source: "multicast" }, { source: "moq" }])).toBe("mixed");
+      expect(deliveryProvenanceOf([{ source: "moq" }, { source: "multicast" }])).toBe("mixed");
+    });
+    test("an unattributed fragment degrades multicast to unknown, never to proven", () => {
+      expect(deliveryProvenanceOf([{ source: "multicast" }, {}])).toBe("unknown");
+      expect(deliveryProvenanceOf([{}])).toBe("unknown");
+    });
+    test("mixed absorbs unknown \u2014 a moq byte is worse news than a missing label", () => {
+      expect(deliveryProvenanceOf([{ source: "moq" }, {}])).toBe("mixed");
+      expect(deliveryProvenanceOf([{}, { source: "moq" }])).toBe("mixed");
+    });
+    test("an empty fragment set proves nothing", () => {
+      expect(deliveryProvenanceOf([])).toBe("unknown");
+    });
+    test("the fold never upgrades a verdict", () => {
+      expect(foldDeliveryProvenance("mixed", "multicast")).toBe("mixed");
+      expect(foldDeliveryProvenance("unknown", "multicast")).toBe("unknown");
+      expect(foldDeliveryProvenance("unknown", "moq")).toBe("mixed");
+    });
+    test("a multicast head with a non-multicast tail is NOT multicast-exclusive", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 1000n,
+        rapFlag: true,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        source: "moq",
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.fragmentCount).toBe(2);
+      expect(result.source).toBe("multicast");
+      expect(result.deliveryProvenance).toBe("mixed");
+    });
+    test("an all-multicast fragmented frame is multicast-exclusive", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 2000n,
+        rapFlag: true,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(2, 1)
+      });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 0,
+        data: new Uint8Array([204]),
+        timestamp: 2000n,
+        rapFlag: false,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(2, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.deliveryProvenance).toBe("multicast");
+    });
+    test("an unlabelled complete frame proves nothing", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 3,
+        fragmentCounter: 0,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 3000n,
+        rapFlag: true
+      });
+      expect(result).not.toBeNull();
+      expect(result.deliveryProvenance).toBe("unknown");
+    });
+  });
+}
+
+// src/wasm-mfu-reassembler.ts
+function asNumber(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
+function timestampU32(timestamp) {
+  return Number(BigInt.asUintN(32, timestamp));
+}
+var WasmMfuReassembler = class {
+  #bindings;
+  #core;
+  #now;
+  #timeoutMs;
+  #cleanupTimer = null;
+  #nextStreamIdentity = 1;
+  #streamIdentityByKey = /* @__PURE__ */ new Map();
+  #streamNameByIdentity = /* @__PURE__ */ new Map();
+  // Every fragment handed to the core, including ones it rejected. This is
+  // what `coreTotal + rejectedBeforeCore` computed with a core stats() round
+  // trip before and after every fragment (BLO-36599).
+  #offeredFragments = 0;
+  #rejectedFragments = 0;
+  #stats = {
+    totalFragments: 0,
+    reassembledMFUs: 0,
+    rejectedFragments: 0,
+    timedOutMFUs: 0,
+    evictedMemoryLimit: 0,
+    outOfOrderFragments: 0
+  };
+  constructor(options) {
+    const maxBuffered = options.maxBuffered ?? 100;
+    if (!Number.isInteger(maxBuffered) || maxBuffered <= 0) {
+      throw new Error("[WasmMfuReassembler] maxBuffered must be a positive integer");
+    }
+    this.#bindings = options.bindings;
+    this.#timeoutMs = options.timeoutMs;
+    this.#now = options.now ?? (() => globalThis.performance?.now() ?? Date.now());
+    this.#core = options.timeoutMs === null ? options.bindings.MmtReassembler.clock_free(maxBuffered) : new options.bindings.MmtReassembler(options.timeoutMs, maxBuffered);
+  }
+  get timeoutMs() {
+    return this.#timeoutMs;
+  }
+  /**
+   * Host-observable reassembly statistics, read from the core when asked.
+   * Reading them is a wasm crossing plus six counter getters, so neither
+   * addFragment nor the router's per-packet path refreshes them (BLO-36599).
+   */
+  get stats() {
+    this.#refreshStats();
+    return this.#stats;
+  }
+  set timeoutMs(timeoutMs) {
+    if (timeoutMs !== null && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+      throw new Error("[WasmMfuReassembler] timeoutMs must be a finite number > 0");
+    }
+    this.#timeoutMs = timeoutMs;
+    if (timeoutMs === null) this.#core.set_clock_free();
+    else this.#core.set_timeout(Math.ceil(timeoutMs));
+    this.#scheduleCleanup();
+  }
+  addFragment(fragment) {
+    const wasmFragment = new this.#bindings.MfuFragmentJs(
+      fragment.mpuSequenceNumber,
+      fragment.fragmentationIndicator,
+      fragment.fragmentCounter,
+      fragment.data,
+      timestampU32(fragment.timestamp),
+      fragment.rapFlag
+    );
+    if (fragment.movieFragmentSequenceNumber !== void 0 && fragment.sampleNumber !== void 0 && fragment.sampleNumber > 0 && fragment.sampleOffset !== void 0) {
+      wasmFragment.with_sample_identity(
+        fragment.movieFragmentSequenceNumber,
+        fragment.sampleNumber,
+        fragment.sampleOffset
+      );
+    }
+    if (fragment.itemId !== void 0) wasmFragment.set_item_id(fragment.itemId);
+    if (fragment.packetSequenceNumber !== void 0) {
+      wasmFragment.set_packet_delivery?.(
+        fragment.packetSequenceNumber,
+        fragment.recovered === true
+      );
+    }
+    if (fragment.priority !== void 0) wasmFragment.set_priority(fragment.priority);
+    if (fragment.source !== void 0) {
+      wasmFragment.set_attribution(fragment.source === "multicast" ? 1 : 2);
+    }
+    const streamIdentity = this.#streamIdentityFor(fragment);
+    if (streamIdentity !== void 0) {
+      wasmFragment.set_stream_identity(streamIdentity);
+    }
+    let output;
+    try {
+      output = this.#core.add_fragment(this.#now(), wasmFragment);
+    } catch (error) {
+      const rejection = this.#asReassemblyError(error);
+      if (rejection === null) throw error;
+      this.#offeredFragments++;
+      this.#rejectedFragments++;
+      this.#ensureCleanupArmed();
+      throw rejection;
+    }
+    this.#offeredFragments++;
+    this.#ensureCleanupArmed();
+    if (!output) return null;
+    try {
+      const catalogTrackName = output.stream_identity === void 0 ? void 0 : this.#streamNameByIdentity.get(output.stream_identity);
+      const packetSequenceNumbers = output.packet_sequence_numbers === void 0 ? void 0 : Array.from(output.packet_sequence_numbers);
+      const repairedPacketSequenceNumbers = output.repaired_packet_sequence_numbers === void 0 ? void 0 : Array.from(output.repaired_packet_sequence_numbers);
+      return {
+        mpuSequenceNumber: output.mpu_sequence_number,
+        ...packetSequenceNumbers?.[0] === void 0 ? {} : { packetSequenceNumber: packetSequenceNumbers[0] },
+        ...packetSequenceNumbers === void 0 ? {} : { packetSequenceNumbers },
+        ...repairedPacketSequenceNumbers === void 0 ? {} : { repairedPacketSequenceNumbers },
+        data: output.data,
+        timestamp: BigInt(output.timestamp),
+        fragmentCount: output.fragment_count,
+        rapFlag: output.rap_flag,
+        ...output.priority === void 0 ? {} : { priority: output.priority },
+        ...output.sample_number === void 0 ? {} : { sampleNumber: output.sample_number },
+        ...output.movie_fragment_sequence_number === void 0 ? {} : {
+          movieFragmentSequenceNumber: output.movie_fragment_sequence_number
+        },
+        ...output.attribution === 1 ? { source: "multicast" } : output.attribution === 2 ? { source: "moq" } : {},
+        // The Rust core folds `attribution` over every contributing fragment
+        // and reports None unless they were unanimous, so a tag here is
+        // already whole-frame evidence. A missing tag means "not unanimous or
+        // never recorded" — both unproven, never multicast.
+        deliveryProvenance: output.attribution === 1 ? "multicast" : output.attribution === 2 ? "mixed" : "unknown",
+        ...catalogTrackName === void 0 ? {} : { catalogTrackName }
+      };
+    } finally {
+      output.free();
+    }
+  }
+  flush() {
+    this.#clearCleanupTimer();
+    this.#core.flush();
+  }
+  resetStream(catalogTrackName) {
+    const streamIdentity = this.#streamIdentityByKey.get(`catalog:${catalogTrackName}`);
+    if (streamIdentity === void 0) return;
+    this.#clearCleanupTimer();
+    this.#core.reset_stream(streamIdentity);
+    this.#scheduleCleanup();
+  }
+  reset() {
+    this.#clearCleanupTimer();
+    this.#core.reset();
+    this.#nextStreamIdentity = 1;
+    this.#streamIdentityByKey.clear();
+    this.#streamNameByIdentity.clear();
+    this.#offeredFragments = 0;
+    this.#rejectedFragments = 0;
+  }
+  get pendingCount() {
+    return this.#core.buffered_count;
+  }
+  getStatus() {
+    this.#refreshStats();
+    return {
+      bufferedMFUs: this.#core.buffered_count,
+      pendingFragments: this.#core.pending_fragment_count,
+      // Detailed fragment coordinates remain internal to the Rust core. Counts
+      // and health statistics stay available to MmtpRouter diagnostics.
+      pendingSamples: [],
+      stats: { ...this.#stats }
+    };
+  }
+  #refreshStats() {
+    const stats = this.#core.stats();
+    this.#stats.totalFragments = this.#offeredFragments;
+    this.#stats.reassembledMFUs = asNumber(stats.reassembled_mfus);
+    this.#stats.rejectedFragments = this.#rejectedFragments;
+    this.#stats.timedOutMFUs = asNumber(stats.timed_out_mfus);
+    this.#stats.evictedMemoryLimit = asNumber(stats.evicted_memory_limit) + asNumber(stats.evicted_data_units ?? 0);
+    this.#stats.outOfOrderFragments = asNumber(stats.out_of_order_fragments);
+    stats.free?.();
+  }
+  #streamIdentityFor(fragment) {
+    const key = fragment.catalogTrackName !== void 0 ? `catalog:${fragment.catalogTrackName}` : fragment.packetId !== void 0 ? `packet:${fragment.packetId}` : void 0;
+    if (key === void 0) return void 0;
+    const existing = this.#streamIdentityByKey.get(key);
+    if (existing !== void 0) return existing;
+    const identity = this.#nextStreamIdentity++;
+    this.#streamIdentityByKey.set(key, identity);
+    if (fragment.catalogTrackName !== void 0) {
+      this.#streamNameByIdentity.set(identity, fragment.catalogTrackName);
+    }
+    return identity;
+  }
+  #asReassemblyError(error) {
+    if (typeof error !== "object" && typeof error !== "function" || error === null) return null;
+    const code = Reflect.get(error, "code");
+    if (!isMfuReassemblyErrorCode(code)) return null;
+    const message = Reflect.get(error, "message");
+    return new MfuReassemblyError(
+      code,
+      typeof message === "string" ? message : `MFU reassembly rejected: ${code}`
+    );
+  }
+  /**
+   * Arm the cleanup wake-up only when none is armed. A fragment can only add
+   * a data unit whose deadline is its own arrival plus the one configured
+   * timeout, which is never earlier than the deadline already armed; the
+   * armed wake-up re-reads the core's next deadline after cleanup. Only a
+   * timeout change can move the next deadline earlier, and the timeoutMs
+   * setter re-arms for that. This replaces a next_timeout_at() crossing and a
+   * clear+set timer pair on every fragment (BLO-36599).
+   */
+  #ensureCleanupArmed() {
+    if (this.#cleanupTimer === null) this.#scheduleCleanup();
+  }
+  #scheduleCleanup() {
+    this.#clearCleanupTimer();
+    if (this.#timeoutMs === null) return;
+    const next = this.#core.next_timeout_at();
+    if (next === void 0) return;
+    const delay = Math.max(0, Math.ceil(next - this.#now()));
+    this.#cleanupTimer = setTimeout(() => {
+      this.#cleanupTimer = null;
+      this.#core.cleanup_timeouts(this.#now());
+      this.#scheduleCleanup();
+    }, delay);
+  }
+  #clearCleanupTimer() {
+    if (this.#cleanupTimer === null) return;
+    clearTimeout(this.#cleanupTimer);
+    this.#cleanupTimer = null;
+  }
+};
+function resolveGlobalMmtWasmBindings() {
+  const globals = globalThis;
+  const bindings = globals.__MmtWasmBindings ?? globals.__blockcastMmtReassemblerWasmBindgen;
+  if (!bindings?.MmtReassembler || !bindings.MfuFragmentJs) {
+    throw new Error("[WasmMfuReassembler] initialized mmt-wasm bindings are unavailable");
+  }
+  return bindings;
+}
+export {
+  WasmMfuReassembler,
+  resolveGlobalMmtWasmBindings
+};
+//# sourceMappingURL=wasm-mfu-reassembler.js.map