@blockcast/mmt-container 2.2.0-main.73af0eedcbc8 → 2.2.0-main.a16efba1d85a

package/src/fec-manager.ts

@@ -644,6 +644,10 @@ export class FECManager {
   // ── Keyframe-protected repair policy (block-policy.ts) ──
   // One classifier per physical stream, built from that stream's geometry.
   #classifiers = new Map<string, BlockClassifier>()
+  // A stream without catalog timing has no classifier, so the last RAP it
+  // released stands in for one: "an MPU boundary bounds its RAPs" holds until
+  // a second RAP is released inside one MPU (BLO-52085).
+  #noSpanRaps = new Map<string, { mpu: number; presentationTime: bigint; inside: boolean }>()
   // Geometry a stream-scoped configuration gave one stream (streamKey). ABR
   // rungs can share a packetId with a different framerate or GOP, so the
   // packet-level geometry is only the geometry of a packet whose streams
@@ -1706,6 +1710,7 @@ export class FECManager {
       // The classifier compares authored order with SBN order only within
       // one continuous SBN sequence.
       this.#classifiers.get(streamKey)?.noteSourceDiscontinuity()
+      this.#noSpanRaps.delete(streamKey)
       this.#highestSbn.set(streamKey, { sbn, atMs: now })
       this.#sourceFrontiers.set(streamKey, { sbn, atMs: now })
       if (psn === undefined) this.#sourceAnchors.delete(streamKey)
@@ -2289,6 +2294,9 @@ export class FECManager {
       // sibling's change, but the first stream-scoped geometry on a packet
       // does change the siblings that have none (stream-geometry-absent).
       this.#bumpEpoch(packetId)
+      for (const key of [...this.#noSpanRaps.keys()]) {
+        if (this.#belongsToPacket(key, packetId)) this.#noSpanRaps.delete(key)
+      }
       for (const [key, classifier] of [...this.#classifiers]) {
         if (!this.#belongsToPacket(key, packetId)) continue
         const stream = this.#parseStreamKey(key)
@@ -2565,6 +2573,7 @@ export class FECManager {
     resetMap(this.#isoLocators)
     resetMap(this.#sourceAnchors)
     this.#classifiers.delete(this.#streamKey(packetId, catalogTrackName))
+    this.#noSpanRaps.delete(this.#streamKey(packetId, catalogTrackName))
     this.#bumpEpoch(packetId)
     for (const [sbn, keys] of this.#blockKeysBySbn) {
       for (const key of keys.keys()) {
@@ -2679,6 +2688,7 @@ export class FECManager {
     dropMap(this.#isoLocators)
     dropMap(this.#sourceAnchors)
     dropMap(this.#classifiers)
+    dropMap(this.#noSpanRaps)
     dropMap(this.#streamGeometries)
     dropSet(this.#pendingWorkerCleanups)
     dropSet(this.#completedBlocks)
@@ -3470,11 +3480,14 @@ export class FECManager {
   /**
    * Whether an MPU boundary still bounds this stream's RAPs (see
    * `BlockClassifier.mpuBoundsRaps`). Gap decisions drop MPU evidence once
-   * it does not. A stream with no classifier yet has shown nothing against it.
+   * it does not. A stream with no classifier yet has shown nothing against it,
+   * and neither has a stream without catalog timing until it releases two
+   * RAPs inside one MPU.
    */
   mpuBoundsRapsFor(packetId: number, catalogTrackName?: string): boolean {
-    if (!this.#hasCatalogTimingForPacket(packetId)) return false
-    return this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))?.mpuBoundsRaps ?? true
+    const streamKey = this.#streamKey(packetId, catalogTrackName)
+    if (!this.#hasCatalogTimingForPacket(packetId)) return this.#noSpanRaps.get(streamKey)?.inside !== true
+    return this.#classifiers.get(streamKey)?.mpuBoundsRaps ?? true
   }
 
   /** A block's class now, or frozen at its resolution. */
@@ -3510,7 +3523,15 @@ export class FECManager {
     presentationTime: bigint,
     mediaTimescale: number,
   ): void {
-    if (!this.#trackConfigs.has(packetId) || !this.#hasCatalogTimingForPacket(packetId)) return
+    if (!this.#trackConfigs.has(packetId)) return
+    if (!this.#hasCatalogTimingForPacket(packetId)) {
+      const streamKey = this.#streamKey(packetId, catalogTrackName)
+      const last = this.#noSpanRaps.get(streamKey)
+      const inside = last?.inside === true ||
+        (last?.mpu === mpu && last.presentationTime !== presentationTime)
+      this.#noSpanRaps.set(streamKey, { mpu, presentationTime, inside })
+      return
+    }
     this.#applyClassifierChanges(
       packetId,
       catalogTrackName,
@@ -4883,6 +4904,7 @@ export class FECManager {
     this.#blockAnchorsMs.clear()
     this.#blockCatalogTrackNames.clear()
     this.#classifiers.clear()
+    this.#noSpanRaps.clear()
     this.#streamGeometries.clear()
     this.#failedBlocks.clear()
     this.#resolvedBlockClasses.clear()

package/src/fec-worker-setup.ts

@@ -64,7 +64,7 @@ export interface FecWorkerSetupOptions {
   /**
    * Repair symbols per block this receiver actually joined: the sum of
    * `repairSymbols` over the joined BASE layers (draft-ramadan-moq-fec 6.3).
-   * Reported as P by the worker snapshot and CMCD `x-bc-fec-p`, because the
+   * Reported as P by the worker snapshot and CMCD `com.blockcast-fp`, because the
    * catalog total is not what this receiver joined. Falls back to
    * `fecRepairCount`, which is the same value on a single-layer track.
    */
@@ -252,7 +252,7 @@ export async function setupFecWorkerForTrack(
     blockProfile,
     k: opts.fecK,
     // P as this receiver joined it, not the catalog total: the worker snapshot
-    // and CMCD `x-bc-fec-p` are read from this. Identity on a single layer.
+    // and CMCD `com.blockcast-fp` are read from this. Identity on a single layer.
     repairCount: opts.joinedRepairCount ?? opts.fecRepairCount,
     symbolSize: opts.fecSymbolSize,
     interleaveDepth: interleaveDepthBlocks,

package/src/index.ts

@@ -299,6 +299,7 @@ export {
   type MmtpFeedOutcomeKey,
   type TrackInfo,
   type MmtpReorderStats,
+  type MmtpRecoveredHeadTimingStats,
   type MmtpReorderFrameDiagnostics,
   type MmtpReorderStreamDiagnostics,
   type FrameMeta as ParserFrameMeta,
@@ -526,10 +527,13 @@ export {
   type FecStarvationDetectorConfig,
 } from './fec-starvation-detector.js'
 
-// CMCD Producer (x-bc-* vendor key telemetry, BLO-1044)
+// CMCD v2 Event-mode producer (CTA-5004-B, com.blockcast-* custom keys)
 export {
   CmcdProducer,
-  type CmcdParams,
+  encodeCmcdRecord,
+  type CmcdRecord,
+  type CmcdToken,
+  type CmcdValue,
   type CmcdProducerOptions,
   type SnapshotData,
   type TransportSnapshot,
@@ -546,6 +550,7 @@ export {
 	type TrackFecParams,
 	type TrackFecUnavailable,
 	catalogTrackFecUnavailable,
+	catalogTrackDeliveryMode,
 	catalogGroupDurationMs,
 	catalogKeyframeCadenceMs,
 	catalogFecMediaUnitsPerSecond,
@@ -602,11 +607,22 @@ export {
 	type MmtpFecSessionConfig,
 	type MmtpFecSessionDecoder,
 	type MmtpFecSessionDecoderConstructor,
+	type MmtpFecSessionMessageConfig,
+	type MmtpFecSessionMessageUpdate,
 	type MmtpFecSessionMixedPathStats,
 	type MmtpFecSessionPath,
 	type MmtpFecSessionPathCounts,
 	type MmtpFecSessionStats,
 } from "./mmtp-fec-session.js";
+// MoQ repair-layer subscriptions by measured loss (BLO-35456)
+export {
+	RepairLayerSubscriptions,
+	type MoqRepairDelivery,
+	type RepairLayerSource,
+	type RepairLayerSubscriptionsOptions,
+	type RepairLayerSubscriptionsSnapshot,
+	type RepairTrackSubscription,
+} from "./repair-layer-subscriptions.js";
 
 export {
 	catalogAmtNetworkSource,

package/src/iso-bmff-timing.ts

@@ -581,6 +581,14 @@ type PendingMovieFragment = Array<IsoBmffSampleTiming | null>
 export class IsoBmffTimingResolver {
   #track: IsoBmffTrackTiming | null = null
   #fragments = new Map<string, PendingMovieFragment>()
+  /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+  #firstSamples = new Map<string, IsoBmffSampleTiming>()
+  /**
+   * First sample and sample count of the newest fragments whose every slot was
+   * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+   * matches the combiner, since it retires an abandoned sample as well.
+   */
+  #delivered = new Map<string, { first: IsoBmffSampleTiming, sampleCount: number }>()
   #pendingSamples = 0
   #evictedSamples = 0
   #lastMovieFragmentRejection: IsoBmffMovieFragmentRejection | null = null
@@ -591,6 +599,11 @@ export class IsoBmffTimingResolver {
     }
   }
 
+  /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+  get initialized(): boolean {
+    return this.#track !== null
+  }
+
   get pendingSampleCount(): number {
     return this.#pendingSamples
   }
@@ -618,10 +631,18 @@ export class IsoBmffTimingResolver {
     return true
   }
 
+  /**
+   * `recovered` marks an FEC-recovered copy. A recovered block hands back
+   * every FT=1 it holds, the received ones included, so a recovered copy of a
+   * fragment whose samples are all done is a duplicate: admitting it again
+   * would charge stale timing and could displace the live MPU's. A source
+   * copy is still admitted again (a rendition switch re-arms timing that way).
+   */
   addMovieFragment(
     mpuSequenceNumber: number,
     data: Uint8Array,
     additionalSampleLimit = this.maxPendingSamples,
+    recovered = false,
   ): boolean {
     this.#lastMovieFragmentRejection = null
     if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
@@ -648,6 +669,9 @@ export class IsoBmffTimingResolver {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index]!),
       )
     }
+    const delivered = recovered ? this.#delivered.get(key) : undefined
+    if (delivered && delivered.sampleCount === parsed.samples.length &&
+        sameSample(delivered.first, parsed.samples[0]!)) return true
     // Sliding window, not a one-way ratchet. `consumeSample` and
     // `releaseSample` between them cover every sample some component observed
     // -- but a sample whose data units never arrive at all is observed by
@@ -683,6 +707,7 @@ export class IsoBmffTimingResolver {
       return false
     }
     this.#fragments.set(key, [...parsed.samples])
+    this.#firstSamples.set(key, parsed.samples[0]!)
     this.#pendingSamples += parsed.samples.length
     return true
   }
@@ -758,6 +783,7 @@ export class IsoBmffTimingResolver {
     let live = 0
     for (const sample of samples) if (sample !== null) live++
     this.#fragments.delete(oldest)
+    this.#firstSamples.delete(oldest)
     this.#pendingSamples -= live
     this.#evictedSamples += live
     return live
@@ -779,13 +805,26 @@ export class IsoBmffTimingResolver {
     if (!samples || !samples[index]) return false
     samples[index] = null
     this.#pendingSamples--
-    if (samples.every(value => value === null)) this.#fragments.delete(key)
+    if (samples.every(value => value === null)) {
+      this.#fragments.delete(key)
+      const first = this.#firstSamples.get(key)!
+      this.#firstSamples.delete(key)
+      this.#delivered.delete(key)
+      this.#delivered.set(key, { first, sampleCount: samples.length })
+      // ponytail: the dedupe memory is as wide as the timing budget, in fragments;
+      // a recovered copy older than that is admitted again, as before.
+      if (this.#delivered.size > this.maxPendingSamples) {
+        this.#delivered.delete(this.#delivered.keys().next().value!)
+      }
+    }
     return true
   }
 
   reset(): void {
     this.#track = null
     this.#fragments.clear()
+    this.#firstSamples.clear()
+    this.#delivered.clear()
     this.#pendingSamples = 0
   }
 }

package/src/mmtp-container-parser.ts

@@ -365,10 +365,19 @@ export type MmtpFeedDropReason =
   /** No timing resolver, or it refused the initialization segment. */
   | 'init-timing-refused'
   | 'fragment-unexpected-fragmentation'
+  /** FT=1 before an FT=0 has bound the stream's timing track. */
   | 'fragment-no-resolver'
   /** addMovieFragment refused — includes the pending-timing-sample budget. */
   | 'fragment-timing-refused'
   | 'unknown-fragment-type'
+  /** Stable code, no longer produced: an FT=2 with no timing (before the
+   *  stream's first FT=0, or after setTrack dropped it) now waits for its
+   *  timing like one whose FT=1 has not arrived. A head counts as
+   *  `drop:mfu-sample-timing-missing` (parked) and a FI=2/FI=3 continuation
+   *  as the `pending` record. A continuation that completes a head the
+   *  reassembler buffered before the timing was dropped counts as
+   *  `drop:assembled-timing-missing`. A panel keyed on this code reads zero:
+   *  a re-attribution, not lost coverage. Re-key on both drop codes. */
   | 'mfu-no-resolver'
   | 'mfu-empty-payload'
   | 'mfu-du-header-missing'
@@ -1089,9 +1098,30 @@ interface AwaitingTimingHead {
   mpuSequenceNumber: number
   movieFragmentSequenceNumber: number
   sampleNumber: number
+  /** MMTP packet sequence number; a recovered copy carries its source's. */
+  sequenceNumber: number
   arrivedAt: number
 }
 
+/** FEC-recovered heads that went through the awaiting-timing queue. Every
+ * count but `pending` is cumulative. A held head is pending or has left the
+ * queue exactly once, so `held - expired - discarded - superseded - pending`
+ * is the number fed again once their FT=1 landed. That feed can still refuse
+ * one (size, offset, dispose from a frame callback); the refusal is counted in
+ * `feedStats.deferredOutcomes`, not here. */
+export interface MmtpRecoveredHeadTimingStats {
+  /** Held because their sample's FT=1 had not arrived yet. */
+  held: number
+  /** Left without timing: the reassembler-timeout deadline, or pushed out by the queue's capacity. */
+  expired: number
+  /** Dropped with their stream (track reconfigure, reset or retire) or by dispose(). */
+  discarded: number
+  /** Gave way to their arriving source copy, which takes their place in the queue. */
+  superseded: number
+  /** In the queue now; current occupancy, not cumulative. */
+  pending: number
+}
+
 const MAX_AWAITING_TIMING_HEADS = 8
 
 // ── MmtpContainerParser ─────────────────────────────────────────────
@@ -1129,6 +1159,9 @@ export class MmtpContainerParser {
   #reclaimedTimingSamples = 0
   #evictedTimingSamples = 0
   #rejectedMovieFragments = 0
+  #recoveredHeadsAwaitingTiming: Omit<MmtpRecoveredHeadTimingStats, 'pending'> = {
+    held: 0, expired: 0, discarded: 0, superseded: 0,
+  }
   #sequencers = new Map<string, { packetId: number; sequencer: FrameSequencer }>()
   #fecGate: FecReleaseGate | null = null
   #fecSequencer: FecReleaseSequencer | null = null
@@ -1346,6 +1379,15 @@ export class MmtpContainerParser {
     }
   }
 
+  /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+  get recoveredHeadsAwaitingTiming(): Readonly<MmtpRecoveredHeadTimingStats> {
+    let pending = 0
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) if (head.options?.recovered) pending++
+    }
+    return { ...this.#recoveredHeadsAwaitingTiming, pending }
+  }
+
   get reorderStats(): Readonly<MmtpReorderStats> {
     let bufferedFrames = this.#fecSequencer?.buffered ?? 0
     for (const { sequencer } of this.#sequencers.values()) bufferedFrames += sequencer.buffered
@@ -1541,7 +1583,7 @@ export class MmtpContainerParser {
     const now = Date.now()
     for (const { awaitingTiming } of this.#timingStreams.values()) {
       while (awaitingTiming.length > 0 && now - awaitingTiming[0]!.arrivedAt > timeoutMs) {
-        awaitingTiming.shift()
+        this.#leaveAwaitingTiming(awaitingTiming.shift()!, 'expired')
       }
     }
   }
@@ -1711,11 +1753,16 @@ export class MmtpContainerParser {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return this.#drop('fragment-unexpected-fragmentation')
       const resolver = this.#timingResolver(streamKey, info.packetId, false)
-      if (!resolver) return this.#drop('fragment-no-resolver')
+      if (!resolver?.initialized) return this.#drop('fragment-no-resolver')
       const pendingBefore = resolver.pendingSampleCount
       const evictedBefore = resolver.evictedSampleCount
       const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples
-      const admitted = resolver.addMovieFragment(mpu.mpuSequenceNumber, data, remaining)
+      const admitted = resolver.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true,
+      )
       // Sync on BOTH paths: the resolver can displace stale timing and still
       // refuse the fragment in hand, and a global count that missed those
       // freed slots would keep refusing on a budget that is no longer full.
@@ -1739,7 +1786,11 @@ export class MmtpContainerParser {
     }
     if (fragmentType !== 2) return this.#drop('unknown-fragment-type')
 
-    const resolver = this.#timingResolver(streamKey, info.packetId, false)
+    // An FT=2 before the stream's first FT=0 (a join, a track reset) is taken
+    // like one whose FT=1 has not arrived: a head waits for its timing, a
+    // continuation parks in the reassembler, and a later or FEC-recovered
+    // FT=0/FT=1 can still time them.
+    const resolver = this.#timingResolver(streamKey, info.packetId, true)
     if (!resolver) return this.#drop('mfu-no-resolver')
     if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
       return this.#drop('mfu-empty-payload')
@@ -1761,6 +1812,7 @@ export class MmtpContainerParser {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now(),
         })
         return this.#drop('mfu-sample-timing-missing')
@@ -2146,6 +2198,18 @@ export class MmtpContainerParser {
     this.#emitFrame(data, meta)
   }
 
+  /** Whether FT=1 metadata already names this sample, without claiming it. */
+  hasAuthoredTimingFor(
+    packetId: number,
+    mpuSequenceNumber: number,
+    movieFragmentSequenceNumber: number,
+    sampleNumber: number,
+    catalogTrackName?: string,
+  ): boolean {
+    return this.#timingResolver(this.#streamKey(packetId, catalogTrackName), packetId, false)
+      ?.sampleTiming(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) != null
+  }
+
   /**
    * Claim and return the authored timing for a recovered sample. Recovery does
    * not pass through the ordinary `feed()` completion path, so it must retire
@@ -2216,6 +2280,9 @@ export class MmtpContainerParser {
     for (const { sequencer } of this.#sequencers.values()) sequencer.discard()
     this.#sequencers.clear()
     this.#fecSequencer?.discard()
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) this.#leaveAwaitingTiming(head, 'discarded')
+    }
     this.#timingStreams.clear()
     this.#pendingTimingSamples = 0
     this.#reliableMoqStartupGate.clear()
@@ -2241,10 +2308,27 @@ export class MmtpContainerParser {
   }
 
   #awaitTiming(streamKey: string, head: AwaitingTimingHead): void {
-    const awaitingTiming = this.#timingStreams.get(streamKey)?.awaitingTiming
-    if (!awaitingTiming) return
+    const state = this.#timingStreams.get(streamKey)
+    if (!state) return
+    // The source copy of a held recovered head takes its place, so the frame
+    // is delivered with source provenance once FT=1 lands.
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter(queued =>
+        !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber)
+      this.#recoveredHeadsAwaitingTiming.superseded += state.awaitingTiming.length - kept.length
+      state.awaitingTiming = kept
+    }
+    const awaitingTiming = state.awaitingTiming
     awaitingTiming.push(head)
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift()
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming.held++
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      this.#leaveAwaitingTiming(awaitingTiming.shift()!, 'expired')
+    }
+  }
+
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  #leaveAwaitingTiming(head: AwaitingTimingHead, outcome: 'expired' | 'discarded'): void {
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming[outcome]++
   }
 
   /**
@@ -2274,6 +2358,7 @@ export class MmtpContainerParser {
     const state = this.#timingStreams.get(streamKey)
     if (!state) return
     this.#timingStreams.delete(streamKey)
+    for (const head of state.awaitingTiming) this.#leaveAwaitingTiming(head, 'discarded')
     this.#pendingTimingSamples -= state.resolver.pendingSampleCount
     if (this.#pendingTimingSamples < 0) {
       throw new Error('[MmtpContainerParser] pending timing sample accounting underflow')

package/src/mmtp-fec-session.ts

@@ -23,6 +23,15 @@
  * uses. A packet below B_0 at or after the anchor fails the session closed:
  * `stats.failClosed` reports why, and every later repair is refused.
  *
+ * Catalog-less (draft-ramadan-moq-mmt-02 8.3, 13.2): a receiver holding
+ * layer 0 under the AL-FEC message alone builds the session from the message's
+ * fec_flow entry (`alFecFlow`) instead. K, T, the code point and the repair
+ * packet_id come from that entry, and layer 0 is held at
+ * maximum_p_for_repair_flow, standing for O_0 + P_0, by the anchored clause of
+ * draft-ramadan-moq-fec-core-00 7.3.2 alone. A later version that raises the
+ * field raises the held total (updateAlFecFlow()); the message carries no
+ * millisecond budget, so the caller states the retention (fec-core-00 9.4).
+ *
  * Every repair packet that cannot be used is counted under the reason it was
  * refused, and every block ends under exactly one outcome, so a stream whose
  * FEC is doing nothing can be told apart from one with nothing to repair.
@@ -30,6 +39,8 @@
 
 import {
   admitMmtpRepairObject,
+  alFecRaptorQFlowConfig,
+  FEC_CODE_RAPTORQ,
   isoBlockContains,
   isoBlocksBehindLowerBound,
   parseFecBlockProfile,
@@ -39,6 +50,8 @@ import {
   serial32Precedes,
   ssbg1FitsSymbol,
   trimSsbg1SourceSymbol,
+  type AlFecFlow,
+  type AlFecRaptorQFlowConfig,
   type FecBlockProfile,
 } from '@blockcast/mmt-base'
 import { deriveFecRetentionBlocks, fecBlockBudgetMs } from '@blockcast/mmt-fec'
@@ -105,6 +118,25 @@ export interface MmtpFecSessionConfig {
   heldLayers?: readonly number[]
 }
 
+/**
+ * A catalog-less session: one fec_flow entry of the AL-FEC message
+ * (`parseAlFecMessage(...).flows[i]`), draft-ramadan-moq-mmt-02 8.3.
+ */
+export interface MmtpFecSessionMessageConfig {
+  /** The source track's entry; it must pass `alFecRaptorQFlowConfig`. */
+  alFecFlow: AlFecFlow
+  /**
+   * The decoder retention in blocks. The message carries no elapsed-time
+   * budget (mmt-02 7.5), so open-block state is bounded by local policy
+   * (fec-core-00 9.4); required, never defaulted.
+   */
+  retentionBlocks: number
+  Decoder: MmtpFecSessionDecoderConstructor
+}
+
+/** What updateAlFecFlow() did with a later version of the message. */
+export type MmtpFecSessionMessageUpdate = 'raised' | 'unchanged' | 'refused'
+
 /**
  * The path a symbol arrived on: its MoQT subscription, or the multicast
  * group (native SSM or AMT) carrying the same asset. The caller states it;
@@ -197,12 +229,17 @@ export class MmtpFecSession {
   readonly algorithm: 'raptorq' | 'reed-solomon'
   readonly sourceSymbols: number
   /** P_0 = B_0, the held total every repair packet is checked against. */
-  readonly repairSymbols: number
+  get repairSymbols(): number {
+    return this.#repairSymbols
+  }
   readonly symbolSize: number
   /** The decoder's retention, in blocks, derived from the catalog budget. */
   readonly retentionBlocks: number
 
   #decoder: MmtpFecSessionDecoder | null
+  #repairSymbols: number
+  /** The message entry a catalog-less session was built from; undefined under a catalog. */
+  #message: AlFecRaptorQFlowConfig | undefined
   /** Blocks a repair has defined and that are not settled yet, by SS_Start. */
   #blocks = new Map<number, BlockState>()
   /** SS_Starts of settled blocks, so a later repair for one is refused. */
@@ -240,7 +277,26 @@ export class MmtpFecSession {
    *   the scheme, the block profile, K, P_0 (`repairSymbols`), T,
    *   `interleaveDepthMs` or `reorderToleranceMs`. None is defaulted.
    */
-  constructor(config: MmtpFecSessionConfig) {
+  constructor(config: MmtpFecSessionConfig | MmtpFecSessionMessageConfig) {
+    if (config && 'alFecFlow' in config) {
+      const message = alFecRaptorQFlowConfig(config.alFecFlow)
+      if (!message) {
+        throw new Error('MmtpFecSession: the AL-FEC entry is outside draft-ramadan-moq-mmt-02 8.3 (iso-ssbg1-v1)')
+      }
+      this.#message = message
+      // Coding byte 0x14 is the iso-ssbg1-v1 profile (mmt-02 8.3).
+      this.blockProfile = parseFecBlockProfile('iso-ssbg1-v1', 'alFecFlow')
+      this.algorithm = message.fecCodeId === FEC_CODE_RAPTORQ ? 'raptorq' : 'reed-solomon'
+      this.sourceSymbols = message.maximumK
+      this.#repairSymbols = message.maximumP
+      this.symbolSize = message.repairSymbolSize
+      this.retentionBlocks = requirePositiveInteger(config.retentionBlocks, 'retentionBlocks')
+      this.#repairPacketId = message.repairFlowId
+      this.#heldLayers = layerZero(message.maximumP)
+      this.#anchorHorizon = heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols)
+      this.#decoder = buildDecoder(config.Decoder, this)
+      return
+    }
     const fec = config?.fec
     if (!fec || typeof fec !== 'object') {
       throw new Error('MmtpFecSession: the catalog fec instance is required')
@@ -251,7 +307,7 @@ export class MmtpFecSession {
     }
     this.algorithm = fec.scheme
     this.sourceSymbols = requirePositiveInteger(fec.sourceSymbols, 'fec.sourceSymbols')
-    this.repairSymbols = requirePositiveInteger(fec.repairSymbols, 'fec.repairSymbols')
+    this.#repairSymbols = requirePositiveInteger(fec.repairSymbols, 'fec.repairSymbols')
     this.symbolSize = requirePositiveInteger(fec.symbolSize, 'fec.symbolSize')
     const interleaveDepthMs = requireNumber(fec.interleaveDepthMs, 'fec.interleaveDepthMs')
     const reorderToleranceMs = requireNumber(fec.reorderToleranceMs, 'fec.reorderToleranceMs')
@@ -271,17 +327,38 @@ export class MmtpFecSession {
       config.heldLayers,
     )
     this.#anchorHorizon = heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols)
-    if (typeof config.Decoder !== 'function') {
-      throw new Error('MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required')
-    }
-    const decoder = new config.Decoder(this.retentionBlocks, this.blockProfile, this.algorithm)
-    try {
-      decoder.configure_params(this.sourceSymbols, this.symbolSize)
-    } catch (error) {
-      decoder.free()
-      throw error
+    this.#decoder = buildDecoder(config.Decoder, this)
+  }
+
+  /**
+   * A later version of the AL-FEC message, catalog-less sessions only. A
+   * maximum_p_for_repair_flow above the held total raises it (`raised`): the
+   * anchored check restarts at the new total, so a block generated under the
+   * previous one stays valid before the first block carrying the new total
+   * (fec-core-00 7.3.2, mmt-02 8.3). A field at or below it changes nothing
+   * (`unchanged`): no publisher lowers it, and the check catches a wire that
+   * does. An entry with another asset, repair flow, code point, K or T, or
+   * one outside 8.3, is `refused`: that is a new source encoding, which needs
+   * a new session. A latched fail-closed stays latched either way.
+   */
+  updateAlFecFlow(flow: AlFecFlow): MmtpFecSessionMessageUpdate {
+    const held = this.#message
+    if (!held) throw new Error('MmtpFecSession: updateAlFecFlow() needs a session built from an AL-FEC entry')
+    const next = alFecRaptorQFlowConfig(flow)
+    if (
+      !next ||
+      next.sourcePacketIds[0] !== held.sourcePacketIds[0] ||
+      next.repairFlowId !== held.repairFlowId ||
+      next.fecCodeId !== held.fecCodeId ||
+      next.maximumK !== held.maximumK ||
+      next.repairSymbolSize !== held.repairSymbolSize
+    ) {
+      return 'refused'
     }
-    this.#decoder = decoder
+    if (next.maximumP <= this.#repairSymbols) return 'unchanged'
+    this.#repairSymbols = next.maximumP
+    this.#heldLayers = layerZero(next.maximumP)
+    return 'raised'
   }
 
   /** True once release() ran. */
@@ -386,7 +463,7 @@ export class MmtpFecSession {
       // An RSB_length below a held layer's total goes to the 7.3.2 stop, not
       // to the discard; the block state is unchanged either way.
       const verdict = this.#heldLayers.failsClosed(
-        repairTrackName, frame.ssStart, frame.rsbLength, this.#anchorHorizon, this.#newestSource,
+        this.#trackFor(repairTrackName), frame.ssStart, frame.rsbLength, this.#anchorHorizon, this.#newestSource,
       )
       if (verdict) {
         this.#stats.failClosed = verdict
@@ -399,7 +476,7 @@ export class MmtpFecSession {
     // fec-01 6.3.9, after the 4.5 discards and the size check, before a block
     // is placed. Without a track name only the anchored rule (b) applies.
     const verdict = this.#heldLayers.admit(
-      repairTrackName,
+      this.#trackFor(repairTrackName),
       frame.ssStart,
       frame.rsbLength,
       this.#anchorHorizon,
@@ -464,6 +541,11 @@ export class MmtpFecSession {
     return true
   }
 
+  /** Catalog-less: layer 0 has no own-track clause (mmt-02 8.3), so no track name is judged. */
+  #trackFor(repairTrackName: string | undefined): string | undefined {
+    return this.#message ? undefined : repairTrackName
+  }
+
   #drop(reason: string): Uint8Array[] {
     this.#stats.dropped[reason] = (this.#stats.dropped[reason] ?? 0) + 1
     return []
@@ -600,6 +682,24 @@ export class MmtpFecSession {
   }
 }
 
+function layerZero(total: number): HeldLayerAdmission {
+  return new HeldLayerAdmission([{ layer: 0, repairTrackName: '', rsIdOffset: 0, repairSymbols: total }])
+}
+
+function buildDecoder(Decoder: MmtpFecSessionDecoderConstructor, session: MmtpFecSession): MmtpFecSessionDecoder {
+  if (typeof Decoder !== 'function') {
+    throw new Error('MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required')
+  }
+  const decoder = new Decoder(session.retentionBlocks, session.blockProfile, session.algorithm)
+  try {
+    decoder.configure_params(session.sourceSymbols, session.symbolSize)
+  } catch (error) {
+    decoder.free()
+    throw error
+  }
+  return decoder
+}
+
 function requirePositiveInteger(value: unknown, path: string): number {
   if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
     throw new Error(`MmtpFecSession: ${path} must be a positive integer (got ${String(value)})`)