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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcast/mmt-container",
-  "version": "2.2.0-main.c4fa878f4ff4",
+  "version": "2.2.0-main.da2e7cd1dd5d",
   "description": "MMTP/LOC container parsing for MMT over MoQ and SSM",
   "type": "module",
   "main": "dist/index.js",
@@ -169,10 +169,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@blockcast/fec-worker": "2.2.0-main.c4fa878f4ff4",
-    "@blockcast/mmt-base": "2.2.0-main.c4fa878f4ff4",
-    "@blockcast/mmt-fec": "2.2.0-main.c4fa878f4ff4",
-    "@blockcast/mmt-manifest-verify": "2.2.0-main.c4fa878f4ff4",
+    "@blockcast/fec-worker": "2.2.0-main.da2e7cd1dd5d",
+    "@blockcast/mmt-base": "2.2.0-main.da2e7cd1dd5d",
+    "@blockcast/mmt-fec": "2.2.0-main.da2e7cd1dd5d",
+    "@blockcast/mmt-manifest-verify": "2.2.0-main.da2e7cd1dd5d",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
     "ajv": "^8.17.1",
@@ -180,6 +180,9 @@
   },
   "devDependencies": {
     "@blockcast/mmt-transport": "file:../transport",
+    "@svta/cml-cmcd": "^2.8.4",
+    "@svta/cml-structured-field-values": "^1.1.7",
+    "@svta/cml-utils": "^1.7.0",
     "esbuild": "^0.28.0",
     "hash-wasm": "^4.12.0",
     "typescript": "^5.3.0",

package/schemas/catalog.schema.json

@@ -138,6 +138,10 @@
           "$ref": "#/$defs/positiveInteger",
           "description": "Keyframe interval in the track's timescale ticks (moqcast-draft §4.4.3). Exact where keyframeIntervalMs rounds (e.g. 30000/1001 video); when both are present, keyframeIntervalTicks wins."
         },
+        "deliveryMode": {
+          "type": "string",
+          "description": "How the publisher sends this track's objects (draft-ramadan-moq-fec-catalog-00 §3.3, proposed in moqcast-draft#26): \"datagram\" or \"stream\". A receiver treats a missing or unrecognized value as \"datagram\", so any string is admitted here rather than rejected. Allowed on source, repair and symbol tracks."
+        },
         "fec": { "$ref": "#/$defs/fec" }
       },
       "allOf": [

package/src/catalog-fec-params.ts

@@ -30,6 +30,7 @@ import type {
 	RepairOverlayParams,
 } from "./repair-layers.js";
 import type { RepairTarget } from "./repair-fetch.js";
+import type { MoqRepairDelivery } from "./repair-layer-subscriptions.js";
 
 export { catalogFecInterleaveMs, type FecInterleaveCatalog };
 export { FEC_BLOCK_PROFILES, isFecBlockProfile, parseFecBlockProfile, type FecBlockProfile };
@@ -273,6 +274,9 @@ export type TrackFecParams = {
 	/** Keyframe overlay instances declared for this track. Present (possibly
 	 *  empty) whenever repairLayers is. */
 	repairOverlays?: readonly RepairOverlayParams[];
+	/** The publisher's MoQ delivery mode (`catalogTrackDeliveryMode`).
+	 *  Present whenever repairLayers is; `RepairLayerSubscriptions` reads it. */
+	deliveryMode?: MoqRepairDelivery;
 	fps?: number;
 	sampleRate?: number;
 };
@@ -293,7 +297,7 @@ const NO_FEC: TrackFecParams = {
  * A keyframe overlay is a separate FEC instance with its own K, its own
  * RSB_length and its own RS_ID space, so it is never added here however it was
  * joined. Counting it would overstate the base instance's P and misreport
- * CMCD `x-bc-fec-p`.
+ * CMCD `com.blockcast-fp`.
  *
  * Falls back to P_0 when the track declares no layers, which is the
  * single-layer identity rather than a default: with one layer, P_0 is the
@@ -368,6 +372,36 @@ export function resolveRepairLayers(
 	};
 }
 
+/** The catalog value a JSON Pointer (RFC 6901) names, or undefined. */
+function valueAt(catalog: unknown, pointer: string): unknown {
+	let node = catalog;
+	for (const segment of pointer.split("/").slice(1)) {
+		if (typeof node !== "object" || node === null) return undefined;
+		node = (node as Record<string, unknown>)[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+	}
+	return node;
+}
+
+/**
+ * The publisher's MoQ delivery mode for one source track: `deliveryMode` on
+ * its base track entry (the hang rendition or MSF `tracks[]` entry its FEC
+ * binds to). `stream` means QUIC retransmits, so the receiver subscribes no
+ * repair track. Absent or any other value is `datagram`, FFmpeg's
+ * `moq_delivery_mode` default: a receiver never silently drops repair on a
+ * lossy path. When a track is declared both as a hang rendition and as an
+ * MSF `tracks[]` entry, the rendition is authoritative: a `deliveryMode` on
+ * the shadowed `tracks[]` entry is not read (fails safe to `datagram`).
+ * Never throws.
+ */
+export function catalogTrackDeliveryMode(
+	catalog: RepairLayerCatalog | undefined,
+	source: string | CatalogTrackRef,
+): MoqRepairDelivery {
+	const binding = bindingOf(catalog, source);
+	const entry = binding ? valueAt(catalog, binding.pointer) : undefined;
+	return (entry as { deliveryMode?: unknown } | undefined)?.deliveryMode === "stream" ? "stream" : "datagram";
+}
+
 /** A MoQ Transport priority (0..255, lower first), or null. */
 function moqtPriority(value: unknown): number | null {
 	return Number.isSafeInteger(value) && (value as number) >= 0 && (value as number) <= 255 ? (value as number) : null;
@@ -444,6 +478,7 @@ function fecParams(
 		repairTrackName: base.repairTrack,
 		repairLayers: repair.baseLayers,
 		repairOverlays: repair.overlays,
+		deliveryMode: catalogTrackDeliveryMode(catalog, track!),
 		...mediaRate,
 	};
 }

package/src/cmcd-producer.ts

@@ -1,26 +1,36 @@
 /**
- * CmcdProducer — transport-agnostic CMCD telemetry producer.
+ * CmcdProducer — CMCD v2 Event-mode reports (CTA-5004-B §2.2) from a player.
  *
- * Maps FecTrackStats snapshots and TransportSnapshot state to x-bc-*
- * CMCD vendor keys (proto tags 70-99). Fires callbacks for two delivery
- * channels: MoQ SUBSCRIBE params and multicast HTTP POST.
+ * Maps FecTrackStats snapshots, repair lifecycle events and transport state to
+ * newline-separated `application/cmcd` records (CTA-5004-B §3.3), each an
+ * RFC 8941 dictionary carrying `v=2`, `ts`, `e`, `sn` and `sid`:
  *
- * Does NOT call fetch() or write to QUIC directly — the player wiring
- * layer is responsible for attaching params to SUBSCRIBE or POSTing
- * the payload to the CDN CMCD endpoint.
+ * - `e=t`  — time-interval heartbeat, Table 1 keys only;
+ * - `e=ce` — custom event `cen="com.blockcast-fec"` carrying the
+ *   `com.blockcast-*` counters at the heartbeat cadence. Custom keys ride
+ *   only on `e=ce`: §2.2 admits on Event reports only Table 1 keys, and the
+ *   Table 1 `cen` row admits a custom key-value pair with a custom event;
+ * - `e=e`  — FEC failed closed, with `ec`.
  *
- * @see docs/superpowers/specs/2026-04-15-iwa-multicast-stack-design.md §3.3
- * @see CDN+ Track D BLO-1044
+ * Custom values are STRING or TOKEN of at most 64 characters (§4.1): numbers
+ * go out as strings. A value that is unknown is omitted, never sent as zero
+ * (§3). Counters are absolute since session start, so a lost report loses
+ * nothing.
+ *
+ * Does NOT call fetch(): the player POSTs the body handed to `onCmcdPost` with
+ * `Content-Type: application/cmcd`. The heartbeat is driven by the snapshots
+ * the player already feeds; there is no timer here.
  */
 
 import type { FecTrackStats } from '@blockcast/fec-worker'
 import type { FecFailClosedReason } from './fec-manager.js'
+import type { RepairLifecycleEvent } from './multicast-manager.js'
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
-/** Source-auth counters for CMCD: records verified, and drops per reason. */
+/** Source-auth counters: records verified, and drops per reason. */
 export interface ManifestVerificationStats {
   verified: number
   failures: Record<string, number>
@@ -42,11 +52,11 @@ export interface TransportSnapshot {
   amtRelay?: string
 }
 
-/** Transport transition event identifiers for x-bc-ct. */
+/** Transport transition event identifiers for `com.blockcast-ct`. */
 export type TransportTransitionEvent = 'mc-start' | 'mc-to-uc' | 'amt-start'
 
 /**
- * Phase 14 play-mode state (D-12, x-bc-play-mode):
+ * Play-mode state (`com.blockcast-pm`):
  * - `full`         — base + delta both active
  * - `base-only`    — delta fell back; base carries playback
  * - `single-track` — stream is not a multi-track switching set (legacy)
@@ -55,15 +65,27 @@ export type PlayMode = 'full' | 'base-only' | 'single-track'
 
 const PLAY_MODES: readonly PlayMode[] = ['full', 'base-only', 'single-track']
 
-/** CMCD vendor key map. Values are string, number, or boolean. */
-export type CmcdParams = Record<string, string | number | boolean>
+/** An RFC 8941 token (bare, unquoted). */
+export interface CmcdToken {
+  readonly token: string
+}
+
+/** A record value: integer, string, token, or inner list of strings. */
+export type CmcdValue = number | string | CmcdToken | readonly string[]
+
+/** One CMCD record, before encoding. */
+export type CmcdRecord = Record<string, CmcdValue>
 
 /** Options for CmcdProducer construction. */
 export interface CmcdProducerOptions {
-  /** Fired on each snapshot and on transport transitions. Params for MoQ SUBSCRIBE. */
-  onCmcdParams?: (params: CmcdParams) => void
-  /** Fired on each snapshot and on transport transitions. RFC 9559 query-string for HTTP POST body. */
-  onCmcdPost?: (payload: string) => void
+  /** Fired with an `application/cmcd` body: one record per line. */
+  onCmcdPost?: (body: string) => void
+  /** Heartbeat period for the `e=t` and counter reports. Default 30 s (CTA-5004-B §5). */
+  intervalMs?: number
+  /** CTA-5004-B `sid`. Default: a random UUID per producer. */
+  sessionId?: string
+  /** Wall clock in ms since the epoch, for `ts` and the heartbeat. Default `Date.now`. */
+  now?: () => number
 }
 
 /** Snapshot data passed to onSnapshot(). */
@@ -80,95 +102,80 @@ export interface TransportOnlySnapshotData {
   switchMiscount?: number
 }
 
-// ---------------------------------------------------------------------------
-// Value sanitization (T-06-01: header injection mitigation)
-// ---------------------------------------------------------------------------
+const DEFAULT_INTERVAL_MS = 30_000
+const CUSTOM_PREFIX = 'com.blockcast-'
+/** CTA-5004-B §4.1: a custom value is at most 64 characters. */
+const MAX_CUSTOM_VALUE = 64
 
-/** Strip commas, newlines, and carriage returns from string values. */
-function sanitize(value: string): string {
-  return value.replace(/[,\r\n]/g, '')
+const TRANSPORT_TOKEN: Record<TransportSnapshot['transport'], string> = {
+  native: 'ssm',
+  amt: 'amt',
+  moq: 'moq',
 }
 
 // ---------------------------------------------------------------------------
-// Key building (pure functions, no side effects)
+// Encoding (RFC 8941 dictionary, keys sorted — CTA-5004-B §3)
 // ---------------------------------------------------------------------------
 
-/** Build FEC vendor keys from a FecTrackStats snapshot. */
-function buildFecParams(stats: FecTrackStats): CmcdParams {
-  const params: CmcdParams = {}
-  const cfg = stats.config
-
-  params['x-bc-fec-algo'] = cfg.algorithm
-  params['x-bc-fec-k'] = cfg.k
-  // P as this receiver JOINED it: the worker is configured from
-  // TrackSessionConfig.joinedRepairCount, the sum of repairSymbols over the
-  // joined base layers. Not the catalog total, which a receiver on a clean path
-  // does not receive, and never including a keyframe overlay (separate FEC
-  // instance with its own RSB_length).
-  params['x-bc-fec-p'] = cfg.repairCount
-  params['x-bc-fec-recovery'] = parseFloat((stats.recoveryRate / 100).toFixed(4))
-
-  return params
-}
-
-/** Build transport vendor keys from a TransportSnapshot. */
-function buildTransportParams(snap: TransportSnapshot | undefined): CmcdParams {
-  if (!snap) return {}
-
-  const params: CmcdParams = {}
-  params['x-bc-transport'] = snap.transport
-
-  if (snap.multicastGroup != null) {
-    params['x-bc-multicast-group'] = snap.multicastGroup
-  }
-  if (snap.multicastSource != null) {
-    params['x-bc-multicast-source'] = snap.multicastSource
-  }
-  if (snap.amtRelay != null) {
-    params['x-bc-amt-relay'] = snap.amtRelay
-  }
-
-  return params
+/** RFC 8941 §3.3.3 string: printable ASCII, `\` and `"` escaped. */
+function sfString(value: string): string {
+  return `"${value.replace(/[^\x20-\x7e]/g, '').replace(/[\\"]/g, '\\$&')}"`
 }
 
-// ---------------------------------------------------------------------------
-// Query-string serialization (RFC 9559 §2)
-// ---------------------------------------------------------------------------
-
-/**
- * Serialize CmcdParams to RFC 9559 query-string format.
- * Keys sorted for deterministic output. String values sanitized.
- */
-function formatQueryString(params: CmcdParams): string {
-  return Object.keys(params)
+/** Encode one record as an RFC 8941 dictionary with keys in alphabetical order. */
+export function encodeCmcdRecord(record: CmcdRecord): string {
+  return Object.keys(record)
     .sort()
     .map(key => {
-      const v = params[key]
-      if (typeof v === 'string') return `${key}=${sanitize(v)}`
-      return `${key}=${v}`
+      const value = record[key]
+      if (typeof value === 'number') return `${key}=${value}`
+      if (typeof value === 'string') return `${key}=${sfString(value)}`
+      if (Array.isArray(value)) return `${key}=(${value.map(sfString).join(' ')})`
+      return `${key}=${(value as CmcdToken).token}`
     })
     .join(',')
 }
 
+const token = (value: string): CmcdToken => ({ token: value })
+
+/** Set a custom key, numbers as strings; drop anything absent or over 64 characters. */
+function putCustom(record: CmcdRecord, name: string, value: string | number | CmcdToken | undefined): void {
+  if (value === undefined) return
+  if (typeof value === 'number') value = String(value)
+  if (typeof value === 'string' && value.length > MAX_CUSTOM_VALUE) return
+  record[CUSTOM_PREFIX + name] = value
+}
+
 // ---------------------------------------------------------------------------
 // CmcdProducer
 // ---------------------------------------------------------------------------
 
 export class CmcdProducer {
-  #onCmcdParams: ((params: CmcdParams) => void) | undefined
-  #onCmcdPost: ((payload: string) => void) | undefined
+  #onCmcdPost: ((body: string) => void) | undefined
+  #intervalMs: number
+  #sessionId: string
+  #now: () => number
+  #sn = 0
+  #lastHeartbeat: number | null = null
+
   #transport: TransportSnapshot | undefined
   #lastStats: FecTrackStats | undefined
-  // Phase 14 state — Plan 03 Task 2 (D-12, D-15).
   #playMode: PlayMode | null = null
   #deltaFailRate: number | null = null
   #switchMiscount = 0
   #manifestStats: ManifestVerificationStats | null = null
   #fecFailClosed: FecFailClosedReason | null = null
+  /** Video-block resolutions from the repair lifecycle; null until the player feeds one. */
+  #lifecycle: { inband: number; fetch: number; failedKeyframe: number } | null = null
 
   constructor(options: CmcdProducerOptions) {
-    this.#onCmcdParams = options.onCmcdParams
     this.#onCmcdPost = options.onCmcdPost
+    this.#intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS
+    if (!Number.isFinite(this.#intervalMs) || this.#intervalMs <= 0) {
+      throw new Error(`[CmcdProducer] invalid intervalMs "${String(options.intervalMs)}"; expected a positive number`)
+    }
+    this.#sessionId = options.sessionId ?? globalThis.crypto.randomUUID()
+    this.#now = options.now ?? Date.now
   }
 
   /** Update the stored transport state. Called by player wiring layer. */
@@ -177,9 +184,8 @@ export class CmcdProducer {
   }
 
   /**
-   * Set the current play-mode. Emitted as `x-bc-play-mode` on subsequent
-   * snapshots. Throws on any value outside {'full','base-only','single-track'}
-   * (CLAUDE.md: error on bad init).
+   * Set the current play-mode, reported as `com.blockcast-pm`. Throws on any
+   * value outside {'full','base-only','single-track'} (CLAUDE.md: error on bad init).
    */
   updatePlayMode(mode: PlayMode): void {
     if (typeof mode !== 'string' || !PLAY_MODES.includes(mode as PlayMode)) {
@@ -191,9 +197,8 @@ export class CmcdProducer {
   }
 
   /**
-   * Set the delta-track FEC block-failure rate (0..1 inclusive). Emitted as
-   * `x-bc-delta-fail-rate` on snapshots when play-mode is 'full' or 'base-only'.
-   * Omitted on single-track streams.
+   * Set the delta-track FEC block-failure rate (0..1 inclusive), reported as
+   * `com.blockcast-dfr` when play-mode is 'full' or 'base-only'.
    */
   updateDeltaFailRate(rate: number): void {
     if (typeof rate !== 'number' || !Number.isFinite(rate) || rate < 0 || rate > 1) {
@@ -204,22 +209,22 @@ export class CmcdProducer {
     this.#deltaFailRate = rate
   }
 
-  /**
-   * Bump the cumulative switching-set misalignment counter. Emitted as
-   * `x-bc-switch-miscount` on snapshots when the counter is > 0.
-   */
+  /** Bump the cumulative switching-set misalignment counter (`com.blockcast-sm`). */
   incrementSwitchMiscount(): void {
     this.#switchMiscount += 1
   }
 
   /**
-   * Record that FEC failed closed at runtime (fec-01 6.3.9). Every later
-   * snapshot carries `x-bc-fec-fail-closed` (the reason code) and
-   * `x-bc-fec-fail-layer` (the held layer i whose total B_i was undercut), so a
-   * stream playing without FEC is told apart from one with no loss.
+   * Record that FEC failed closed at runtime (fec-01 6.3.9). Reported at once
+   * as `e=e` with the reason code in `ec`, and on every later counter report
+   * as `com.blockcast-ffc` / `com.blockcast-ffl` (the held layer whose total
+   * B_i was undercut), so a stream playing without FEC is told apart from one
+   * with no loss.
    */
   updateFecFailClosed(reason: FecFailClosedReason): void {
+    const changed = this.#fecFailClosed?.code !== reason.code || this.#fecFailClosed?.layer !== reason.layer
     this.#fecFailClosed = reason
+    if (changed) this.#post([{ ...this.#base('e'), ec: [reason.code] }])
   }
 
   updateManifestVerification(stats: ManifestVerificationStats): void {
@@ -227,124 +232,129 @@ export class CmcdProducer {
   }
 
   /**
-   * One-shot emit of `x-bc-switch-drift-us` for a single misalignment event.
-   * Does NOT mutate snapshot state — subsequent onSnapshot() calls will not
-   * include the drift key until the next emitSwitchDrift(). Mirrors the
-   * existing onTransition() pattern.
+   * Count a video block's resolution from the repair lifecycle: recovered in
+   * band (`com.blockcast-fbr`), recovered by repair FETCH (`-fbq`), or failed
+   * as a keyframe-class block (`-fbfk`). Audio blocks are not counted, matching
+   * the video-track `-fbf`. Until the player feeds this, the three are absent.
    */
+  onRepairLifecycle(event: RepairLifecycleEvent): void {
+    this.#lifecycle ??= { inband: 0, fetch: 0, failedKeyframe: 0 }
+    if (event.type === 'recovered' && event.blockClass !== 'audio') {
+      if (event.via === 'inband') this.#lifecycle.inband++
+      else this.#lifecycle.fetch++
+    } else if (event.type === 'failed' && event.blockClass === 'keyframe') {
+      this.#lifecycle.failedKeyframe++
+    }
+  }
+
+  /** One-shot custom event `com.blockcast-switch-drift` for a single misalignment. */
   emitSwitchDrift(driftUs: number): void {
-    if (
-      typeof driftUs !== 'number' ||
-      !Number.isFinite(driftUs) ||
-      driftUs < 0
-    ) {
+    if (typeof driftUs !== 'number' || !Number.isFinite(driftUs) || driftUs < 0) {
       throw new Error(
         `[CmcdProducer] invalid drift-us "${String(driftUs)}"; expected a non-negative finite number`,
       )
     }
-    const params: CmcdParams = {}
-    if (this.#lastStats) Object.assign(params, buildFecParams(this.#lastStats))
-    Object.assign(params, buildTransportParams(this.#transport))
-    if (this.#switchMiscount > 0) params['x-bc-switch-miscount'] = this.#switchMiscount
-    params['x-bc-switch-drift-us'] = driftUs
-    this.#emit(params)
+    const record: CmcdRecord = { ...this.#base('ce'), cen: CUSTOM_PREFIX + 'switch-drift' }
+    putCustom(record, 'sdu', Math.round(driftUs))
+    this.#post([record])
   }
 
-  /**
-   * Process a FecTrackStats snapshot. Finds the video track, builds
-   * x-bc-* vendor keys, and fires both delivery callbacks.
-   */
+  /** Take a FecTrackStats snapshot (first video track) and send the heartbeat when due. */
   onSnapshot(data: SnapshotData): void {
-    // Find first video track; skip if none
     const videoTrack = data.tracks.find(t => t.config.trackType === 'video')
     if (!videoTrack) return
-
     this.#lastStats = videoTrack
-
-    const params: CmcdParams = {
-      ...buildFecParams(videoTrack),
-      ...buildTransportParams(this.#transport),
-    }
-
-    if (this.#playMode !== null) {
-      params['x-bc-play-mode'] = this.#playMode
-    }
-
-    if (this.#fecFailClosed) {
-      params['x-bc-fec-fail-closed'] = this.#fecFailClosed.code
-      params['x-bc-fec-fail-layer'] = this.#fecFailClosed.layer
-    }
-
-    // Delta-fail-rate is only meaningful when a delta track exists.
-    if (
-      this.#playMode !== null &&
-      this.#playMode !== 'single-track' &&
-      this.#deltaFailRate !== null
-    ) {
-      params['x-bc-delta-fail-rate'] = parseFloat(this.#deltaFailRate.toFixed(4))
-    }
-
-    if (this.#switchMiscount > 0) {
-      params['x-bc-switch-miscount'] = this.#switchMiscount
-    }
-    if (this.#manifestStats) {
-      params['x-bc-manifest-verified'] = this.#manifestStats.verified > 0
-      params['x-bc-manifest-failures'] = Object.values(this.#manifestStats.failures)
-        .reduce((total, count) => total + count, 0)
-    }
-
-    this.#emit(params)
+    this.#heartbeat()
   }
 
   /**
-   * Emit transport state without inventing FEC metrics. Cadence is owned by
-   * the caller because only the transport integration knows when state changed.
+   * Take transport state for receivers that do not own FEC stats, and send the
+   * heartbeat when due.
    */
   onTransportSnapshot(data: TransportOnlySnapshotData): void {
     if (!Number.isFinite(data.timestampMs) || data.timestampMs < 0) {
       throw new Error('[CmcdProducer] transport snapshot timestamp must be a non-negative finite number')
     }
     if (data.playMode !== undefined) this.updatePlayMode(data.playMode)
-    if (
-      data.switchMiscount !== undefined &&
-      (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0)
-    ) {
-      throw new Error('[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer')
+    if (data.switchMiscount !== undefined) {
+      if (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0) {
+        throw new Error('[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer')
+      }
+      this.#switchMiscount = data.switchMiscount
     }
-
     this.#transport = data.transport
-    const params = buildTransportParams(data.transport)
-    if (this.#playMode !== null) params['x-bc-play-mode'] = this.#playMode
-    const switchMiscount = data.switchMiscount ?? this.#switchMiscount
-    if (switchMiscount > 0) params['x-bc-switch-miscount'] = switchMiscount
-    this.#emit(params)
+    this.#heartbeat()
   }
 
-  /**
-   * Signal a transport transition event. Fires an immediate out-of-band
-   * emit with x-bc-ct set. The subsequent onSnapshot() will NOT include
-   * x-bc-ct (one-shot).
-   */
+  /** Report a transport transition at once, as custom event `com.blockcast-ct`. */
   onTransition(event: TransportTransitionEvent): void {
-    const params: CmcdParams = {}
+    const record: CmcdRecord = { ...this.#base('ce'), cen: CUSTOM_PREFIX + 'ct' }
+    putCustom(record, 'ct', token(event))
+    this.#putTransport(record)
+    this.#post([record])
+  }
 
-    // Include last known FEC stats if available
-    if (this.#lastStats) {
-      Object.assign(params, buildFecParams(this.#lastStats))
-    }
+  #base(event: string): CmcdRecord {
+    return { e: token(event), sid: this.#sessionId, sn: this.#sn++, ts: Math.floor(this.#now()), v: 2 }
+  }
 
-    // Include transport state if available
-    Object.assign(params, buildTransportParams(this.#transport))
+  #heartbeat(): void {
+    const now = this.#now()
+    if (this.#lastHeartbeat !== null && now - this.#lastHeartbeat < this.#intervalMs) return
+    this.#lastHeartbeat = now
+    this.#post([this.#base('t'), this.#counters()])
+  }
 
-    // Add the transition event key (one-shot)
-    params['x-bc-ct'] = event
+  #putTransport(record: CmcdRecord): void {
+    const snap = this.#transport
+    if (!snap) return
+    putCustom(record, 'tr', token(TRANSPORT_TOKEN[snap.transport]))
+    if (snap.multicastGroup != null && snap.multicastSource != null) {
+      putCustom(record, 'sg', `${snap.multicastGroup}@${snap.multicastSource}`)
+    }
+    putCustom(record, 'ar', snap.amtRelay)
+  }
 
-    this.#emit(params)
+  /** The `e=ce` counter report. */
+  #counters(): CmcdRecord {
+    const record: CmcdRecord = { ...this.#base('ce'), cen: CUSTOM_PREFIX + 'fec' }
+    const stats = this.#lastStats
+    if (stats) {
+      putCustom(record, 'fa', stats.config.algorithm)
+      putCustom(record, 'fk', stats.config.k)
+      // P as this receiver JOINED it: the sum of repairSymbols over the joined
+      // base layers, never including a keyframe overlay.
+      putCustom(record, 'fp', stats.config.repairCount)
+      putCustom(record, 'pr', stats.sourceSymbols)
+      putCustom(record, 'pl', stats.sourcePacketsMissing)
+      putCustom(record, 'pu', stats.sourcePacketsUnrecovered)
+      putCustom(record, 'fbf', stats.blocksFailed)
+    }
+    if (this.#lifecycle) {
+      putCustom(record, 'fbr', this.#lifecycle.inband)
+      putCustom(record, 'fbq', this.#lifecycle.fetch)
+      putCustom(record, 'fbfk', this.#lifecycle.failedKeyframe)
+    }
+    this.#putTransport(record)
+    if (this.#playMode !== null) {
+      putCustom(record, 'pm', token(this.#playMode))
+      if (this.#playMode !== 'single-track' && this.#deltaFailRate !== null) {
+        putCustom(record, 'dfr', this.#deltaFailRate.toFixed(3))
+      }
+    }
+    if (this.#fecFailClosed) {
+      putCustom(record, 'ffc', token(this.#fecFailClosed.code))
+      putCustom(record, 'ffl', this.#fecFailClosed.layer)
+    }
+    if (this.#switchMiscount > 0) putCustom(record, 'sm', this.#switchMiscount)
+    if (this.#manifestStats) {
+      putCustom(record, 'mv', this.#manifestStats.verified)
+      putCustom(record, 'mf', Object.values(this.#manifestStats.failures).reduce((a, b) => a + b, 0))
+    }
+    return record
   }
 
-  /** Fire both delivery callbacks with the given params. */
-  #emit(params: CmcdParams): void {
-    this.#onCmcdParams?.(params)
-    this.#onCmcdPost?.(formatQueryString(params))
+  #post(records: CmcdRecord[]): void {
+    this.#onCmcdPost?.(records.map(encodeCmcdRecord).join('\n'))
   }
 }