@blockcast/mmt-container 2.2.0-main.c4fa878f4ff4 → 2.2.0-main.da2e7cd1dd5d

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

@@ -526,10 +526,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 +549,7 @@ export {
 	type TrackFecParams,
 	type TrackFecUnavailable,
 	catalogTrackFecUnavailable,
+	catalogTrackDeliveryMode,
 	catalogGroupDurationMs,
 	catalogKeyframeCadenceMs,
 	catalogFecMediaUnitsPerSecond,

package/src/mmtp-container-parser.ts

@@ -2146,6 +2146,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

package/src/mmtp-router.ts

@@ -5206,6 +5206,27 @@ export class MmtpRouter {
       );
     }
 
+    // A recovered head whose sample FT=1 has not named yet (an overlay that
+    // outran the source path) would complete its data unit untimed: the unit
+    // is dropped, marked completed, and the timed source copy is then refused
+    // (BLO-53342). Leave it out; its recovered continuations park and complete
+    // with the source head. A head that is truly lost ends as it did before.
+    result = {
+      ...result,
+      symbols: result.symbols.filter((sym) =>
+        sym.fragmentType !== 2 ||
+        sym.fragment.fragmentationIndicator !== 1 ||
+        sym.fragment.movieFragmentSequenceNumber === undefined ||
+        sym.fragment.sampleNumber === undefined ||
+        this.#parser.hasAuthoredTimingFor(
+          ownerPacketId,
+          sym.fragment.mpuSequenceNumber,
+          sym.fragment.movieFragmentSequenceNumber,
+          sym.fragment.sampleNumber,
+          catalogTrackName,
+        )),
+    };
+
     // MSE assembler path: route recovered block as pre-assembled frames (skip FT=0)
     // BLO-3035 layer 3: recovered symbols are RAW MFU fragments, not complete
     // frames. A keyframe can span multiple packets (FI=1/2/3); pushing each

package/src/repair-layer-subscriptions.ts

@@ -15,7 +15,10 @@
  * base (`MmtpRouter.feedRepairPacket(..., repairTrackName)`).
  *
  * `stream` delivery means QUIC retransmits: no repair track is ever
- * subscribed (FEC only for unreliable transports).
+ * subscribed (FEC only for unreliable transports). The mode is the source's
+ * `deliveryMode` (`catalogTrackDeliveryMode`); absent is `datagram`. It is
+ * read from the current source, so on a catalog refresh re-feed the updated
+ * source through `switchSource` for a changed `deliveryMode` to take effect.
  *
  * ABR switch R -> R' (`switchSource`): R's subscriptions are closed, the layer
  * count carries to R', and any packet R's subscriptions deliver after the
@@ -35,6 +38,8 @@ export interface RepairLayerSource {
   repairLayers?: readonly RepairLayerParams[]
   /** Keyframe overlays (`TrackFecParams.repairOverlays`); at most one is used. */
   repairOverlays?: readonly RepairOverlayParams[]
+  /** The publisher's MoQ delivery mode; absent is `datagram`. */
+  deliveryMode?: MoqRepairDelivery
 }
 
 export interface RepairTrackSubscription {
@@ -43,7 +48,6 @@ export interface RepairTrackSubscription {
 
 export interface RepairLayerSubscriptionsOptions {
   source: RepairLayerSource
-  delivery: MoqRepairDelivery
   /** Subscribe one repair track; every object payload goes to `onPacket`. */
   subscribe(
     repairTrackName: string,
@@ -110,7 +114,7 @@ export class RepairLayerSubscriptions {
    * or interleaved sequences read as loss.
    */
   noteSourceSequence(seq: number): void {
-    if (this.#disposed || this.#opts.delivery === 'stream') return
+    if (this.#disposed || this.#delivery() === 'stream') return
     seq >>>= 0
     if (this.#lastSeq === undefined) {
       this.#lastSeq = seq
@@ -152,13 +156,13 @@ export class RepairLayerSubscriptions {
     this.#expected = 0
     this.#lost = 0
     this.#wantFewer = 0
-    this.#layerCount = Math.min(this.#layerCount, this.#layers().length)
+    this.#layerCount = this.#delivery() === 'stream' ? 0 : Math.min(this.#layerCount, this.#layers().length)
     this.#reconcile()
   }
 
   snapshot(): RepairLayerSubscriptionsSnapshot {
     return {
-      delivery: this.#opts.delivery,
+      delivery: this.#delivery(),
       layerCount: this.#layerCount,
       subscribedTracks: [...this.#subs.keys()],
       repairPackets: this.#repairPackets,
@@ -174,6 +178,10 @@ export class RepairLayerSubscriptions {
     this.#disposed = true
   }
 
+  #delivery(): MoqRepairDelivery {
+    return this.#source.deliveryMode === 'stream' ? 'stream' : 'datagram'
+  }
+
   #layers(): readonly RepairLayerParams[] {
     return this.#source.repairLayers ?? []
   }

package/src/track-session.ts

@@ -58,7 +58,7 @@ export interface TrackSessionConfig {
    * This is runtime join state, not catalog geometry: a receiver on a clean
    * path joins layer 0 only while a lossy one adds layers, so the catalog's
    * total P is not what this receiver is receiving. Diagnostics that report P
-   * (the worker snapshot, CMCD `x-bc-fec-p`) must read this.
+   * (the worker snapshot, CMCD `com.blockcast-fp`) must read this.
    *
    * Absent when the caller joins no layers explicitly, in which case P_0 is
    * what was joined. That is an identity on a single-layer track, not a