@blockcast/mmt-wasm 0.0.0-stage → 0.1.0

package/pkg/mmt_wasm.d.ts

@@ -0,0 +1,1067 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class CombinedSampleJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly attribution: number | undefined;
+  readonly sample_number: number;
+  readonly stream_identity: number | undefined;
+  /**
+   * Number of subsample data units combined (1 for a whole-sample DU or a
+   * non-timed passthrough).
+   */
+  readonly subsample_count: number;
+  readonly mpu_sequence_number: number;
+  readonly packet_sequence_numbers: Uint32Array | undefined;
+  readonly movie_fragment_sequence_number: number;
+  readonly repaired_packet_sequence_numbers: Uint32Array | undefined;
+  /**
+   * Same pattern as [`ReassembledMfuJs::data`].
+   */
+  readonly data: Uint8Array;
+  readonly priority: number | undefined;
+  readonly rap_flag: boolean;
+  readonly timestamp: number;
+}
+
+export class FecStats {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Recovery rate as percentage (0-100)
+   * Counts all blocks: complete + recovered + FEC-failed + delivery-failed
+   */
+  recovery_rate(): number;
+  constructor();
+  source_packets: bigint;
+  repair_packets: bigint;
+  blocks_complete: bigint;
+  blocks_recovered: bigint;
+  blocks_failed: bigint;
+  bytes_recovered: bigint;
+  /**
+   * Blocks that expired with fewer than K symbols (delivery issue, not FEC issue)
+   */
+  blocks_delivery_failed: bigint;
+}
+
+export class MfuFragmentJs {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Attach the non-timed MFU Item_ID.
+   */
+  set_item_id(item_id: number): void;
+  /**
+   * Attach timed-MFU DU priority metadata.
+   */
+  set_priority(priority: number): void;
+  /**
+   * Attach an opaque host attribution tag that follows the accepted frame.
+   */
+  set_attribution(attribution: number): void;
+  /**
+   * Attach the authored source-header packet sequence and whether FEC
+   * reconstructed it. Recovered packets must retain the original u32 value.
+   */
+  set_packet_delivery(packet_sequence_number: number, recovered: boolean): void;
+  /**
+   * Attach an opaque host stream identity used to isolate reassembly state.
+   */
+  set_stream_identity(stream_identity: number): void;
+  /**
+   * 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).
+   */
+  with_sample_identity(movie_fragment_sequence: number, sample_number: number, offset: number): void;
+  /**
+   * 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.
+   */
+  constructor(mpu_sequence_number: number, fragmentation_indicator: number, fragment_counter: number, data: Uint8Array, timestamp: number, rap_flag: boolean);
+}
+
+export class MmtFecDecoder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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.
+   */
+  add_repair(ss_start: number, ssb_length: number, rs_id: number, data: Uint8Array, timestamp: number): Uint8Array | undefined;
+  /**
+   * 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())
+   */
+  add_source(ss_id: number, data: Uint8Array, timestamp: number): Uint8Array | undefined;
+  /**
+   * Reset statistics
+   */
+  reset_stats(): void;
+  /**
+   * Get alignment (Al) parameter from OTI
+   */
+  get_alignment(): number;
+  /**
+   * `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.
+   */
+  cleanup_by_sbn(current_sbn: number): Uint32Array;
+  /**
+   * Get sub-blocks (N) parameter from OTI
+   */
+  get_sub_blocks(): number;
+  /**
+   * Get number of pending blocks
+   */
+  pending_blocks(): number;
+  /**
+   * Get symbol size (T) parameter from OTI
+   */
+  get_symbol_size(): number;
+  /**
+   * `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.
+   */
+  retire_unplaced(current: number): number;
+  /**
+   * 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.
+   */
+  configure_params(k: number, symbol_size: number): void;
+  /**
+   * The `fec.blockProfile` token this decoder was built for.
+   */
+  get_block_profile(): string;
+  /**
+   * Get source blocks (Z) parameter from OTI
+   */
+  get_source_blocks(): number;
+  /**
+   * `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.
+   */
+  cleanup_by_ss_start(current: number): Uint32Array;
+  /**
+   * Get current interleave depth
+   */
+  get_interleave_depth(): number;
+  /**
+   * 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.
+   */
+  cleanup_blocks_detailed(sbns: Uint32Array): void;
+  /**
+   * 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.
+   */
+  constructor(interleave_depth: number, block_profile: string);
+  /**
+   * Flush all pending decoder state while preserving configuration.
+   */
+  flush(): void;
+  /**
+   * Get K (symbols per block) derived from OTI
+   */
+  get_k(): number;
+  /**
+   * Configure FEC from 12-byte OTI
+   *
+   * # Arguments
+   * * `oti` - 12-byte Object Transmission Information from S-TSID fecOTI
+   */
+  configure(oti: Uint8Array): void;
+  /**
+   * Get current statistics
+   */
+  get_stats(): FecStats;
+}
+
+export class MmtFecEncoder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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.
+   */
+  encode_repair(block: number, source_block: Uint8Array, repair_count: number): Uint8Array;
+  /**
+   * 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.
+   */
+  constructor(k: number, symbol_size: number, block_profile: string);
+  /**
+   * 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`.
+   */
+  oti(): Uint8Array;
+  /**
+   * Symbol size (T) in bytes.
+   */
+  readonly symbol_size: number;
+  /**
+   * The `fec.blockProfile` token this encoder was built for.
+   */
+  readonly block_profile: string;
+  /**
+   * Source symbols per block (K).
+   */
+  readonly k: number;
+}
+
+/**
+ * MMT MPU fragment type (ISO/IEC 23008-1 MPU fragmentation), exposed to JS as
+ * a u8-backed enum. Mirrors `mmt_core::header::FragmentType`.
+ */
+export enum MmtFragmentType {
+  /**
+   * Initialization segment (ftyp + moov).
+   */
+  Init = 0,
+  /**
+   * Movie fragment (moof + mdat).
+   */
+  Fragment = 1,
+  /**
+   * Media Fragment Unit (individual samples / NAL units).
+   */
+  Mfu = 2,
+}
+
+export class MmtPacketizer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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.
+   */
+  constructor(mtu: number);
+  /**
+   * 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).
+   */
+  fragment(payload: Uint8Array): Uint32Array;
+  /**
+   * Build one complete MFU packet (MMTP + MPU + MFU headers + `sample_data`)
+   * and return its bytes.
+   */
+  build_mfu(packet_id: number, mpu_sequence: number, movie_fragment_sequence: number, sample_number: number, sample_data: Uint8Array, rap_flag: boolean): Uint8Array;
+  /**
+   * Build one complete MPU packet (MMTP header + MPU header + `payload`) and
+   * return its bytes. `fragment_type` selects Init / Fragment / Mfu framing.
+   */
+  build_mpu(packet_id: number, mpu_sequence: number, fragment_type: MmtFragmentType, payload: Uint8Array, rap_flag: boolean): Uint8Array;
+  /**
+   * 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`.
+   */
+  readonly max_payload: number;
+  /**
+   * Configured MTU.
+   */
+  readonly mtu: number;
+}
+
+export class MmtReassembler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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)`.
+   */
+  static clock_free(max_buffered: number): MmtReassembler;
+  /**
+   * Switch to a catalog/in-band-derived numeric deadline without dropping
+   * in-flight MFUs.
+   */
+  set_timeout(timeout_ms: number): void;
+  /**
+   * 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`.
+   */
+  add_fragment(now: number, fragment: MfuFragmentJs): ReassembledMfuJs | undefined;
+  /**
+   * Drop one stream's buffered and dedup state without disturbing other
+   * tracks sharing this reassembler instance.
+   */
+  reset_stream(stream_identity: number): void;
+  /**
+   * Switch to reliable-MoQ clock-free operation without dropping in-flight MFUs.
+   */
+  set_clock_free(): void;
+  /**
+   * Earliest absolute `performance.now()` millisecond tick requiring cleanup.
+   */
+  next_timeout_at(): number | undefined;
+  /**
+   * Expire incomplete objects past the timeout and enforce the memory limit.
+   * The host drives this — see the constructor note.
+   */
+  cleanup_timeouts(now: number): void;
+  /**
+   * 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).
+   */
+  constructor(timeout_ms: number, max_buffered: number);
+  /**
+   * Drop all buffered fragments and dedup state (call on stream end / seek).
+   */
+  flush(): void;
+  /**
+   * Flush buffered state and zero statistics.
+   */
+  reset(): void;
+  /**
+   * Statistics snapshot.
+   */
+  stats(): ReassemblerStatsJs;
+  /**
+   * Number of incomplete objects currently buffered.
+   */
+  readonly buffered_count: number;
+  /**
+   * Fragments retained across all incomplete objects.
+   */
+  readonly pending_fragment_count: number;
+}
+
+export class MmtSampleCombiner {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Drop one stream's buffered and registered-size state without
+   * disturbing other streams sharing this combiner instance.
+   */
+  reset_stream(stream_identity: number): void;
+  /**
+   * Discard samples whose oldest held segment has waited past
+   * `timeout_ms`. The host drives this, mirroring
+   * [`MmtReassembler::cleanup_timeouts`].
+   */
+  cleanup_timeouts(now: number, timeout_ms: number): void;
+  /**
+   * 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.
+   */
+  register_authored_size(stream_identity: number | null | undefined, mpu_sequence_number: number, movie_fragment_sequence_number: number, sample_number: number, size: number): CombinedSampleJs | undefined;
+  /**
+   * * `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).
+   */
+  constructor(max_buffered: number, require_authored_size: boolean, max_segments_per_sample: number);
+  /**
+   * Drop all buffered subsample state (call on stream end / seek).
+   */
+  flush(): void;
+  /**
+   * Statistics snapshot.
+   */
+  stats(): SampleCombinerStatsJs;
+  /**
+   * 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`.
+   */
+  add_mfu(now: number, mfu: ReassembledMfuJs): CombinedSampleJs | undefined;
+  /**
+   * Number of incomplete samples currently buffered.
+   */
+  readonly pending_count: number;
+}
+
+export class MoqEncodedBlock {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  getRepairSymbol(index: number): Uint8Array | undefined;
+  getSourceSymbol(index: number): Uint8Array | undefined;
+  repairSymbolCount(): number;
+  sourceSymbolCount(): number;
+  getOti(): Uint8Array;
+  readonly original_len: number;
+  readonly k: number;
+  readonly p: number;
+  readonly block_id: number;
+}
+
+export class MoqFecConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  maxBlockSize(): number;
+  overheadRatio(): number;
+  constructor(symbol_size: number, k: number, p: number, interleave_depth: number);
+  readonly symbol_size: number;
+  readonly interleaveDepth: number;
+  readonly k: number;
+  readonly p: number;
+}
+
+export class MoqFecDecoder {
+  free(): void;
+  [Symbol.dispose](): void;
+  resetBlock(block_id: number): void;
+  getBlockData(block_id: number): Uint8Array;
+  addRepairSymbol(block_id: number, esi: number, symbol: Uint8Array): Uint8Array | undefined;
+  addSourceSymbol(block_id: number, esi: number, symbol: Uint8Array, original_len?: number | null): Uint8Array | undefined;
+  isBlockComplete(block_id: number): boolean;
+  constructor(config: MoqFecConfig, oti: Uint8Array);
+  getStats(): MoqFecStatsJs;
+}
+
+export class MoqFecEncoder {
+  free(): void;
+  [Symbol.dispose](): void;
+  blockCount(): number;
+  encodeBlock(data: Uint8Array): MoqEncodedBlock;
+  constructor(config: MoqFecConfig);
+  getOti(): Uint8Array;
+}
+
+export class MoqFecStatsJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  recoveryRate(): number;
+  effectiveLossRate(): number;
+  readonly blocksComplete: number;
+  readonly interleaveDepth: number;
+  readonly blocksIncomplete: number;
+  readonly k: number;
+  readonly p: number;
+  readonly totalSymbolsReceived: number;
+}
+
+export class ReassembledMfuJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly attribution: number | undefined;
+  readonly sample_number: number | undefined;
+  readonly fragment_count: number;
+  readonly stream_identity: number | undefined;
+  readonly mpu_sequence_number: number;
+  readonly packet_sequence_numbers: Uint32Array | undefined;
+  readonly movie_fragment_sequence_number: number | undefined;
+  readonly repaired_packet_sequence_numbers: Uint32Array | undefined;
+  /**
+   * 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.
+   */
+  readonly data: Uint8Array;
+  /**
+   * 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.
+   */
+  readonly offset: number | undefined;
+  readonly priority: number | undefined;
+  readonly rap_flag: boolean;
+  readonly timestamp: number;
+}
+
+export class ReassemblerStatsJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  total_fragments: bigint;
+  reassembled_mfus: bigint;
+  timed_out_mfus: bigint;
+  evicted_memory_limit: bigint;
+  /**
+   * 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.
+   */
+  evicted_data_units: bigint;
+  out_of_order_fragments: bigint;
+  duplicate_fragments: bigint;
+  ambiguous_fallback_fragments: bigint;
+}
+
+export class RecoveredSet {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * FEC set index within the slot.
+   */
+  readonly fec_set_index: number;
+  /**
+   * Solana slot of the recovered FEC set (JS: `BigInt`).
+   */
+  readonly slot: bigint;
+  /**
+   * 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`].
+   */
+  readonly payload: Uint8Array;
+}
+
+export class SampleCombinerStatsJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  combined_samples: bigint;
+  passthrough_samples: bigint;
+  timed_out_samples: bigint;
+  /**
+   * Incomplete samples discarded to enforce `max_buffered`.
+   */
+  evicted_samples: bigint;
+}
+
+export class ShredFecBuffer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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.
+   */
+  try_recover_all(_now_ms: number): Uint8Array | undefined;
+  /**
+   * Number of incomplete (non-tombstone) FEC sets buffered.
+   */
+  pending_fec_sets(): number;
+  /**
+   * 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`.
+   */
+  try_recover_all_with_identity(_now_ms: number): RecoveredSet | undefined;
+  constructor(timeout_ms: bigint, max_buffered: number);
+  /**
+   * Feed a data or coding shred (wire-v3 erasure shard).
+   * Returns reassembled FEC-set bytes if the set just completed, null otherwise.
+   */
+  add_shred(slot: bigint, fec_set_index: number, local_index: number, num_data: number, num_coding: number, is_coding: boolean, payload: Uint8Array, last_in_set: boolean): Uint8Array | undefined;
+}
+
+export class ShredReassembler {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Number of FEC sets currently buffered (incomplete).
+   */
+  pending_fec_sets(): number;
+  constructor(timeout_ms: bigint, max_buffered: number);
+  /**
+   * Feed one data shred.
+   * Returns the reassembled FEC-set bytes when the set is complete, otherwise null.
+   */
+  add_shred(slot: bigint, fec_set_index: number, local_index: number, payload: Uint8Array, last_in_set: boolean): Uint8Array | undefined;
+}
+
+/**
+ * True when an Annex B access unit contains a keyframe slice for the
+ * catalog codec's family. Every NAL unit header is validated.
+ */
+export function annexb_access_unit_is_keyframe(codec: string, access_unit: Uint8Array): boolean;
+
+/**
+ * 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.
+ */
+export function hevc_codec_string(codec: string, sps: Uint8Array): string;
+
+/**
+ * The `hvcC` HEVCDecoderConfigurationRecord (ISO/IEC 14496-15 8.3.3.1)
+ * built from the VPS, SPS and PPS carried in an Annex B IRAP access unit;
+ * usable as the fMP4 `hvcC` box payload and the WebCodecs `description`.
+ * Samples must then be 4-byte length-prefixed (`lengthSizeMinusOne` = 3).
+ */
+export function hevc_hvcc_from_annexb(codec: string, access_unit: Uint8Array): Uint8Array;
+
+/**
+ * Initialize the WASM module
+ */
+export function init(): void;
+
+/**
+ * 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.
+ */
+export function is_keyframe_nal(codec: string, nal: Uint8Array): boolean;
+
+/**
+ * Exact browser-facing MoQ FEC contract implemented by this module.
+ */
+export function moq_fec_contract_version(): string;
+
+/**
+ * Hash one authenticated object on the browser main thread.
+ */
+export function source_auth_blake3(object: Uint8Array): Uint8Array;
+
+/**
+ * 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.
+ */
+export function ssbg1_source_symbol(packet: Uint8Array, symbol_size: number): Uint8Array;
+
+/**
+ * The sample entry four-character code (`avc1`, `avc3`, `hev1`, `hvc1`)
+ * named by a catalog codec string. Throws for any other codec family.
+ */
+export function video_sample_entry_from_codec_string(codec: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_combinedsamplejs_free: (a: number, b: number) => void;
+  readonly __wbg_fecstats_free: (a: number, b: number) => void;
+  readonly __wbg_get_fecstats_blocks_complete: (a: number) => bigint;
+  readonly __wbg_get_fecstats_blocks_delivery_failed: (a: number) => bigint;
+  readonly __wbg_get_fecstats_blocks_failed: (a: number) => bigint;
+  readonly __wbg_get_fecstats_blocks_recovered: (a: number) => bigint;
+  readonly __wbg_get_fecstats_bytes_recovered: (a: number) => bigint;
+  readonly __wbg_get_fecstats_repair_packets: (a: number) => bigint;
+  readonly __wbg_get_fecstats_source_packets: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_ambiguous_fallback_fragments: (a: number) => bigint;
+  readonly __wbg_mfufragmentjs_free: (a: number, b: number) => void;
+  readonly __wbg_mmtfecdecoder_free: (a: number, b: number) => void;
+  readonly __wbg_mmtfecencoder_free: (a: number, b: number) => void;
+  readonly __wbg_mmtpacketizer_free: (a: number, b: number) => void;
+  readonly __wbg_mmtreassembler_free: (a: number, b: number) => void;
+  readonly __wbg_mmtsamplecombiner_free: (a: number, b: number) => void;
+  readonly __wbg_moqencodedblock_free: (a: number, b: number) => void;
+  readonly __wbg_moqfecconfig_free: (a: number, b: number) => void;
+  readonly __wbg_moqfecdecoder_free: (a: number, b: number) => void;
+  readonly __wbg_moqfecencoder_free: (a: number, b: number) => void;
+  readonly __wbg_moqfecstatsjs_free: (a: number, b: number) => void;
+  readonly __wbg_reassembledmfujs_free: (a: number, b: number) => void;
+  readonly __wbg_reassemblerstatsjs_free: (a: number, b: number) => void;
+  readonly __wbg_recoveredset_free: (a: number, b: number) => void;
+  readonly __wbg_samplecombinerstatsjs_free: (a: number, b: number) => void;
+  readonly __wbg_set_fecstats_blocks_complete: (a: number, b: bigint) => void;
+  readonly __wbg_set_fecstats_blocks_delivery_failed: (a: number, b: bigint) => void;
+  readonly __wbg_set_fecstats_blocks_failed: (a: number, b: bigint) => void;
+  readonly __wbg_set_fecstats_blocks_recovered: (a: number, b: bigint) => void;
+  readonly __wbg_set_fecstats_bytes_recovered: (a: number, b: bigint) => void;
+  readonly __wbg_set_fecstats_repair_packets: (a: number, b: bigint) => void;
+  readonly __wbg_set_fecstats_source_packets: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_ambiguous_fallback_fragments: (a: number, b: bigint) => void;
+  readonly __wbg_shredfecbuffer_free: (a: number, b: number) => void;
+  readonly __wbg_shredreassembler_free: (a: number, b: number) => void;
+  readonly annexb_access_unit_is_keyframe: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly combinedsamplejs_attribution: (a: number) => number;
+  readonly combinedsamplejs_data: (a: number) => [number, number];
+  readonly combinedsamplejs_movie_fragment_sequence_number: (a: number) => number;
+  readonly combinedsamplejs_mpu_sequence_number: (a: number) => number;
+  readonly combinedsamplejs_packet_sequence_numbers: (a: number) => [number, number];
+  readonly combinedsamplejs_priority: (a: number) => number;
+  readonly combinedsamplejs_rap_flag: (a: number) => number;
+  readonly combinedsamplejs_repaired_packet_sequence_numbers: (a: number) => [number, number];
+  readonly combinedsamplejs_sample_number: (a: number) => number;
+  readonly combinedsamplejs_stream_identity: (a: number) => number;
+  readonly combinedsamplejs_subsample_count: (a: number) => number;
+  readonly combinedsamplejs_timestamp: (a: number) => number;
+  readonly fecstats_new: () => number;
+  readonly fecstats_recovery_rate: (a: number) => number;
+  readonly hevc_codec_string: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly hevc_hvcc_from_annexb: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly is_keyframe_nal: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly mfufragmentjs_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly mfufragmentjs_set_attribution: (a: number, b: number) => void;
+  readonly mfufragmentjs_set_item_id: (a: number, b: number) => void;
+  readonly mfufragmentjs_set_packet_delivery: (a: number, b: number, c: number) => void;
+  readonly mfufragmentjs_set_priority: (a: number, b: number) => void;
+  readonly mfufragmentjs_set_stream_identity: (a: number, b: number) => void;
+  readonly mfufragmentjs_with_sample_identity: (a: number, b: number, c: number, d: number) => void;
+  readonly mmtfecdecoder_add_repair: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+  readonly mmtfecdecoder_add_source: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly mmtfecdecoder_cleanup_blocks_detailed: (a: number, b: number, c: number) => void;
+  readonly mmtfecdecoder_cleanup_by_sbn: (a: number, b: number) => [number, number, number, number];
+  readonly mmtfecdecoder_cleanup_by_ss_start: (a: number, b: number) => [number, number, number, number];
+  readonly mmtfecdecoder_configure: (a: number, b: number, c: number) => [number, number];
+  readonly mmtfecdecoder_configure_params: (a: number, b: number, c: number) => [number, number];
+  readonly mmtfecdecoder_flush: (a: number) => void;
+  readonly mmtfecdecoder_get_alignment: (a: number) => [number, number, number];
+  readonly mmtfecdecoder_get_block_profile: (a: number) => [number, number];
+  readonly mmtfecdecoder_get_interleave_depth: (a: number) => number;
+  readonly mmtfecdecoder_get_k: (a: number) => [number, number, number];
+  readonly mmtfecdecoder_get_source_blocks: (a: number) => [number, number, number];
+  readonly mmtfecdecoder_get_stats: (a: number) => number;
+  readonly mmtfecdecoder_get_sub_blocks: (a: number) => [number, number, number];
+  readonly mmtfecdecoder_get_symbol_size: (a: number) => [number, number, number];
+  readonly mmtfecdecoder_new: (a: number, b: number, c: number) => [number, number, number];
+  readonly mmtfecdecoder_pending_blocks: (a: number) => number;
+  readonly mmtfecdecoder_reset_stats: (a: number) => void;
+  readonly mmtfecdecoder_retire_unplaced: (a: number, b: number) => [number, number, number];
+  readonly mmtfecencoder_block_profile: (a: number) => [number, number];
+  readonly mmtfecencoder_encode_repair: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly mmtfecencoder_k: (a: number) => number;
+  readonly mmtfecencoder_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly mmtfecencoder_oti: (a: number) => [number, number];
+  readonly mmtfecencoder_symbol_size: (a: number) => number;
+  readonly mmtpacketizer_build_mfu: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
+  readonly mmtpacketizer_build_mpu: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+  readonly mmtpacketizer_fragment: (a: number, b: number, c: number) => [number, number];
+  readonly mmtpacketizer_max_payload: (a: number) => number;
+  readonly mmtpacketizer_mtu: (a: number) => number;
+  readonly mmtpacketizer_new: (a: number) => [number, number, number];
+  readonly mmtreassembler_add_fragment: (a: number, b: number, c: number) => [number, number, number];
+  readonly mmtreassembler_buffered_count: (a: number) => number;
+  readonly mmtreassembler_cleanup_timeouts: (a: number, b: number) => void;
+  readonly mmtreassembler_clock_free: (a: number) => [number, number, number];
+  readonly mmtreassembler_flush: (a: number) => void;
+  readonly mmtreassembler_new: (a: number, b: number) => [number, number, number];
+  readonly mmtreassembler_next_timeout_at: (a: number) => [number, number];
+  readonly mmtreassembler_pending_fragment_count: (a: number) => number;
+  readonly mmtreassembler_reset: (a: number) => void;
+  readonly mmtreassembler_reset_stream: (a: number, b: number) => void;
+  readonly mmtreassembler_set_clock_free: (a: number) => void;
+  readonly mmtreassembler_set_timeout: (a: number, b: number) => [number, number];
+  readonly mmtreassembler_stats: (a: number) => number;
+  readonly mmtsamplecombiner_add_mfu: (a: number, b: number, c: number) => [number, number, number];
+  readonly mmtsamplecombiner_cleanup_timeouts: (a: number, b: number, c: number) => void;
+  readonly mmtsamplecombiner_flush: (a: number) => void;
+  readonly mmtsamplecombiner_new: (a: number, b: number, c: number) => [number, number, number];
+  readonly mmtsamplecombiner_pending_count: (a: number) => number;
+  readonly mmtsamplecombiner_register_authored_size: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly mmtsamplecombiner_reset_stream: (a: number, b: number) => void;
+  readonly mmtsamplecombiner_stats: (a: number) => number;
+  readonly moq_fec_contract_version: () => [number, number];
+  readonly moqencodedblock_block_id: (a: number) => number;
+  readonly moqencodedblock_getOti: (a: number) => [number, number];
+  readonly moqencodedblock_getRepairSymbol: (a: number, b: number) => [number, number];
+  readonly moqencodedblock_getSourceSymbol: (a: number, b: number) => [number, number];
+  readonly moqencodedblock_k: (a: number) => number;
+  readonly moqencodedblock_original_len: (a: number) => number;
+  readonly moqencodedblock_repairSymbolCount: (a: number) => number;
+  readonly moqencodedblock_sourceSymbolCount: (a: number) => number;
+  readonly moqfecconfig_interleaveDepth: (a: number) => number;
+  readonly moqfecconfig_k: (a: number) => number;
+  readonly moqfecconfig_maxBlockSize: (a: number) => number;
+  readonly moqfecconfig_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly moqfecconfig_overheadRatio: (a: number) => number;
+  readonly moqfecconfig_p: (a: number) => number;
+  readonly moqfecconfig_symbol_size: (a: number) => number;
+  readonly moqfecdecoder_addRepairSymbol: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly moqfecdecoder_addSourceSymbol: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+  readonly moqfecdecoder_getBlockData: (a: number, b: number) => [number, number, number, number];
+  readonly moqfecdecoder_getStats: (a: number) => number;
+  readonly moqfecdecoder_isBlockComplete: (a: number, b: number) => number;
+  readonly moqfecdecoder_new: (a: number, b: number, c: number) => [number, number, number];
+  readonly moqfecdecoder_resetBlock: (a: number, b: number) => [number, number];
+  readonly moqfecencoder_blockCount: (a: number) => number;
+  readonly moqfecencoder_encodeBlock: (a: number, b: number, c: number) => [number, number, number];
+  readonly moqfecencoder_getOti: (a: number) => [number, number];
+  readonly moqfecencoder_new: (a: number) => [number, number, number];
+  readonly moqfecstatsjs_effectiveLossRate: (a: number) => number;
+  readonly moqfecstatsjs_interleaveDepth: (a: number) => number;
+  readonly moqfecstatsjs_k: (a: number) => number;
+  readonly moqfecstatsjs_p: (a: number) => number;
+  readonly moqfecstatsjs_recoveryRate: (a: number) => number;
+  readonly reassembledmfujs_attribution: (a: number) => number;
+  readonly reassembledmfujs_data: (a: number) => [number, number];
+  readonly reassembledmfujs_fragment_count: (a: number) => number;
+  readonly reassembledmfujs_movie_fragment_sequence_number: (a: number) => number;
+  readonly reassembledmfujs_mpu_sequence_number: (a: number) => number;
+  readonly reassembledmfujs_offset: (a: number) => number;
+  readonly reassembledmfujs_packet_sequence_numbers: (a: number) => [number, number];
+  readonly reassembledmfujs_priority: (a: number) => number;
+  readonly reassembledmfujs_rap_flag: (a: number) => number;
+  readonly reassembledmfujs_repaired_packet_sequence_numbers: (a: number) => [number, number];
+  readonly reassembledmfujs_sample_number: (a: number) => number;
+  readonly reassembledmfujs_stream_identity: (a: number) => number;
+  readonly reassembledmfujs_timestamp: (a: number) => number;
+  readonly recoveredset_fec_set_index: (a: number) => number;
+  readonly recoveredset_payload: (a: number) => [number, number];
+  readonly recoveredset_slot: (a: number) => bigint;
+  readonly shredfecbuffer_add_shred: (a: number, b: bigint, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+  readonly shredfecbuffer_new: (a: bigint, b: number) => number;
+  readonly shredfecbuffer_pending_fec_sets: (a: number) => number;
+  readonly shredfecbuffer_try_recover_all: (a: number, b: number) => [number, number];
+  readonly shredfecbuffer_try_recover_all_with_identity: (a: number, b: number) => number;
+  readonly shredreassembler_add_shred: (a: number, b: bigint, c: number, d: number, e: number, f: number, g: number) => [number, number];
+  readonly shredreassembler_new: (a: bigint, b: number) => number;
+  readonly source_auth_blake3: (a: number, b: number) => [number, number];
+  readonly ssbg1_source_symbol: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly video_sample_entry_from_codec_string: (a: number, b: number) => [number, number, number, number];
+  readonly moqencodedblock_p: (a: number) => number;
+  readonly moqfecstatsjs_blocksComplete: (a: number) => number;
+  readonly moqfecstatsjs_blocksIncomplete: (a: number) => number;
+  readonly moqfecstatsjs_totalSymbolsReceived: (a: number) => number;
+  readonly shredreassembler_pending_fec_sets: (a: number) => number;
+  readonly __wbg_get_reassemblerstatsjs_duplicate_fragments: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_evicted_data_units: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_evicted_memory_limit: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_out_of_order_fragments: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_reassembled_mfus: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_timed_out_mfus: (a: number) => bigint;
+  readonly __wbg_get_reassemblerstatsjs_total_fragments: (a: number) => bigint;
+  readonly __wbg_get_samplecombinerstatsjs_combined_samples: (a: number) => bigint;
+  readonly __wbg_get_samplecombinerstatsjs_evicted_samples: (a: number) => bigint;
+  readonly __wbg_get_samplecombinerstatsjs_passthrough_samples: (a: number) => bigint;
+  readonly __wbg_get_samplecombinerstatsjs_timed_out_samples: (a: number) => bigint;
+  readonly __wbg_set_reassemblerstatsjs_duplicate_fragments: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_evicted_data_units: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_evicted_memory_limit: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_out_of_order_fragments: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_reassembled_mfus: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_timed_out_mfus: (a: number, b: bigint) => void;
+  readonly __wbg_set_reassemblerstatsjs_total_fragments: (a: number, b: bigint) => void;
+  readonly __wbg_set_samplecombinerstatsjs_combined_samples: (a: number, b: bigint) => void;
+  readonly __wbg_set_samplecombinerstatsjs_evicted_samples: (a: number, b: bigint) => void;
+  readonly __wbg_set_samplecombinerstatsjs_passthrough_samples: (a: number, b: bigint) => void;
+  readonly __wbg_set_samplecombinerstatsjs_timed_out_samples: (a: number, b: bigint) => void;
+  readonly init: () => void;
+  readonly raptorq_create_oti: (a: bigint, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly raptorq_decoder_add_packet: (a: number, b: number, c: number) => number;
+  readonly raptorq_decoder_free: (a: number) => void;
+  readonly raptorq_decoder_get_data: (a: number, b: number, c: number, d: number) => number;
+  readonly raptorq_decoder_is_complete: (a: number) => number;
+  readonly raptorq_decoder_new: (a: number) => number;
+  readonly raptorq_decoder_new_with_params: (a: bigint, b: number, c: number, d: number, e: number) => number;
+  readonly raptorq_decoder_packet_size: (a: number) => number;
+  readonly raptorq_decoder_symbol_size: (a: number) => number;
+  readonly raptorq_decoder_transfer_length: (a: number) => bigint;
+  readonly raptorq_encoder_free: (a: number) => void;
+  readonly raptorq_encoder_get_oti: (a: number, b: number) => number;
+  readonly raptorq_encoder_get_repair_packets: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly raptorq_encoder_get_source_packets: (a: number, b: number, c: number) => number;
+  readonly raptorq_encoder_new: (a: number, b: number, c: number, d: number) => number;
+  readonly raptorq_encoder_source_symbol_count: (a: number) => number;
+  readonly raptorq_free: (a: number, b: number) => void;
+  readonly raptorq_interleaved_decoder_add_packet: (a: number, b: number, c: number, d: number) => number;
+  readonly raptorq_interleaved_decoder_free: (a: number) => void;
+  readonly raptorq_interleaved_decoder_get_block_data: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly raptorq_interleaved_decoder_is_block_complete: (a: number, b: number) => number;
+  readonly raptorq_interleaved_decoder_new: (a: number, b: number) => number;
+  readonly raptorq_interleaved_decoder_reset_block: (a: number, b: number) => number;
+  readonly raptorq_interleaved_encoder_add_packet: (a: number, b: number, c: number, d: number) => number;
+  readonly raptorq_interleaved_encoder_add_packet_ex: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly raptorq_interleaved_encoder_force_complete: (a: number, b: number, c: number) => number;
+  readonly raptorq_interleaved_encoder_free: (a: number) => void;
+  readonly raptorq_interleaved_encoder_generate_repair: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly raptorq_interleaved_encoder_get_block_status: (a: number, b: number, c: number) => number;
+  readonly raptorq_interleaved_encoder_get_oti: (a: number, b: number) => number;
+  readonly raptorq_interleaved_encoder_new: (a: number, b: number, c: number, d: number) => number;
+  readonly raptorq_oti_symbol_size: (a: number) => number;
+  readonly raptorq_oti_transfer_length: (a: number) => bigint;
+  readonly raptorq_encoder_symbol_size: (a: number) => number;
+  readonly raptorq_encoder_transfer_length: (a: number) => bigint;
+  readonly raptorq_encoder_packet_size: (a: number) => number;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;