@blockcast/mmt-container 0.1.0 → 0.3.0-main.0bde85f7082f

package/node_modules/@blockcast/mmt-fec/dist/reorder-buffer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ReorderBuffer — container-agnostic frame reorder buffer for FEC-interleaved streams.
+ *
+ * FEC interleaving causes frames to complete out of decode order (e.g., frame N+3
+ * before N+1). H.264 P-frames reference the previous frame, so feeding out-of-order
+ * frames to VideoDecoder produces green artifacts from reference frame mismatch.
+ *
+ * This buffer accumulates frames and flushes them in sequence order.
+ * - In-order frames flush immediately (zero added latency for well-ordered streams).
+ * - Out-of-order frames buffer until the gap is filled or the buffer is full.
+ * - Keyframes flush all pending frames first (random access point).
+ * - Safety timeout force-flushes stalled buffers (missing frame that will never arrive).
+ *
+ * Used by WebCodecs decode path. NOT needed for MSE (browser handles ordering internally).
+ */
+export interface ReorderBufferConfig<T> {
+    /** Maximum frames to buffer before force-flushing oldest. */
+    maxSize: number;
+    /** Extract sequence number from a frame. */
+    getSequence: (frame: T) => number;
+    /** Check if a frame is a keyframe (flushes all pending). Optional. */
+    isKeyframe?: (frame: T) => boolean;
+}
+export declare class ReorderBuffer<T> {
+    #private;
+    constructor(config: ReorderBufferConfig<T>);
+    /**
+     * Push a frame into the buffer. Returns frames ready to decode (in sequence order).
+     * May return 0 frames (buffered), 1 frame (in-order), or multiple (gap filled / flush).
+     */
+    push(frame: T): T[];
+    /**
+     * Flush all pending frames in sequence order. Call on keyframe or cleanup.
+     */
+    flushAll(): T[];
+    /** Number of frames currently buffered (waiting for gap to fill). */
+    get pending(): number;
+    /** Reset buffer state. */
+    reset(): void;
+}
+//# sourceMappingURL=reorder-buffer.d.ts.map

package/node_modules/@blockcast/mmt-fec/dist/reorder-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reorder-buffer.d.ts","sourceRoot":"","sources":["../src/reorder-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACrC,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IAClC,sEAAsE;IACtE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;CACnC;AAED,qBAAa,aAAa,CAAC,CAAC;;gBAKf,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAI1C;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IAwCnB;;OAEG;IACH,QAAQ,IAAI,CAAC,EAAE;IASf,qEAAqE;IACrE,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,0BAA0B;IAC1B,KAAK,IAAI,IAAI;CAIb"}

package/node_modules/@blockcast/mmt-fec/dist/reorder-buffer.js

@@ -0,0 +1,81 @@
+/**
+ * ReorderBuffer — container-agnostic frame reorder buffer for FEC-interleaved streams.
+ *
+ * FEC interleaving causes frames to complete out of decode order (e.g., frame N+3
+ * before N+1). H.264 P-frames reference the previous frame, so feeding out-of-order
+ * frames to VideoDecoder produces green artifacts from reference frame mismatch.
+ *
+ * This buffer accumulates frames and flushes them in sequence order.
+ * - In-order frames flush immediately (zero added latency for well-ordered streams).
+ * - Out-of-order frames buffer until the gap is filled or the buffer is full.
+ * - Keyframes flush all pending frames first (random access point).
+ * - Safety timeout force-flushes stalled buffers (missing frame that will never arrive).
+ *
+ * Used by WebCodecs decode path. NOT needed for MSE (browser handles ordering internally).
+ */
+export class ReorderBuffer {
+    #config;
+    #buffer = [];
+    #lastFlushedSeq = -1;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Push a frame into the buffer. Returns frames ready to decode (in sequence order).
+     * May return 0 frames (buffered), 1 frame (in-order), or multiple (gap filled / flush).
+     */
+    push(frame) {
+        const { getSequence, isKeyframe, maxSize } = this.#config;
+        // Keyframe: flush all pending in order, then emit keyframe
+        if (isKeyframe?.(frame)) {
+            const flushed = this.flushAll();
+            this.#lastFlushedSeq = getSequence(frame);
+            flushed.push(frame);
+            return flushed;
+        }
+        const seq = getSequence(frame);
+        // Drop truly stale frames (older than what we've already flushed)
+        if (seq > 0 && seq <= this.#lastFlushedSeq) {
+            return [];
+        }
+        // Insert into buffer (maintain sorted order)
+        this.#buffer.push(frame);
+        this.#buffer.sort((a, b) => getSequence(a) - getSequence(b));
+        // Flush in-order frames from front
+        const flushed = [];
+        while (this.#buffer.length > 0) {
+            const frontSeq = getSequence(this.#buffer[0]);
+            // Flush if: next expected seq, OR nothing flushed yet (bootstrap), OR buffer full
+            if (frontSeq <= this.#lastFlushedSeq + 1 || this.#lastFlushedSeq < 0 || this.#buffer.length >= maxSize) {
+                const f = this.#buffer.shift();
+                this.#lastFlushedSeq = getSequence(f);
+                flushed.push(f);
+            }
+            else {
+                break; // gap — wait for missing frame
+            }
+        }
+        return flushed;
+    }
+    /**
+     * Flush all pending frames in sequence order. Call on keyframe or cleanup.
+     */
+    flushAll() {
+        this.#buffer.sort((a, b) => this.#config.getSequence(a) - this.#config.getSequence(b));
+        const flushed = this.#buffer.splice(0);
+        if (flushed.length > 0) {
+            this.#lastFlushedSeq = this.#config.getSequence(flushed[flushed.length - 1]);
+        }
+        return flushed;
+    }
+    /** Number of frames currently buffered (waiting for gap to fill). */
+    get pending() {
+        return this.#buffer.length;
+    }
+    /** Reset buffer state. */
+    reset() {
+        this.#buffer = [];
+        this.#lastFlushedSeq = -1;
+    }
+}
+//# sourceMappingURL=reorder-buffer.js.map

package/node_modules/@blockcast/mmt-fec/dist/reorder-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reorder-buffer.js","sourceRoot":"","sources":["../src/reorder-buffer.ts"],"names":[],"mappings":"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"}

package/node_modules/@blockcast/mmt-fec/dist/repair-group.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The MoQ repair group id of an `iso-ssbg1-v1` block: `(wrapEpoch << 32) | ssStart`.
+ *
+ * @param wrapEpoch - How many times SS_ID has wrapped before this block, in `[0, 2^30)`
+ * @param ssStart - The block's SS_Start (uint32) from its Repair FEC Payload ID
+ * @returns The 62-bit repair group id
+ * @throws RangeError unless `ssStart` is a uint32 and `wrapEpoch` a bigint in `[0, 2^30)`
+ */
+export declare function extSsStart(wrapEpoch: bigint, ssStart: number): bigint;
+/**
+ * Extend a 32-bit SS_ID to the 62-bit value congruent to it mod 2^32 that is
+ * nearest `reference` in RFC 1982 serial order: forward when `ssId` follows
+ * the reference's low 32 bits serially, backward when it precedes them, and
+ * `reference` itself when they are equal.
+ *
+ * @param reference - A 62-bit extended SS_ID or repair group id the receiver already holds
+ * @param ssId - The 32-bit SS_ID (or SS_Start) to extend
+ * @returns The extended 62-bit value
+ * @throws RangeError when `ssId` lies exactly 2^31 from the reference's low
+ *   32 bits (RFC 1982 leaves that pair unordered, so no direction exists), or
+ *   when the extension falls outside `[0, 2^62)`
+ */
+export declare function extendSsId(reference: bigint, ssId: number): bigint;
+/** An absolute, inclusive MoQ group range for a repair FETCH. */
+export interface RepairFetchRange {
+    /** First group of the FETCH. */
+    readonly startGroup: bigint;
+    /** Last group of the FETCH: the extended lost SS_ID. */
+    readonly endGroup: bigint;
+}
+/** What a lost SS_ID is extended from (draft-ramadan-moq-fec §7.5). */
+export type RepairFetchAnchor = 
+/** ext(S_prev): the extended SS_Start of the last block the receiver
+ *  delimited that ends before the lost SS_ID. The caller vouches for that
+ *  ordering; only a lost SS_ID at or before the block's start is
+ *  detectable here, since the block's length is not an input. */
+{
+    readonly previousBlockStart: bigint;
+}
+/** The reference value r of the receiver's wrap epoch, when it has
+ *  delimited no block that ends before the lost SS_ID. */
+ | {
+    readonly reference: bigint;
+};
+/**
+ * The repair FETCH for a lost SS_ID x whose block the receiver has not
+ * delimited (draft-ramadan-moq-fec §7.5): the absolute, inclusive group range
+ *
+ *   [max(ext(S_prev) + 1, ext(x) - (K - 1)), ext(x)]
+ *
+ * or, with no S_prev, `[max(ext(x) - (K - 1), 0), ext(x)]`, where ext(x) is x
+ * extended relative to ext(S_prev), or else to the epoch reference r. Repair
+ * group ids sit at block starts and no block holds more than K source symbols,
+ * so the block containing x starts at most K - 1 SS_IDs before x and is the
+ * last group the range returns. The range is never empty.
+ *
+ * @param lostSsId - The lost 32-bit SS_ID x
+ * @param kMax - K: the instance's catalog `sourceSymbols`, the largest
+ *   SSB_length a block can have
+ * @param anchor - ext(S_prev), or the epoch reference r without one
+ * @throws RangeError when `kMax` is not a positive safe integer, when x does
+ *   not extend past `previousBlockStart`, or whenever {@link extendSsId} throws
+ */
+export declare function repairFetchRange(lostSsId: number, kMax: number, anchor: RepairFetchAnchor): RepairFetchRange;
+/**
+ * Whether a repair object received over MoQ may be used: its Group ID must
+ * agree with the SS_Start of its Repair FEC Payload ID, which is authoritative
+ * (draft-ramadan-moq-fec §7.5). The Group ID must equal SS_Start modulo 2^32
+ * and, once the receiver holds an epoch reference, equal ext(SS_Start)
+ * extended relative to it. A receiver discards a repair object for which this
+ * is false, leaving every block's state unchanged, and never takes its Group
+ * ID as an epoch reference. An SS_Start that cannot be extended (exactly 2^31
+ * from the reference) cannot be checked, so it does not match either.
+ *
+ * @param groupId - The repair object's MoQ Group ID
+ * @param ssStart - The SS_Start of its Repair FEC Payload ID
+ * @param reference - The receiver's epoch reference r, once it holds one
+ * @throws RangeError unless `ssStart` is a uint32 or `reference` (when given)
+ *   a 62-bit group id
+ */
+export declare function repairGroupIdMatches(groupId: bigint, ssStart: number, reference?: bigint): boolean;
+//# sourceMappingURL=repair-group.d.ts.map

package/node_modules/@blockcast/mmt-fec/dist/repair-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-group.d.ts","sourceRoot":"","sources":["../src/repair-group.ts"],"names":[],"mappings":"AAwDA;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAMrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAmBlE;AAED,iEAAiE;AACjE,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAED,uEAAuE;AACvE,MAAM,MAAM,iBAAiB;AAC5B;;;iEAGiE;AAC/D;IAAE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;CAAE;AACzC;0DAC0D;GACxD;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,gBAAgB,CAqB5G;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAWlG"}

package/node_modules/@blockcast/mmt-fec/dist/repair-group.js

@@ -0,0 +1,170 @@
+/**
+ * MoQ repair group ids for `iso-ssbg1-v1` FEC blocks (BLO-35597, decision D2(a)).
+ *
+ * SS_ID and SS_Start are 32-bit wire fields that wrap at 2^32 (ISO/IEC
+ * 23008-1 C.5.2, C.5.3; RFC 1982 serial arithmetic). A MoQ group id is a
+ * 62-bit unsigned integer that must never go backwards, so the repair group
+ * of an `iso-ssbg1-v1` block is the wrap-epoch-extended SS_Start:
+ *
+ *   ext(SS_Start) = (wrap_epoch << 32) | SS_Start
+ *
+ * Repair group ids are therefore sparse (one per block, at the block's first
+ * SS_ID) and strictly increasing. A receiver that lost SS_ID x in a block it
+ * has not delimited FETCHes the absolute group range of draft-ramadan-moq-fec
+ * §7.5 (`repairFetchRange`); the last group that range returns is the block
+ * containing x.
+ *
+ * A receiver establishes its wrap-epoch reference from the Group ID of a
+ * repair object it received over MoQ, from the Largest Location a
+ * TRACK_STATUS for a repair track reports, or as epoch 0 when it observed the
+ * instance from its first block (draft-ramadan-moq-fec §7.5). The first two
+ * take the epoch from a Group ID itself (`groupId >> 32`): the publisher
+ * assigns repair Group IDs and MoQ delivers them unaltered, so a delivered
+ * Group ID is the epoch reference, on the same footing as the Largest
+ * Location, not a candidate for this module to verify. Nothing a receiver
+ * holds before its first reference can check an epoch: without one,
+ * `repairGroupIdMatches` checks only the low 32 bits, and its `true` means
+ * "this object can be this block's", never "this epoch is verified". It
+ * screens out an object to discard; it does not confirm an epoch. No other
+ * value is an epoch reference: not a group id computed from a 32-bit SS_ID,
+ * and not one carried in a payload rather than as an object's MoQ Group ID.
+ *
+ * All values are bigint: 62-bit group ids exceed Number's 2^53 exact range.
+ */
+import { SERIAL32_HALF, SERIAL32_SPAN, serial32Distance } from "@blockcast/mmt-base";
+/** Bits of a MoQ group id above the 32-bit SS_Start: 62 - 32. */
+const WRAP_EPOCH_BITS = 30n;
+/** 2^32 as a bigint: the SS_ID wrap and the shift of the wrap epoch. */
+const SS_ID_SPAN = BigInt(SERIAL32_SPAN);
+/** Exclusive bound of the wrap epoch: 2^30. */
+const WRAP_EPOCH_SPAN = 1n << WRAP_EPOCH_BITS;
+/** Exclusive bound of a MoQ group id: 2^62. */
+const MOQ_GROUP_ID_SPAN = WRAP_EPOCH_SPAN * SS_ID_SPAN;
+function assertSsId(value, name) {
+    if (!Number.isInteger(value) || value < 0 || value >= SERIAL32_SPAN) {
+        throw new RangeError(`${name} must be a uint32 SS_ID (got ${value})`);
+    }
+}
+function assertGroupId(value, name) {
+    if (typeof value !== "bigint" || value < 0n || value >= MOQ_GROUP_ID_SPAN) {
+        throw new RangeError(`${name} must be a 62-bit MoQ group id in [0, 2^62) (got ${String(value)})`);
+    }
+}
+/**
+ * The MoQ repair group id of an `iso-ssbg1-v1` block: `(wrapEpoch << 32) | ssStart`.
+ *
+ * @param wrapEpoch - How many times SS_ID has wrapped before this block, in `[0, 2^30)`
+ * @param ssStart - The block's SS_Start (uint32) from its Repair FEC Payload ID
+ * @returns The 62-bit repair group id
+ * @throws RangeError unless `ssStart` is a uint32 and `wrapEpoch` a bigint in `[0, 2^30)`
+ */
+export function extSsStart(wrapEpoch, ssStart) {
+    if (typeof wrapEpoch !== "bigint" || wrapEpoch < 0n || wrapEpoch >= WRAP_EPOCH_SPAN) {
+        throw new RangeError(`wrap epoch must be a bigint in [0, 2^30) (got ${String(wrapEpoch)})`);
+    }
+    assertSsId(ssStart, "ssStart");
+    return (wrapEpoch << 32n) | BigInt(ssStart);
+}
+/**
+ * Extend a 32-bit SS_ID to the 62-bit value congruent to it mod 2^32 that is
+ * nearest `reference` in RFC 1982 serial order: forward when `ssId` follows
+ * the reference's low 32 bits serially, backward when it precedes them, and
+ * `reference` itself when they are equal.
+ *
+ * @param reference - A 62-bit extended SS_ID or repair group id the receiver already holds
+ * @param ssId - The 32-bit SS_ID (or SS_Start) to extend
+ * @returns The extended 62-bit value
+ * @throws RangeError when `ssId` lies exactly 2^31 from the reference's low
+ *   32 bits (RFC 1982 leaves that pair unordered, so no direction exists), or
+ *   when the extension falls outside `[0, 2^62)`
+ */
+export function extendSsId(reference, ssId) {
+    assertGroupId(reference, "reference");
+    assertSsId(ssId, "ssId");
+    const low = Number(reference & (SS_ID_SPAN - 1n));
+    const forward = serial32Distance(low, ssId);
+    if (forward === SERIAL32_HALF) {
+        throw new RangeError(`SS_ID ${ssId} is exactly 2^31 from ${low}; RFC 1982 leaves the pair unordered`);
+    }
+    const extended = forward < SERIAL32_HALF
+        ? reference + BigInt(forward)
+        : reference - BigInt(SERIAL32_SPAN - forward);
+    if (extended < 0n || extended >= MOQ_GROUP_ID_SPAN) {
+        throw new RangeError(`SS_ID ${ssId} extends from ${String(reference)} to ${String(extended)}, outside [0, 2^62)`);
+    }
+    return extended;
+}
+/**
+ * The repair FETCH for a lost SS_ID x whose block the receiver has not
+ * delimited (draft-ramadan-moq-fec §7.5): the absolute, inclusive group range
+ *
+ *   [max(ext(S_prev) + 1, ext(x) - (K - 1)), ext(x)]
+ *
+ * or, with no S_prev, `[max(ext(x) - (K - 1), 0), ext(x)]`, where ext(x) is x
+ * extended relative to ext(S_prev), or else to the epoch reference r. Repair
+ * group ids sit at block starts and no block holds more than K source symbols,
+ * so the block containing x starts at most K - 1 SS_IDs before x and is the
+ * last group the range returns. The range is never empty.
+ *
+ * @param lostSsId - The lost 32-bit SS_ID x
+ * @param kMax - K: the instance's catalog `sourceSymbols`, the largest
+ *   SSB_length a block can have
+ * @param anchor - ext(S_prev), or the epoch reference r without one
+ * @throws RangeError when `kMax` is not a positive safe integer, when x does
+ *   not extend past `previousBlockStart`, or whenever {@link extendSsId} throws
+ */
+export function repairFetchRange(lostSsId, kMax, anchor) {
+    if (!Number.isSafeInteger(kMax) || kMax <= 0) {
+        throw new RangeError(`kMax must be a positive integer (got ${kMax})`);
+    }
+    let floor;
+    let endGroup;
+    if ("previousBlockStart" in anchor) {
+        assertGroupId(anchor.previousBlockStart, "previousBlockStart");
+        floor = anchor.previousBlockStart + 1n;
+        endGroup = extendSsId(anchor.previousBlockStart, lostSsId);
+        if (endGroup < floor) {
+            throw new RangeError(`lost SS_ID ${lostSsId} extends to ${String(endGroup)}, not after the previous block at ${String(anchor.previousBlockStart)}`);
+        }
+    }
+    else {
+        floor = 0n;
+        endGroup = extendSsId(anchor.reference, lostSsId);
+    }
+    const reach = endGroup - BigInt(kMax - 1);
+    return { startGroup: reach > floor ? reach : floor, endGroup };
+}
+/**
+ * Whether a repair object received over MoQ may be used: its Group ID must
+ * agree with the SS_Start of its Repair FEC Payload ID, which is authoritative
+ * (draft-ramadan-moq-fec §7.5). The Group ID must equal SS_Start modulo 2^32
+ * and, once the receiver holds an epoch reference, equal ext(SS_Start)
+ * extended relative to it. A receiver discards a repair object for which this
+ * is false, leaving every block's state unchanged, and never takes its Group
+ * ID as an epoch reference. An SS_Start that cannot be extended (exactly 2^31
+ * from the reference) cannot be checked, so it does not match either.
+ *
+ * @param groupId - The repair object's MoQ Group ID
+ * @param ssStart - The SS_Start of its Repair FEC Payload ID
+ * @param reference - The receiver's epoch reference r, once it holds one
+ * @throws RangeError unless `ssStart` is a uint32 or `reference` (when given)
+ *   a 62-bit group id
+ */
+export function repairGroupIdMatches(groupId, ssStart, reference) {
+    assertSsId(ssStart, "ssStart");
+    if (reference !== undefined)
+        assertGroupId(reference, "reference");
+    if (typeof groupId !== "bigint" || groupId < 0n || groupId >= MOQ_GROUP_ID_SPAN)
+        return false;
+    if ((groupId & (SS_ID_SPAN - 1n)) !== BigInt(ssStart))
+        return false;
+    if (reference === undefined)
+        return true;
+    try {
+        return extendSsId(reference, ssStart) === groupId;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=repair-group.js.map

package/node_modules/@blockcast/mmt-fec/dist/repair-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-group.js","sourceRoot":"","sources":["../src/repair-group.ts"],"names":[],"mappings":"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"}

package/node_modules/@blockcast/mmt-fec/node_modules/@blockcast/mmt-alta-parse/README.md

@@ -0,0 +1,181 @@
+# @blockcast/mmt-alta-parse
+
+Zero-dependency leaf package that extracts the detached **ALTA authenticator trailer** from an MMTP source packet. ALTA (Authenticated Lightweight TESLA-like Algorithm) is Blockcast's sender-authentication scheme for multicast streams: each MMTP source packet carries a detached signature trailer that downstream consumers (the FEC worker, the FFI core) verify against a catalog-published public key. This package is **the parser only** — it locates the trailer, returns the raw authenticator bytes, and tells the caller where the signed payload ends. Signature verification (Ed25519 / P-256) lives in the consumer that has crypto and the public key in hand.
+
+It is split into a leaf package with zero `@blockcast/*` dependencies so both `@blockcast/mmt-container` (wire-path parsing) and `@blockcast/fec-worker` (FEC-recovered-source parsing) can share one implementation without creating a package cycle.
+
+## Install
+
+```bash
+pnpm add @blockcast/mmt-alta-parse
+```
+
+## Quick start
+
+```ts
+import { extractAltaTrailer } from "@blockcast/mmt-alta-parse"
+
+// `wirePacket` is a full MMTP packet as it came off the network (Uint8Array).
+const trailer = extractAltaTrailer(wirePacket)
+
+if (trailer === null) {
+  // Packet has no ALTA trailer. This is normal for:
+  //  - non-MPU packets (repair, signaling)
+  //  - unsigned streams
+  //  - malformed / truncated packets
+  return
+}
+
+// `trailer.auth`        — the authenticator bytes (no ext_type/ext_length prefix)
+// `trailer.signedEnd`   — byte offset where the signed payload ends inside wirePacket.
+//                         The signer signed wirePacket.subarray(0, signedEnd).
+
+const signedPayload = wirePacket.subarray(0, trailer.signedEnd)
+// Hand off to a verifier with the catalog-published public key:
+//   ed25519.verify_detached(trailer.auth, signedPayload, publicKey)
+```
+
+For FEC-recovered source symbols (where the upstream FEC pipeline has already stripped the 4-byte Source FEC Payload ID), pass `{ skipFecId: true }`:
+
+```ts
+const trailer = extractAltaTrailer(recoveredSymbol, { skipFecId: true })
+```
+
+## Exports
+
+Per `package.json` (single entry point, ESM only):
+
+| Export | Kind | Purpose |
+|--------|------|---------|
+| `extractAltaTrailer(packet, options?)` | function | Parse a wire MMTP packet and return its `AltaTrailer` or `null`. |
+| `AltaTrailer` | type | `{ auth: Uint8Array; signedEnd: number }` |
+| `MMTP_EXT_TYPE_ALTA_AUTH` | const `0xf0a1` | The MMTP header-extension `ext_type` assigned to the detached ALTA trailer. |
+| `MMTP_EXT_TRAILER_HEADER_SIZE` | const `4` | Fixed size of the trailer's `[ext_type][ext_length]` prefix (2 + 2 bytes BE). |
+
+The package has no runtime dependencies — `package.json` lists `"dependencies": {}`.
+
+## ALTA wire format
+
+The detached ALTA authenticator is appended **after** the declared MPU payload bytes and **before** the optional 4-byte Source FEC Payload ID. ISO/IEC 23008-1 defines `payload_length` as a length-after-field value: it includes the six MPU-header bytes following the field, the MFU data-unit header when present, and the media bytes. The MMTP header-extension `X` bit stays `0` — non-ALTA receivers treat the trailing bytes as data past `payload_length` and discard them per ISO/IEC 23008-1 §9.2.2 ("may be discarded without impacting correct processing").
+
+Wire layout for a signed source packet:
+
+```
+| MMTP hdr | length (2) | remaining MPU hdr (6) | MFU hdr? | MFU data | TRAILER | SS_ID? (4) |
+             \_______________________________________________________/
+                    payload_length bytes start after the field
+                                                                    ^
+                                                                    |
+                                                               signedEnd
+```
+
+In MPU-payload coordinates, `signedEnd` is exactly `2 + payload_length`; the returned packet-relative offset also includes the complete, possibly extended MMTP header.
+
+The trailer itself is:
+
+```
+| ext_type (2 BE) | ext_length (2 BE) | auth (ext_length bytes) |
+       0xf0a1
+```
+
+- `ext_type = 0xf0a1` identifies the trailer as ALTA. Anything else is rejected (`null` return).
+- `ext_length` is the authenticator length in bytes — 64 for Ed25519, 64 for P-256 raw `(r,s)`, or whatever the signer minted.
+- The signed range is everything from byte 0 through `signedEnd-1` of the wire packet — i.e. the MMTP header, MPU header, MFU header, and MFU payload, but **not** the trailer itself or the optional FEC payload ID.
+
+This is the **detached trailer** form (a.k.a. "Path 2 / 08-07") from `draft-ramadan-moq-mmt` §12. It coexists with FEC: the signer signs the source-packet bytes **before** they enter the FEC encoder, so a receiver that recovers a missing source symbol from repair gets the same signed bytes the sender minted. This is the "sign-before-encode" rule — see the parent monorepo Phase 8 spec.
+
+### When `extractAltaTrailer` returns `null`
+
+The function returns `null` (rather than throwing) for every non-trailer outcome — see `src/index.ts:69-115`:
+
+| Condition | Why |
+|-----------|-----|
+| Packet shorter than `MMTP_HEADER_SIZE + MPU_HEADER_SIZE` (20 B) | Truncated/malformed |
+| Packet type ≠ MPU (`0x00`) | Repair and signaling packets aren't signed per-packet |
+| Fragment type ≠ 2 (MFU) | Only timed or non-timed MFU media packets carry trailers |
+| `payload_length` cannot contain the MPU-header remainder, structurally required DU header, and media | The declaration ends inside headers or describes a header-only MFU |
+| `2 + payload_length` exceeds the pre-FEC packet boundary | Truncated/malformed declaration |
+| No bytes between MFU data and SS_ID for the 4-byte trailer header | Unsigned stream |
+| `ext_type` ≠ `0xf0a1` | Some other header-extension lives in that slot |
+| Declared `ext_length` does not end exactly at the SS_ID boundary | Malformed or ambiguous trailer suffix |
+
+Callers should treat `null` as "no signature on this packet" and route based on stream policy (require-signed vs allow-unsigned).
+
+## Verification flow (where this package fits)
+
+```
+                    catalog (CMSF)
+                          │
+                  alta.publicKey (SPKI bytes)
+                          │
+                          ▼
+   ┌─────────────────────────────────────────────────────┐
+   │ @blockcast/mmt-container :: mmtp-router             │
+   │   wirePacket → extractAltaTrailer(packet) ──────────┼──► this package
+   │                ⇒ { auth, signedEnd }                │
+   │                                                     │
+   │   feedSourceSymbol(..., { auth, payloadEnd: signedEnd })
+   └────────────────────────┬────────────────────────────┘
+                            │
+                            ▼
+   ┌─────────────────────────────────────────────────────┐
+   │ @blockcast/fec-worker (configured with publicKey)│
+   │   ed25519.verify_detached(auth,                     │
+   │                           symbol[0..payloadEnd],    │
+   │                           publicKey)                │
+   │   → emits altaVerified per packet → FecTrackStats   │
+   └─────────────────────────────────────────────────────┘
+```
+
+Concretely, in `packages/container/src/mmtp-router.ts:798`, the router calls `extractAltaTrailer(packet)` for every signed source packet on the wire, packages the result as `{ auth, payloadEnd: signedEnd }`, and hands it to the FEC manager. The FEC worker (configured with `alta.publicKey` from the CMSF catalog at `configure()` time) does the actual Ed25519 / P-256 verification and increments per-track `altaVerified` / `altaFailed` counters in `FecTrackStats`. Those counters surface in CMCD as `x-bc-alta-verified` (see `packages/container/src/cmcd-producer.ts:93`).
+
+## Why not TESLA
+
+TESLA (RFC 4082) is the IETF reference for sender-authenticated multicast: it uses delayed-disclosure of MAC keys to amortize signing cost, but at the protocol level it carries 10–20% authentication overhead per stream (depending on key chain depth and disclosure interval). ALTA is Blockcast's lighter variant — same threat model (verify each packet was minted by the legitimate sender, not a rogue injector on the multicast group), measurably lower overhead (~6.91% in production multicast tests). The parent monorepo's `CLAUDE.md` calls this out at `packages/alta/`. ALTA replaces the v2 stub verifier in v3.0 / Phase 8.
+
+## Relation to DRM
+
+ALTA and DRM solve **different** problems and are orthogonal:
+
+| | ALTA | DRM (Widevine / PlayReady / FairPlay / ClearKey) |
+|---|---|---|
+| Authenticates | the **sender** | the **receiver** |
+| Question | "Did this packet come from the legitimate broadcaster?" | "Is this device authorized to play this content?" |
+| Wire layer | Per-MMTP-packet detached trailer | Sample-level CENC encryption + license server |
+| Catalog field | `alta.publicKey` | `contentProtection[]` (planned in v4 / M7) |
+
+A stream can use both — ALTA on the multicast wire (so receivers reject injected packets), CENC + DRM at the sample level (so unauthorized devices can't play). They don't interact.
+
+## Specifications
+
+- **ISO/IEC 23008-1:2023** §9.2.2 (MMTP packet header), §9.2.3 (MPU/MFU header) — the host packet structure
+- **draft-ramadan-moq-mmt** §12 — detached authenticator trailer ("Path 2 / 08-07") wire format
+- **RFC 8032** — Ed25519 signature algorithm (a typical inhabitant of the trailer)
+- **NIST FIPS 186-4** — ECDSA over P-256 (alternative inhabitant)
+- **RFC 4082** — TESLA (the heavier scheme ALTA replaces; included for context, not a dependency)
+- ATSC A/331 §A — referenced by libmmt for catalog-style key/signaling distribution patterns
+
+This package is agnostic to the signature algorithm — it only carries opaque bytes.
+
+## Related packages
+
+| Package | Role |
+|---------|------|
+| `@blockcast/mmt-container` | Consumes this parser via `mmtp-router.ts`; provides the CMSF catalog that distributes `alta.publicKey` to the FEC worker. |
+| `@blockcast/fec-worker` | Verifier — receives `{ auth, payloadEnd }` and the catalog public key at configure time, performs the actual Ed25519 / P-256 verification, increments `altaVerified` / `altaFailed` in `FecTrackStats`. |
+| `@blockcast/mmt-fec` | Surfaces verification counters to the application via FEC stats snapshots. |
+
+## Testing
+
+```bash
+pnpm test            # vitest run
+pnpm test:watch      # vitest in watch mode
+pnpm typecheck       # tsc --noEmit
+pnpm build           # tsc → dist/
+```
+
+Direct tests in `src/index.test.ts` cover canonical complete/fragmented declarations, ALTA-only and ALTA+FEC suffixes, malformed lengths, and rejection of obsolete boundary conventions. Coverage is also exercised through the re-exported parser in `@blockcast/mmt-container`.
+
+## License
+
+Apache-2.0 — see `LICENSE`.

package/node_modules/@blockcast/mmt-fec/node_modules/@blockcast/mmt-alta-parse/dist/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Zero-dependency helper for extracting the detached ALTA authenticator trailer
+ * from an MMTP source packet.
+ *
+ * Lives in its own leaf package so both `@blockcast/mmt-container` (wire-path
+ * parsing) and `@blockcast/fec-worker` (FEC-recovered-source parsing) can share
+ * one implementation without creating a package cycle between them.
+ *
+ * Spec: ISO/IEC 23008-1:2023 + draft-ramadan-moq-mmt §12 (detached trailer, Path 2).
+ */
+/**
+ * MMTP header-extension ext_type assigned to the detached ALTA authenticator
+ * trailer (Path 2 / 08-07). Carried in an `[ext_type][ext_length][auth]`
+ * block appended after the MPU's declared payload bytes, before the 4-byte
+ * Source FEC Payload ID. MMTP X-bit stays 0 — non-ALTA MMTP receivers treat
+ * the trailer as bytes past `payload_length` and skip it (per ISO 23008-1
+ * §9.2.2 "may be discarded without impacting correct processing").
+ */
+export declare const MMTP_EXT_TYPE_ALTA_AUTH = 61601;
+/** Fixed size of the trailer's `[ext_type][ext_length]` prefix (2 + 2 BE). */
+export declare const MMTP_EXT_TRAILER_HEADER_SIZE = 4;
+/** Result of extracting the detached ALTA authenticator from an MMTP packet. */
+export interface AltaTrailer {
+    /** Authenticator bytes (no ext_type/ext_length prefix, no trailing padding). */
+    auth: Uint8Array;
+    /**
+     * Wire-packet byte offset where the signed payload ends, i.e. where the
+     * trailer begins. Caller uses this to produce
+     * `payload = wirePacket.subarray(0, signedEnd)` for verify_detached.
+     */
+    signedEnd: number;
+}
+/**
+ * Extract the detached ALTA authenticator trailer from an MMTP source packet.
+ *
+ * Wire layout:
+ *   `[MMTP hdr][length(2)][remaining MPU hdr(6)][DU?][media][TRAILER][SS_ID?]`
+ *   `payload_length = 6 + DU bytes + media bytes`
+ *
+ * Returns `null` when:
+ * - the packet is too small / malformed,
+ * - `payload_length` cannot contain the remaining six MPU-header bytes,
+ * - the declared payload overruns the packet,
+ * - no bytes remain between `payload_length` and the SS_ID,
+ * - the trailer's `ext_type` isn't {@link MMTP_EXT_TYPE_ALTA_AUTH},
+ * - the declared `ext_length` would extend past the SS_ID boundary.
+ *
+ * Non-MPU packets (repair, signaling) always return `null`.
+ *
+ * @param options.skipFecId When true, do NOT reserve 4 trailing bytes for the
+ *   Source FEC Payload ID. Use on FEC-recovered symbols where the PID has
+ *   already been stripped upstream.
+ */
+export declare function extractAltaTrailer(mmtpPacket: Uint8Array, options?: {
+    skipFecId?: boolean;
+}): AltaTrailer | null;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@blockcast/mmt-fec/node_modules/@blockcast/mmt-alta-parse/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAiBH;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAA;AAE7C,8EAA8E;AAC9E,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,IAAI,EAAE,UAAU,CAAA;IAChB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,WAAW,GAAG,IAAI,CA4DpB"}