@blockcast/mmt-fec 0.3.0 → 0.4.0

package/src/repair-group.ts

@@ -193,3 +193,179 @@ export function repairGroupIdMatches(groupId: bigint, ssStart: number, reference
 		return false;
 	}
 }
+
+/**
+ * What a repair FETCH for one block names, or why none is sent: an
+ * `iso-ssbg1-v1` block's repair group is the one Group `ext(SS_Start)`
+ * (draft-ramadan-moq-fec §7.5).
+ *
+ * - `no-epoch`: no reference is established for the repair track on this
+ *   session, so there is no range to request until one is (§7.5).
+ * - `epoch-unbounded`: SS_Start is exactly 2^31 from the reference, or
+ *   extends outside [0, 2^62). The reference is dropped so the next one
+ *   re-establishes it.
+ * - `stale-session`: the request names a session other than the bound one.
+ */
+export type RepairGroupPlan =
+	| { readonly group: bigint }
+	| { readonly reason: "no-epoch" | "epoch-unbounded" | "stale-session" };
+
+/** Outcome of reporting a repair track's Largest Location (§7.5 way 2). */
+export type RepairLargestOutcome = "established" | "advanced" | "redundant" | "absent" | "stale-session";
+
+/**
+ * Counted outcomes of {@link RepairEpochReferences}. A successful
+ * {@link RepairEpochReferences.repairGroup} and a same-session `bind` are not
+ * counted.
+ */
+export interface RepairEpochStats {
+	establishedFromLargest: number;
+	advancedFromLargest: number;
+	largestAbsent: number;
+	largestRedundant: number;
+	establishedFromGroupId: number;
+	admitted: number;
+	discarded: number;
+	declinedNoEpoch: number;
+	epochUnbounded: number;
+	staleSession: number;
+	sessionResets: number;
+	streamResets: number;
+}
+
+/**
+ * The wrap-epoch reference `r` of each repair track, for one MoQ session
+ * (draft-ramadan-moq-fec §7.5). Shared by every native receiver adapter; the
+ * adapter owns its MoQ verbs and passes its session as an opaque object.
+ *
+ * - The adapter calls {@link bind} with the session it holds live, at the
+ *   synchronous point it reads it. A different session drops every reference:
+ *   the SS_IDs between a reconnection and the last reference cannot be bounded
+ *   below 2^31. {@link clear} does the same for a stream or track reset.
+ * - Every other call names the session it acts for, and one naming a session
+ *   other than the bound one changes nothing (`stale-session`). An async
+ *   continuation that outlived its session therefore cannot install that
+ *   session's reference, nor wipe the live session's.
+ * - `r` is established from a non-discarded repair object's Group ID (way 1,
+ *   {@link admit}) or a Largest Location (way 2), and only ever advances to a
+ *   newer Group, so it stays near the live edge for the life of the session.
+ *   Epoch 0 (way 3) needs proof of observing the instance's first block, which
+ *   nothing on the wire carries (SS_IDs start anywhere, C.5.2); it is not used.
+ */
+export class RepairEpochReferences {
+	readonly stats: RepairEpochStats = {
+		establishedFromLargest: 0,
+		advancedFromLargest: 0,
+		largestAbsent: 0,
+		largestRedundant: 0,
+		establishedFromGroupId: 0,
+		admitted: 0,
+		discarded: 0,
+		declinedNoEpoch: 0,
+		epochUnbounded: 0,
+		staleSession: 0,
+		sessionResets: 0,
+		streamResets: 0,
+	};
+	#session: object | undefined;
+	readonly #references = new Map<string, bigint>();
+
+	/** Make `session` the live one; a different session drops every reference. */
+	bind(session: object): void {
+		if (this.#session === session) return;
+		if (this.#session !== undefined) {
+			this.#references.clear();
+			this.stats.sessionResets++;
+		}
+		this.#session = session;
+	}
+
+	/** Drop every reference: the stream or track was reset. */
+	clear(): void {
+		this.#references.clear();
+		this.stats.streamResets++;
+	}
+
+	/** `r` of `repairTrack` on `session`; undefined when none, or the session is not the bound one. */
+	reference(session: object, repairTrack: string): bigint | undefined {
+		return session === this.#session ? this.#references.get(repairTrack) : undefined;
+	}
+
+	#live(session: object): boolean {
+		if (session === this.#session) return true;
+		this.stats.staleSession++;
+		return false;
+	}
+
+	/**
+	 * §7.5 way 2: the Largest Location reported for `repairTrack`, whose Group
+	 * is ext(SS_Start) of the newest repair block. Undefined means an empty
+	 * track and establishes nothing.
+	 *
+	 * @throws RangeError when the Group is not a 62-bit MoQ group id
+	 */
+	establishFromLargestLocation(
+		session: object,
+		repairTrack: string,
+		largestGroup: bigint | undefined,
+	): RepairLargestOutcome {
+		if (largestGroup !== undefined) assertGroupId(largestGroup, "Largest Location Group");
+		if (!this.#live(session)) return "stale-session";
+		if (largestGroup === undefined) {
+			this.stats.largestAbsent++;
+			return "absent";
+		}
+		const held = this.#references.get(repairTrack);
+		if (held !== undefined && largestGroup <= held) {
+			this.stats.largestRedundant++;
+			return "redundant";
+		}
+		this.#references.set(repairTrack, largestGroup);
+		if (held === undefined) {
+			this.stats.establishedFromLargest++;
+			return "established";
+		}
+		this.stats.advancedFromLargest++;
+		return "advanced";
+	}
+
+	/**
+	 * Screen one repair object received over MoQ (§7.5): false means discard
+	 * it, leaving every block's state unchanged. An admitted object's Group ID
+	 * establishes `r` when none is held (way 1) and advances it when newer.
+	 */
+	admit(session: object, repairTrack: string, groupId: bigint, ssStart: number): boolean {
+		if (!this.#live(session)) return false;
+		const held = this.#references.get(repairTrack);
+		if (!repairGroupIdMatches(groupId, ssStart, held)) {
+			this.stats.discarded++;
+			return false;
+		}
+		this.stats.admitted++;
+		if (held === undefined) this.stats.establishedFromGroupId++;
+		if (held === undefined || groupId > held) this.#references.set(repairTrack, groupId);
+		return true;
+	}
+
+	/**
+	 * The repair group of the `iso-ssbg1-v1` block starting at `ssStart`, the
+	 * scheduler's `RepairFetchRequest.sbn`: the one Group ext(SS_Start).
+	 */
+	repairGroup(session: object, repairTrack: string, ssStart: number): RepairGroupPlan {
+		assertSsId(ssStart, "ssStart");
+		if (!this.#live(session)) return { reason: "stale-session" };
+		const reference = this.#references.get(repairTrack);
+		if (reference === undefined) {
+			this.stats.declinedNoEpoch++;
+			return { reason: "no-epoch" };
+		}
+		try {
+			return { group: extendSsId(reference, ssStart) };
+		} catch (error) {
+			if (!(error instanceof RangeError)) throw error;
+			this.#references.delete(repairTrack);
+			this.stats.epochUnbounded++;
+			return { reason: "epoch-unbounded" };
+		}
+	}
+}

package/test-vectors/repair-epoch.json

@@ -0,0 +1,119 @@
+{
+  "$comment": [
+    "Canonical receiver vectors for iso-ssbg1-v1 repair epochs and repair",
+    "FETCH ranges (draft-ramadan-moq-fec §7.5, BLO-45476). libmmt runs them",
+    "against RepairEpochReferences and repairFetchRange; every native receiver",
+    "adapter (moqtail, hang) runs the same file against its own wiring.",
+    "Hand-authored from the draft, never regenerated from the implementation.",
+    "",
+    "Group ids are decimal strings (62-bit, beyond Number). Sessions are names;",
+    "a runner maps each name to one distinct object. W = 2^32.",
+    "epochCases ops: bind | clear | largest (group null = no Largest Location;",
+    "expect 'throws' = RangeError) | admit | repairGroup | reference (null = none)."
+  ],
+  "epochCases": [
+    {
+      "name": "no reference, then Largest Location extends forward across the wrap and backward",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 16, "expect": { "reason": "no-epoch" } },
+        { "op": "largest", "session": "A", "track": "r", "group": "17179869168", "expect": "established" },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 16, "expect": { "group": "17179869200" } },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 4294967280, "expect": { "group": "17179869168" } },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 4294967264, "expect": { "group": "17179869152" } }
+      ]
+    },
+    {
+      "name": "an SS_Start exactly 2^31 from r cannot be ordered and drops r",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "largest", "session": "A", "track": "r", "group": "17179869168", "expect": "established" },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 2147483632, "expect": { "reason": "epoch-unbounded" } },
+        { "op": "reference", "session": "A", "track": "r", "expect": null },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 16, "expect": { "reason": "no-epoch" } }
+      ]
+    },
+    {
+      "name": "an extension below group 0 is unbounded",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "largest", "session": "A", "track": "r", "group": "5", "expect": "established" },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 4294967295, "expect": { "reason": "epoch-unbounded" } }
+      ]
+    },
+    {
+      "name": "admit: discard on SS_Start mismatch, establish, refuse a wrong epoch, advance, never regress",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "admit", "session": "A", "track": "r", "groupId": "21474836580", "ssStart": 101, "expect": false },
+        { "op": "reference", "session": "A", "track": "r", "expect": null },
+        { "op": "admit", "session": "A", "track": "r", "groupId": "21474836580", "ssStart": 100, "expect": true },
+        { "op": "reference", "session": "A", "track": "r", "expect": "21474836580" },
+        { "op": "admit", "session": "A", "track": "r", "groupId": "17179869284", "ssStart": 100, "expect": false },
+        { "op": "admit", "session": "A", "track": "r", "groupId": "21474836530", "ssStart": 50, "expect": true },
+        { "op": "reference", "session": "A", "track": "r", "expect": "21474836580" },
+        { "op": "admit", "session": "A", "track": "r", "groupId": "21474836680", "ssStart": 200, "expect": true },
+        { "op": "reference", "session": "A", "track": "r", "expect": "21474836680" },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 150, "expect": { "group": "21474836630" } }
+      ]
+    },
+    {
+      "name": "Largest Location: absent, redundant, advanced, not a 62-bit group id",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "largest", "session": "A", "track": "r", "group": null, "expect": "absent" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967396", "expect": "established" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967306", "expect": "redundant" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967396", "expect": "redundant" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967496", "expect": "advanced" },
+        { "op": "reference", "session": "A", "track": "r", "expect": "4294967496" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4611686018427387904", "expect": "throws" },
+        { "op": "reference", "session": "A", "track": "r", "expect": "4294967496" }
+      ]
+    },
+    {
+      "name": "stale generation: a new session drops r, and the old session can neither install nor wipe",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967396", "expect": "established" },
+        { "op": "bind", "session": "B" },
+        { "op": "reference", "session": "B", "track": "r", "expect": null },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967396", "expect": "stale-session" },
+        { "op": "admit", "session": "A", "track": "r", "groupId": "4294967396", "ssStart": 100, "expect": false },
+        { "op": "repairGroup", "session": "A", "track": "r", "ssStart": 100, "expect": { "reason": "stale-session" } },
+        { "op": "repairGroup", "session": "B", "track": "r", "ssStart": 100, "expect": { "reason": "no-epoch" } },
+        { "op": "largest", "session": "B", "track": "r", "group": "8589934692", "expect": "established" },
+        { "op": "largest", "session": "A", "track": "r", "group": "4294967396", "expect": "stale-session" },
+        { "op": "repairGroup", "session": "B", "track": "r", "ssStart": 100, "expect": { "group": "8589934692" } }
+      ]
+    },
+    {
+      "name": "nothing bound yet is stale; rebinding the same session keeps r",
+      "ops": [
+        { "op": "largest", "session": "A", "track": "r", "group": "100", "expect": "stale-session" },
+        { "op": "bind", "session": "A" },
+        { "op": "largest", "session": "A", "track": "r", "group": "100", "expect": "established" },
+        { "op": "bind", "session": "A" },
+        { "op": "reference", "session": "A", "track": "r", "expect": "100" }
+      ]
+    },
+    {
+      "name": "a stream reset drops every track's r; tracks are independent",
+      "ops": [
+        { "op": "bind", "session": "A" },
+        { "op": "largest", "session": "A", "track": "video/repair", "group": "100", "expect": "established" },
+        { "op": "repairGroup", "session": "A", "track": "audio/repair", "ssStart": 100, "expect": { "reason": "no-epoch" } },
+        { "op": "clear" },
+        { "op": "repairGroup", "session": "A", "track": "video/repair", "ssStart": 100, "expect": { "reason": "no-epoch" } }
+      ]
+    }
+  ],
+  "rangeCases": [
+    { "name": "from r, across the wrap", "lostSsId": 16, "kMax": 8, "anchor": { "reference": "17179869168" }, "expect": { "startGroup": "17179869193", "endGroup": "17179869200" } },
+    { "name": "floored above the previous block", "lostSsId": 16, "kMax": 8, "anchor": { "previousBlockStart": "17179869194" }, "expect": { "startGroup": "17179869195", "endGroup": "17179869200" } },
+    { "name": "K = 1 names one group", "lostSsId": 16, "kMax": 1, "anchor": { "reference": "17179869168" }, "expect": { "startGroup": "17179869200", "endGroup": "17179869200" } },
+    { "name": "floored at group 0", "lostSsId": 2, "kMax": 8, "anchor": { "reference": "5" }, "expect": { "startGroup": "0", "endGroup": "2" } },
+    { "name": "lost SS_ID at the previous block's start", "lostSsId": 10, "kMax": 8, "anchor": { "previousBlockStart": "17179869194" }, "expect": "throws" },
+    { "name": "K = 0", "lostSsId": 16, "kMax": 0, "anchor": { "reference": "17179869168" }, "expect": "throws" }
+  ]
+}

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

@@ -1,181 +0,0 @@
-# @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-alta-parse/dist/index.d.ts

@@ -1,57 +0,0 @@
-/**
- * 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-alta-parse/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"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"}