@blockcast/mmt-base 0.3.0 → 0.4.0-main.26d61a540c44

package/src/catalog-fec-source.ts

@@ -0,0 +1,164 @@
+/**
+ * Catalog FEC source rules shared by every catalog reader (BLO-40851).
+ *
+ * These are the dialect-level reads the container resolvers
+ * (`resolveRepairLayers`, `catalogFecUnavailable`), the transport endpoint
+ * selection (`selectEndpointPacketIds`) and a player's repair inventory all
+ * need to agree on. They live here, in the leaf package every one of those
+ * depends on, so there is one copy of each rule instead of copies pinned
+ * against each other by tests.
+ *
+ * - `locateCatalogFecSource`: which catalog entry declares a source's `fec`
+ *   block. hang `video`/`audio` rendition blocks are authoritative over an MSF
+ *   `tracks[]` entry of the same name.
+ * - `catalogFecAvailable`: draft-ramadan-moq-fec §5.1, whether a block's FEC
+ *   is usable at all (implemented `blockProfile`, usable span).
+ * - `catalogFecDeclaresUnconfigurableInstance`: a declared FEC instance whose
+ *   geometry a decoder cannot configure, which is a malformed catalog rather
+ *   than "no FEC".
+ *
+ * Every function is total: it never throws, whatever the input.
+ */
+import { isFecBlockProfile } from './fec-block-profile.js'
+
+/** The catalog media roles that carry hang renditions. */
+export type CatalogFecRole = 'video' | 'audio'
+
+/** One media source's `fec` block, as `locateCatalogFecSource` found it. */
+export type CatalogFecSource =
+  | {
+      readonly dialect: 'hang'
+      readonly role: CatalogFecRole
+      /** The rendition object. */
+      readonly entry: Record<string, unknown>
+      /** The rendition's `fec` value, unvalidated (may be undefined). */
+      readonly fec: unknown
+      /** JSON path of that `fec` block. */
+      readonly fecPath: string
+    }
+  | {
+      readonly dialect: 'msf'
+      /** Index of the entry in `tracks[]`. */
+      readonly index: number
+      /** The `tracks[]` entry (an empty object when the entry is not an object). */
+      readonly entry: Record<string, unknown>
+      /** The entry's `fec` value, unvalidated (may be undefined). */
+      readonly fec: unknown
+      /** JSON path of that `fec` block. */
+      readonly fecPath: string
+    }
+
+const ALL_ROLES: readonly CatalogFecRole[] = Object.freeze(['video', 'audio'])
+
+function recordOf(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined
+}
+
+/**
+ * Locate the catalog entry that declares one media source's `fec` block, in
+ * either catalog dialect.
+ *
+ * A hang `video`/`audio` rendition named `source` wins, in `roles` order, over
+ * a `tracks[]` entry of the same name: when a catalog carries rendition blocks
+ * beside a `tracks[]` switching-set index (the unified ABR ladder catalog),
+ * the rendition blocks are authoritative, exactly as they are for hang's own
+ * catalog decode. The precedence is keyed on the rendition EXISTING as an
+ * object, not on it carrying `fec`: a rendition without `fec` locates with
+ * `fec: undefined` and never falls through to `tracks[]`.
+ *
+ * Otherwise the first `tracks[]` entry named `source` locates. Returns
+ * undefined when neither dialect names it, or when `catalog` is not an object.
+ *
+ * @param roles the hang roles to search, in order (both by default). A typed
+ *   track reference passes its own role only.
+ */
+export function locateCatalogFecSource(
+  catalog: unknown,
+  source: string,
+  roles: readonly CatalogFecRole[] = ALL_ROLES,
+): CatalogFecSource | undefined {
+  const root = recordOf(catalog)
+  if (root === undefined) return undefined
+  for (const role of roles) {
+    const renditions = recordOf(recordOf(root[role])?.['renditions'])
+    if (renditions === undefined || !Object.hasOwn(renditions, source)) continue
+    const entry = recordOf(renditions[source])
+    if (entry === undefined) continue
+    return Object.freeze({
+      dialect: 'hang' as const,
+      role,
+      entry,
+      fec: entry['fec'],
+      fecPath: `$.${role}.renditions[${JSON.stringify(source)}].fec`,
+    })
+  }
+  const tracks = root['tracks']
+  if (!Array.isArray(tracks)) return undefined
+  const index = tracks.findIndex((track) => recordOf(track)?.['name'] === source)
+  if (index < 0) return undefined
+  const entry = recordOf(tracks[index]) ?? {}
+  return Object.freeze({
+    dialect: 'msf' as const,
+    index,
+    entry,
+    fec: entry['fec'],
+    fecPath: `$.tracks[${index}].fec`,
+  })
+}
+
+/**
+ * Whether an `iso-ssbg1-v1` block's optional `interleaveDepthMs` span is
+ * usable: absent, or a non-negative safe integer. Zero or absence supplies no
+ * elapsed deadline and still permits in-band FEC. True for every block that
+ * names another profile (the span is not read) and for a non-object.
+ */
+export function isoBlockSpanUsable(fec: unknown): boolean {
+  const block = recordOf(fec)
+  if (block === undefined || block['blockProfile'] !== 'iso-ssbg1-v1') return true
+  const ms = block['interleaveDepthMs']
+  return ms === undefined || (typeof ms === 'number' && Number.isSafeInteger(ms) && ms >= 0)
+}
+
+/**
+ * Whether one catalog `fec` block leaves its FEC available
+ * (draft-ramadan-moq-fec §5.1): the decision the container's
+ * `catalogFecUnavailable` explains with a typed reason.
+ *
+ * False when the block declares an FEC instance (any `algorithm` but `"none"`)
+ * and names no implemented `blockProfile` (the retired `k-padded-v1`
+ * included), or carries an `iso-ssbg1-v1` span it cannot use; and when a block
+ * declaring no FEC instance carries a profile token that is not implemented.
+ * True for a non-object and for every other block. It reads only the profile
+ * and the span: malformed geometry (`sourceSymbols`, `symbolSize`) is
+ * `catalogFecDeclaresUnconfigurableInstance`'s.
+ *
+ * A receiver applies no FEC to a source whose block is unavailable and joins
+ * none of its repair tracks, without failing the session.
+ */
+export function catalogFecAvailable(fec: unknown): boolean {
+  const block = recordOf(fec)
+  if (block === undefined) return true
+  const declaresFecInstance = block['algorithm'] !== 'none'
+  const profile = block['blockProfile']
+  const profileOk = isFecBlockProfile(profile) || (profile === undefined && !declaresFecInstance)
+  return profileOk && (!declaresFecInstance || isoBlockSpanUsable(block))
+}
+
+function isPositiveSafeInteger(value: unknown): boolean {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0
+}
+
+/**
+ * Whether a source's `fec` block declares an FEC instance (any `algorithm`
+ * but `"none"`) whose `sourceSymbols` or `symbolSize` is not a positive
+ * integer. Geometry a decoder cannot configure is a malformed catalog, not
+ * "no FEC": the container's per-track resolver throws `track_fec` for exactly
+ * this block, whatever its profile or span.
+ */
+export function catalogFecDeclaresUnconfigurableInstance(fec: unknown): boolean {
+  const block = recordOf(fec)
+  if (block === undefined || block['algorithm'] === 'none') return false
+  return !(isPositiveSafeInteger(block['sourceSymbols']) && isPositiveSafeInteger(block['symbolSize']))
+}

package/src/fec-block-profile.ts

@@ -1,16 +1,14 @@
 /**
  * FEC block profile (BLO-35597, ISO/IEC 23008-1 Annex C).
  *
- * Every catalog `fec` object that declares an FEC instance names exactly one
- * block profile in `fec.blockProfile`. A receiver applies all of a profile's
- * rules or none of them, so the token is the one explicit per-stream
- * discriminator: it is never defaulted and never inferred from the wire.
+ * Every catalog `fec` object that declares an FEC instance names its block
+ * profile in `fec.blockProfile`. A receiver applies all of a profile's rules
+ * or none of them, so the token is the one explicit per-stream discriminator:
+ * it is never defaulted and never inferred from the wire.
+ *
+ * draft-ramadan-moq-fec §5.1 defines exactly one value, and it is the only
+ * profile this library implements:
  *
- * - `k-padded-v1` (legacy, Blockcast-private): a source symbol is the
- *   protected MMTP packet zero-padded to T with no length field; every block
- *   is a K-symbol RaptorQ block whose ESIs `SSB_length..K-1` are implicit
- *   zero padding; `SS_ID = SBN*K + ESI`, so `SS_Start = SBN*K`; repair
- *   ESI = K + RS_ID; the MoQ repair group id is the SBN.
  * - `iso-ssbg1-v1`: ssbg_mode1 (C.3.3): a source symbol is
  *   `u16 length || protected packet || zero padding` to T; a block is a
  *   K' = SSB_length RaptorQ block (C.5.3) and repair ESI = SSB_length + RS_ID;
@@ -19,40 +17,42 @@
  *   under RFC 1982 serial arithmetic; the MoQ repair group id is the 62-bit
  *   wrap-epoch-extended SS_Start. The AL-FEC coding byte for this profile is
  *   0x14 (one-stage, ssbg_mode1, fec_payload_id_mode 0, Amd 1:2025 Table C.3).
+ *
+ * A track whose `blockProfile` is absent or names any other token (the
+ * retired Blockcast-private `k-padded-v1` included) has no FEC: a receiver
+ * consumes its source without FEC and joins none of its repair tracks
+ * (draft-ramadan-moq-fec §5.1). `parseFecBlockProfile` throws for such a
+ * token; the per-track catalog resolver turns the same rule into a typed
+ * per-track "FEC unavailable" outcome instead of failing the session.
  */
 import { serial32Add, serial32Distance, serial32Precedes } from './serial-number.js'
 
-/** The two block profiles a catalog `fec.blockProfile` may name. */
-export type FecBlockProfile = 'k-padded-v1' | 'iso-ssbg1-v1'
+/** The block profile a catalog `fec.blockProfile` may name: the one this library implements. */
+export type FecBlockProfile = 'iso-ssbg1-v1'
 
-/** Every accepted `fec.blockProfile` token, legacy first. */
+/** Every accepted `fec.blockProfile` token. */
 export const FEC_BLOCK_PROFILES: readonly FecBlockProfile[] = Object.freeze([
-  'k-padded-v1',
   'iso-ssbg1-v1',
 ])
 
-/** True for a known block-profile token. */
+/** True for a block-profile token this library implements. */
 export function isFecBlockProfile(value: unknown): value is FecBlockProfile {
-  return value === 'k-padded-v1' || value === 'iso-ssbg1-v1'
+  return value === 'iso-ssbg1-v1'
 }
 
 /**
- * Read a required `fec.blockProfile`. Throws on an absent or unknown token:
- * there is no default and nothing is inferred, because the two profiles carry
- * identical wire tuples whose repair math differs.
+ * Read a required `fec.blockProfile`. Throws on an absent token and on any
+ * token other than `iso-ssbg1-v1`: there is no default and nothing is
+ * inferred from the wire (draft-ramadan-moq-fec §5.1).
  *
  * @param where the catalog path of the field, for the error message.
  */
 export function parseFecBlockProfile(value: unknown, where: string): FecBlockProfile {
   if (isFecBlockProfile(value)) return value
   if (value === undefined) {
-    throw new Error(
-      `${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`,
-    )
+    throw new Error(`${where} is required: name the FEC block profile ("iso-ssbg1-v1")`)
   }
-  throw new Error(
-    `${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`,
-  )
+  throw new Error(`${where} must be "iso-ssbg1-v1" (got ${JSON.stringify(value)})`)
 }
 
 /** ISO/IEC 23008-1 C.3.3 ssbg_mode1: the two-octet packet length field. */

package/src/index.ts

@@ -4,3 +4,4 @@ export * from './ntp-short.js'
 export * from './signalling.js'
 export * from './serial-number.js'
 export * from './fec-block-profile.js'
+export * from './catalog-fec-source.js'

package/src/mmtp.ts

@@ -1,10 +1,3 @@
-import {
-  MMTP_EXT_TYPE_ALTA_AUTH as _LEAF_MMTP_EXT_TYPE_ALTA_AUTH,
-  MMTP_EXT_TRAILER_HEADER_SIZE as _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE,
-  extractAltaTrailer as _leafExtractAltaTrailer,
-  type AltaTrailer as _LeafAltaTrailer,
-} from '@blockcast/mmt-alta-parse'
-
 /**
  * @mmt/container - MMTP Parser
  *
@@ -353,9 +346,17 @@ function resolveMfuPayloadLayout(
   }
 }
 
-function isEmptyOrExactAltaTrailer(payload: Uint8Array, start: number, end: number): boolean {
+// Legacy detached per-packet authenticator suffix `[0xf0a1][len][auth]`. Its
+// producer was removed (BLO-16483) and nothing verifies it any more; provenance
+// is the signed per-group manifest. Receivers still skip an exact suffix so a
+// stale producer degrades to unauthenticated playback instead of dropped
+// packets. ponytail: hard-cut to reject once no deployed producer can emit it.
+const LEGACY_TRAILER_EXT_TYPE = 0xf0a1
+const LEGACY_TRAILER_HEADER_SIZE = 4
+
+function isEmptyOrExactLegacyTrailer(payload: Uint8Array, start: number, end: number): boolean {
   if (start === end) return true
-  if (start < 0 || end > payload.length || start + _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE > end) {
+  if (start < 0 || end > payload.length || start + LEGACY_TRAILER_HEADER_SIZE > end) {
     return false
   }
 
@@ -364,10 +365,10 @@ function isEmptyOrExactAltaTrailer(payload: Uint8Array, start: number, end: numb
     payload.byteOffset + start,
     end - start,
   )
-  if (view.getUint16(0, false) !== _LEAF_MMTP_EXT_TYPE_ALTA_AUTH) return false
+  if (view.getUint16(0, false) !== LEGACY_TRAILER_EXT_TYPE) return false
 
   const authLength = view.getUint16(2, false)
-  return start + _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE + authLength === end
+  return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end
 }
 
 interface DeclaredTrailerLayout {
@@ -383,21 +384,21 @@ function resolveDeclaredTrailers(
   if (declaredEnd > payload.length) return null
 
   if (options?.skipFecId) {
-    return isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)
+    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)
       ? { hasFecId: false }
       : null
   }
 
   if (fecType === 1) {
     const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE
-    if (fecStart < declaredEnd || !isEmptyOrExactAltaTrailer(payload, declaredEnd, fecStart)) {
+    if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
       return null
     }
     return { hasFecId: true }
   }
   if (fecType !== 0) return null
 
-  if (isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)) {
+  if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
     return { hasFecId: false }
   }
 
@@ -441,8 +442,8 @@ export interface MFUExtraction {
  * - Source FEC Payload ID (4 bytes at end, only when `FEC_type == 1`)
  *
  * `payloadLength` is the ISO length-after-field value: six remaining MPU-header
- * bytes, then the MFU DU header when present, then media. ALTA and Source FEC
- * trailers are outside that declared span and must consume the exact suffix.
+ * bytes, then the MFU DU header when present, then media. The legacy
+ * authenticator suffix and the Source FEC trailer are outside that declared span and must consume the exact suffix.
  *
  * @param mmtpPacket Raw MMTP packet (from multicast or MoQ)
  * @param options.skipFecId When true, do NOT subtract the 4-byte Source FEC Payload ID
@@ -559,7 +560,7 @@ function planMfuExtraction(
         gate: 'declared-trailers-unresolved',
         detail:
           `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty ` +
-          `nor an exact ALTA trailer (fecType=${header.fecType})`,
+          `nor an exact legacy authenticator trailer (fecType=${header.fecType})`,
       },
     }
   }
@@ -732,22 +733,6 @@ export function sourceFecPayloadIdOf(
   }
 }
 
-/**
- * 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").
- */
-// Re-export the ALTA trailer helper from the zero-dep leaf package. The leaf
-// owns the implementation so container and FEC consumers share one parser
-// without creating a package cycle.
-export const MMTP_EXT_TYPE_ALTA_AUTH = _LEAF_MMTP_EXT_TYPE_ALTA_AUTH
-export const MMTP_EXT_TRAILER_HEADER_SIZE = _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE
-export type AltaTrailer = _LeafAltaTrailer
-export const extractAltaTrailer = _leafExtractAltaTrailer
-
 /** Size of Repair FEC Payload ID per ISO/IEC 23008-1 Section C.5.3 */
 export const REPAIR_FEC_PID_SIZE = 13
 

package/src/serial-number.ts

@@ -47,61 +47,3 @@ export function serial32Precedes(a: number, b: number): boolean {
   const distance = serial32Distance(a, b)
   return distance !== 0 && distance < SERIAL32_HALF
 }
-
-/**
- * First SS_ID of block `sbn` under the K-stride numbering every current
- * sender uses (`SS_ID = SBN * K + ESI`, C.5.2), reduced mod 2^32.
- */
-export function kStrideBlockStart(sbn: number, k: number): number {
-  assertUint32(sbn, 'sbn')
-  if (!Number.isInteger(k) || k < 1 || k >= SERIAL32_HALF) {
-    throw new RangeError(`k must be a positive integer below 2^31 (got ${k})`)
-  }
-  // sbn < 2^32 and k < 2^31 keep the product below 2^63, but a double is
-  // exact only to 2^53; split the product so every step is exact.
-  const high = Math.floor(sbn / 0x1_0000) // < 2^16
-  const low = sbn % 0x1_0000              // < 2^16
-  return (((high * k) % SERIAL32_SPAN) * 0x1_0000 + low * k) % SERIAL32_SPAN
-}
-
-/**
- * Whether block `a` precedes block `b`, ordering the blocks by their first
- * SS_ID in serial arithmetic. Identical to `a < b` for any two blocks of a
- * stream that has not wrapped SS_ID.
- */
-export function kStrideBlockPrecedes(a: number, b: number, k: number): boolean {
-  return serial32Precedes(kStrideBlockStart(a, k), kStrideBlockStart(b, k))
-}
-
-/**
- * How many blocks `a` lies behind `b`: 0 when `a` does not precede `b`,
- * otherwise `ceil(distance / K)` over the SS_ID distance between their first
- * symbols. Without a wrap that is exactly `b - a`; across the wrap the one
- * short pre-wrap block (2^32 mod K symbols) still counts as one block.
- */
-export function kStrideBlocksBehind(a: number, b: number, k: number): number {
-  const from = kStrideBlockStart(a, k)
-  const to = kStrideBlockStart(b, k)
-  if (!serial32Precedes(from, to)) return 0
-  return Math.ceil(serial32Distance(from, to) / k)
-}
-
-/**
- * Whether `sbn` and `k` describe a block of the K-stride numbering:
- * `sbn` a uint32, `k` an integer in 1..2^31-1.
- */
-export function isKStrideBlock(sbn: number, k: number): boolean {
-  return Number.isInteger(sbn) && sbn >= 0 && sbn < SERIAL32_SPAN &&
-    Number.isInteger(k) && k >= 1 && k < SERIAL32_HALF
-}
-
-/**
- * The block after `sbn`: `sbn + 1`, or 0 once `(sbn + 1) * K` reaches 2^32
- * and the next SS_ID wraps (C.5.2). There are `ceil(2^32 / K)` blocks per
- * wrap, the last of them short when K does not divide 2^32.
- */
-export function kStrideNextBlock(sbn: number, k: number): number {
-  assertUint32(sbn, 'sbn')
-  kStrideBlockStart(sbn, k) // validates k
-  return (sbn + 1) * k >= SERIAL32_SPAN ? 0 : sbn + 1
-}

package/src/signalling.ts

@@ -112,20 +112,17 @@ function total<T>(parse: () => T | null): T | null {
 // ---------------------------------------------------------------------------
 
 /**
- * How the signalling payload of an MMTP packet was framed.
+ * How the signalling payload of an MMTP packet was framed: always
+ * `iso-9.3.4.2`, the 2-byte `f_i(2) RES(4) H(1) A(1) | frag_counter(8)`
+ * header of ISO/IEC 23008-1:2023 9.3.4.2 ahead of the message(s).
  *
- * - `iso-9.3.4.2`: the 2-byte `f_i(2) RES(4) H(1) A(1) | frag_counter(8)`
- *   header of ISO/IEC 23008-1:2023 9.3.4.2 precedes the message(s).
- * - `legacy-bare-alfec`: the pre-remediation Blockcast form, where the
- *   AL-FEC message starts directly after the MMTP header. It is recognised
- *   only by its first two bytes being `0x02 0x03` (message_id 0x0203). That
- *   pair is never a valid 9.3.4.2 header for a complete message: f_i=00 with
- *   frag_counter=3 claims three further fragments of a message the same
- *   header declares complete. The peek is therefore exact, not a heuristic.
- *   The legacy branch is deleted once no legacy sender remains (BLO-35597
- *   plan, Phase L).
+ * The pre-remediation Blockcast form, an AL-FEC message directly after the
+ * MMTP header, is not accepted (BLO-35597, Phase L). Its first two bytes,
+ * `0x02 0x03`, read as a 9.3.4.2 header claiming three further fragments
+ * of a complete message, which the header parser refuses: such a packet
+ * parses to null, never to a guess.
  */
-export type SignallingPayloadForm = 'iso-9.3.4.2' | 'legacy-bare-alfec'
+export type SignallingPayloadForm = 'iso-9.3.4.2'
 
 export interface SignallingPayload {
   form: SignallingPayloadForm
@@ -158,10 +155,6 @@ export function parseSignallingPayload(mmtpPacket: Uint8Array): SignallingPayloa
 
 function splitSignallingPayload(payload: Uint8Array): SignallingPayload {
   if (payload.length < 2) fail('short signalling payload')
-  if (payload[0] === (ALFEC_MESSAGE_ID >> 8) && payload[1] === (ALFEC_MESSAGE_ID & 0xff)) {
-    return { form: 'legacy-bare-alfec', messages: [payload] }
-  }
-
   const reader = new WireReader(payload)
   const flags = reader.u8()
   const fragmentation = flags >> 6
@@ -445,9 +438,9 @@ export function parseAlFecMessageBody(message: Uint8Array): AlFecMessageBody | n
 }
 
 /**
- * Parse the AL-FEC message carried by a full MMTP signalling packet, in
- * either payload form (see SignallingPayloadForm). Returns null when the
- * packet carries no AL-FEC message, more than one, or a malformed one.
+ * Parse the AL-FEC message carried by a full MMTP signalling packet (a
+ * 9.3.4.2 payload, see SignallingPayloadForm). Returns null when the packet
+ * carries no AL-FEC message, more than one, or a malformed one.
  */
 export function parseAlFecMessage(mmtpPacket: Uint8Array): AlFecMessage | null {
   const packet = parseSignallingPacket(mmtpPacket)
@@ -467,7 +460,9 @@ export function parseAlFecMessage(mmtpPacket: Uint8Array): AlFecMessage | null {
 export interface AlFecRaptorQFlowConfig {
   sourcePacketIds: number[]
   repairFlowId: number
+  /** Always `SSBG_MODE_1` (`iso-ssbg1-v1`). */
   ssbgMode: number
+  /** The coding byte's low bit as signalled (see AlFecFlow.fecPayloadIdMode). */
   fecPayloadIdMode: 0 | 1
   repairSymbolSize: number
   maximumK: number
@@ -506,15 +501,21 @@ function canonicalRaptorQOtiK(oti: Uint8Array, repairSymbolSize: number): number
  * the profile. Nothing is inferred: K comes from the OTI and must equal
  * maximum_k_for_repair_flow.
  *
- * ssbg_mode 0 and 1 are both returned as signalled: which source-symbol
- * construction a decoder applies is the stream's FEC block profile, decided
- * by its consumer, not here. ffsrpts_flag=1 is refused because the FFSRP_TS
- * word changes the source/repair packet trailer layout that every Blockcast
- * receiver assumes.
+ * The profile is `iso-ssbg1-v1`, whose AL-FEC coding byte is 0x14
+ * (draft-ramadan-moq-fec §7.3; ISO/IEC 23008-1 Table C.3 as replaced by
+ * Amd 1:2025): one-stage, ssbg_mode1, ffsrpts_flag 0, fec_payload_id_mode 0.
+ * 0x15 is accepted too: its low bit is fec_payload_id_mode 1 under Amd
+ * 1:2025 but reserved "1" in the unamended 2023 Table C.3, so a 2023 sender
+ * of the same profile emits it. No later field depends on the bit, and each
+ * source packet's FEC_type says whether it carries a Source FEC Payload ID,
+ * so the bit is reported, not interpreted (BLO-35597 N1). Any other coding
+ * byte is refused here, though `parseAlFecMessageBody` still reports it:
+ * ssbg_mode0 (0x10/0x11, the retired `k-padded-v1` wire) carries no length
+ * field; ffsrpts_flag=1 changes the source/repair packet trailer layout.
  */
 export function alFecRaptorQFlowConfig(flow: AlFecFlow): AlFecRaptorQFlowConfig | null {
   if (flow.fecCodingStructure !== FEC_CODING_STRUCTURE_ONE_STAGE || flow.repairFlows.length !== 1) return null
-  if (flow.ssbgMode !== SSBG_MODE_0 && flow.ssbgMode !== SSBG_MODE_1) return null
+  if (flow.ssbgMode !== SSBG_MODE_1) return null
   if (flow.ffsrptsFlag !== 0) return null
   const repair = flow.repairFlows[0]!
   if (repair.fecCodeId !== FEC_CODE_RAPTORQ) return null
@@ -847,10 +848,7 @@ function decodeSignallingMessage(bytes: Uint8Array): MmtSignallingMessage {
  * Parse every signalling message of a full MMTP signalling packet (the
  * packet_id 0 flow). Returns null when the packet or any message in it is
  * malformed: one unparseable message leaves the receiver unable to say what
- * the packet signalled.
- *
- * The legacy bare form carries exactly one AL-FEC message; any other message
- * is only accepted inside a 9.3.4.2 payload.
+ * the packet signalled. Only the 9.3.4.2 payload form is accepted.
  */
 export function parseSignallingPacket(mmtpPacket: Uint8Array): MmtSignallingPacket | null {
   const payload = parseSignallingPayload(mmtpPacket)