@blockcast/mmt-container 0.3.0 → 0.4.0-main.1e94b11199ea

package/src/delivery-catalog.ts

@@ -0,0 +1,498 @@
+/**
+ * Strict v2 multicast delivery catalog: the DASH/HLS/MMTP routes a receiver
+ * joins, their SSM endpoints, FEC geometry and MMTP packet-ID bindings.
+ *
+ * Moved from moqtail-private `libs/moqtail-ts/src/model/catalog/delivery.ts`
+ * (BLO-47003) so every player reads one contract. Two rules are stricter than
+ * the copy it replaces, both libmmt invariants rather than local choices:
+ * `fec.blockProfile` is required and must be `iso-ssbg1-v1` (BLO-35597), and a
+ * DASH route's `mmtp.packetId` is refused when it is the signaling flow 0
+ * (`isMulticastTrackPacketId`).
+ */
+import { parseFecBlockProfile, type FecBlockProfile } from '@blockcast/mmt-base'
+import { isMulticastTrackPacketId } from '@blockcast/mmt-transport'
+
+export type DeliveryPackaging = 'mmtp' | 'dash' | 'hls'
+export type DeliveryContentType = 'video' | 'audio' | 'text'
+
+export interface DeliveryEndpoint {
+  source: string
+  group: string
+  port: number
+}
+
+export interface DeliveryPolicy {
+  bufferWindowSegments: number
+  requestTimeoutMs: number
+  missPolicy: 'fail'
+}
+
+export interface DeliveryObjectMapping {
+  namespace: string
+  initObject: string
+  mediaObjectTemplate: string
+}
+
+export interface DeliveryFec {
+  K: number
+  /** Repair symbols per source block. Zero means source-only delivery. */
+  P: number
+  T: number
+  /** Full FEC block span in milliseconds (draft-ramadan-moq-fec §5.1). */
+  interleaveDepthMs: number
+  /**
+   * The catalog `fec.blockProfile` (BLO-35597). Required and never
+   * defaulted; `parseFecBlockProfile` refuses anything but `iso-ssbg1-v1`,
+   * including the retired `k-padded-v1`.
+   */
+  blockProfile: FecBlockProfile
+}
+
+export interface DeliveryRouteBase {
+  id: string
+  contentType: DeliveryContentType
+  endpointRef: string
+  initUri: string
+  mediaUriTemplate: string
+  objects: DeliveryObjectMapping
+  fec: DeliveryFec
+}
+
+export interface DashDeliveryRoute extends DeliveryRouteBase {
+  representationId: string
+  /**
+   * Authoritative MMTP binding used to assemble the DASH objects carried by
+   * this route. The current source accepts MFU-mode MMTP only; the init MPU is
+   * the representation init segment. MMTP-backed DASH URI and object templates
+   * contain exactly one $Number$ and may also contain $RepresentationID$;
+   * $Time$ is rejected because the catalog has no publisher-authored first-time
+   * anchor. Publishers explicitly anchor MMTP MPU sequence numbers to DASH
+   * $Number$ values so receivers never infer object boundaries from cadence.
+   */
+  mmtp: {
+    trackName: string
+    packetId: number
+    mode: 'mfu'
+    codec: string
+    /** fMP4 media timescale used by Shaka's MMTP transmuxer. */
+    timescale: number
+    /** Exact duration of one MFU in that timescale, from publisher timing. */
+    mediaUnitDurationTicks: number
+    /** Exact MFU count carried by each numbered DASH media object. */
+    mediaUnitsPerObject: number
+    /** First publisher MMTP MPU sequence represented by this route. */
+    firstMpuSequenceNumber: number
+    /** DASH $Number$ containing firstMpuSequenceNumber. */
+    firstObjectNumber: number
+    /** Consecutive MMTP MPU sequence numbers carried by each DASH object. */
+    mpuSequencesPerObject: number
+    /** Optional reliable repair-track name under objects.namespace. */
+    repairTrack?: string
+  }
+}
+
+export interface HlsDeliveryRoute extends DeliveryRouteBase {
+  variantId: string
+  trackId: string
+}
+
+export interface MmtpDeliveryRoute extends DeliveryRouteBase {
+  trackName: string
+}
+
+export interface DashDeliveryConfig {
+  manifestUrl: string
+  routes: DashDeliveryRoute[]
+}
+
+export interface HlsDeliveryConfig {
+  manifestUrl: string
+  routes: HlsDeliveryRoute[]
+}
+
+export interface MmtpDeliveryConfig {
+  routes: MmtpDeliveryRoute[]
+}
+
+export interface DeliveryMulticastBase {
+  endpoints: Record<string, DeliveryEndpoint>
+  deliveryPolicy: DeliveryPolicy
+}
+
+export type DeliveryMulticastV2 = DeliveryMulticastBase &
+  (
+    | { packaging: 'dash'; dash: DashDeliveryConfig }
+    | { packaging: 'hls'; hls: HlsDeliveryConfig }
+    | { packaging: 'mmtp'; mmtp: MmtpDeliveryConfig }
+  )
+
+export interface DeliveryCatalogV2 {
+  schemaVersion: 2
+  channelId: string
+  multicast: DeliveryMulticastV2
+}
+
+const TEMPLATE_VARIABLE = /\$([A-Za-z][A-Za-z0-9]*)\$/g
+const ALLOWED_TEMPLATE_VARIABLES = new Set(['Number', 'Time', 'RepresentationID', 'VariantID', 'TrackID'])
+
+function object(value: unknown, path: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new Error(`${path} must be an object`)
+  }
+  return value as Record<string, unknown>
+}
+
+function string(value: unknown, path: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new Error(`${path} must be a non-empty string`)
+  }
+  return value
+}
+
+function positiveInteger(value: unknown, path: string): number {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
+    throw new Error(`${path} must be a positive integer`)
+  }
+  return value
+}
+
+function nonNegativeInteger(value: unknown, path: string): number {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${path} must be a non-negative integer`)
+  }
+  return value
+}
+
+function nonNegativeSafeInteger(value: unknown, path: string): number {
+  const parsed = nonNegativeInteger(value, path)
+  if (!Number.isSafeInteger(parsed)) throw new Error(`${path} must be a safe integer`)
+  return parsed
+}
+
+function mpuSequenceNumber(value: unknown, path: string): number {
+  const parsed = nonNegativeSafeInteger(value, path)
+  if (parsed > 0xffffffff) throw new Error(`${path} must be between 0 and 4294967295`)
+  return parsed
+}
+
+function port(value: unknown, path: string): number {
+  const parsed = positiveInteger(value, path)
+  if (parsed > 65535) throw new Error(`${path} must be between 1 and 65535`)
+  return parsed
+}
+
+function httpUrl(value: unknown, path: string): string {
+  const raw = string(value, path)
+  let parsed: URL
+  try {
+    parsed = new URL(raw)
+  } catch {
+    throw new Error(`${path} must be an absolute HTTP(S) URL`)
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error(`${path} must be an absolute HTTP(S) URL`)
+  }
+  return raw
+}
+
+function templateVariables(template: string, path: string): Set<string> {
+  const variables = new Set<string>()
+  for (const match of template.matchAll(TEMPLATE_VARIABLE)) {
+    const variable = match[1]
+    if (variable === undefined || !ALLOWED_TEMPLATE_VARIABLES.has(variable)) {
+      throw new Error(`${path} contains unsupported template variable $${variable ?? ''}$`)
+    }
+    variables.add(variable)
+  }
+  if (template.includes('$') && template.replace(TEMPLATE_VARIABLE, '').includes('$')) {
+    throw new Error(`${path} contains a malformed template variable`)
+  }
+  return variables
+}
+
+function validateTemplatePair(mediaUriTemplate: string, mediaObjectTemplate: string, path: string): void {
+  const uriVariables = templateVariables(mediaUriTemplate, `${path}.mediaUriTemplate`)
+  const objectVariables = templateVariables(mediaObjectTemplate, `${path}.objects.mediaObjectTemplate`)
+  if (uriVariables.size === 0) {
+    throw new Error(`${path}.mediaUriTemplate must contain a segment template variable`)
+  }
+  if (
+    uriVariables.size !== objectVariables.size ||
+    [...uriVariables].some((variable) => !objectVariables.has(variable))
+  ) {
+    throw new Error(`${path} URI and object templates must use the same variables`)
+  }
+}
+
+function validateMmtpDashTemplate(template: string, path: string): void {
+  const variables = [...template.matchAll(TEMPLATE_VARIABLE)].map((match) => match[1])
+  const unsupported = variables.find((variable) => variable !== 'Number' && variable !== 'RepresentationID')
+  if (unsupported !== undefined) {
+    throw new Error(`${path} contains unsupported MMTP-backed DASH template variable $${unsupported}$`)
+  }
+  if (variables.filter((variable) => variable === 'Number').length !== 1) {
+    throw new Error(`${path} must contain exactly one $Number$ for MMTP-backed DASH`)
+  }
+}
+
+function validateMmtpDashTemplates(route: DeliveryRouteBase, path: string): void {
+  validateMmtpDashTemplate(route.mediaUriTemplate, `${path}.mediaUriTemplate`)
+  validateMmtpDashTemplate(route.objects.mediaObjectTemplate, `${path}.objects.mediaObjectTemplate`)
+}
+
+function validateEndpoint(value: unknown, path: string): DeliveryEndpoint {
+  const endpoint = object(value, path)
+  return {
+    source: string(endpoint['source'], `${path}.source`),
+    group: string(endpoint['group'], `${path}.group`),
+    port: port(endpoint['port'], `${path}.port`),
+  }
+}
+
+function validateEndpoints(value: unknown): Record<string, DeliveryEndpoint> {
+  const endpoints = object(value, 'multicast.endpoints')
+  const entries = Object.entries(endpoints)
+  if (entries.length === 0) throw new Error('multicast.endpoints must not be empty')
+  return Object.fromEntries(
+    entries.map(([id, endpoint]) => [
+      string(id, 'multicast endpoint id'),
+      validateEndpoint(endpoint, `multicast.endpoints.${id}`),
+    ]),
+  )
+}
+
+function validateDeliveryPolicy(value: unknown): DeliveryPolicy {
+  const policy = object(value, 'multicast.deliveryPolicy')
+  const missPolicy = policy['missPolicy']
+  if (missPolicy !== 'fail') {
+    throw new Error("multicast.deliveryPolicy.missPolicy must be 'fail'")
+  }
+  return {
+    bufferWindowSegments: positiveInteger(
+      policy['bufferWindowSegments'],
+      'multicast.deliveryPolicy.bufferWindowSegments',
+    ),
+    requestTimeoutMs: positiveInteger(policy['requestTimeoutMs'], 'multicast.deliveryPolicy.requestTimeoutMs'),
+    missPolicy,
+  }
+}
+
+function validateRouteBase(
+  value: unknown,
+  path: string,
+  endpoints: Record<string, DeliveryEndpoint>,
+): DeliveryRouteBase {
+  const route = object(value, path)
+  const endpointRef = string(route['endpointRef'], `${path}.endpointRef`)
+  if (!(endpointRef in endpoints)) throw new Error(`${path}.endpointRef does not resolve: ${endpointRef}`)
+
+  const objects = object(route['objects'], `${path}.objects`)
+  const fec = object(route['fec'], `${path}.fec`)
+  if ('interleaveDepth' in fec || 'interleaveMs' in fec) {
+    throw new Error(`${path}.fec.interleaveDepthMs is the only supported interleave field`)
+  }
+  const mediaUriTemplate = httpUrl(route['mediaUriTemplate'], `${path}.mediaUriTemplate`)
+  const mediaObjectTemplate = string(objects['mediaObjectTemplate'], `${path}.objects.mediaObjectTemplate`)
+  validateTemplatePair(mediaUriTemplate, mediaObjectTemplate, path)
+
+  return {
+    id: string(route['id'], `${path}.id`),
+    contentType: validateContentType(route['contentType'], `${path}.contentType`),
+    endpointRef,
+    initUri: httpUrl(route['initUri'], `${path}.initUri`),
+    mediaUriTemplate,
+    objects: {
+      namespace: string(objects['namespace'], `${path}.objects.namespace`),
+      initObject: string(objects['initObject'], `${path}.objects.initObject`),
+      mediaObjectTemplate,
+    },
+    fec: {
+      K: positiveInteger(fec['K'], `${path}.fec.K`),
+      P: nonNegativeInteger(fec['P'], `${path}.fec.P`),
+      T: positiveInteger(fec['T'], `${path}.fec.T`),
+      interleaveDepthMs: positiveInteger(fec['interleaveDepthMs'], `${path}.fec.interleaveDepthMs`),
+      blockProfile: parseFecBlockProfile(fec['blockProfile'], `${path}.fec.blockProfile`),
+    },
+  }
+}
+
+function validateContentType(value: unknown, path: string): DeliveryContentType {
+  if (value !== 'video' && value !== 'audio' && value !== 'text') {
+    throw new Error(`${path} must be 'video', 'audio', or 'text'`)
+  }
+  return value
+}
+
+function templateShape(template: string): string {
+  return template.replace(TEMPLATE_VARIABLE, '$variable$')
+}
+
+function validateRouteUniqueness(
+  routes: DeliveryRouteBase[],
+  selectorKeys: string[],
+  rawRoutes: Record<string, unknown>[],
+): void {
+  const ids = new Set<string>()
+  const selectors = new Set<string>()
+  const initUris = new Set<string>()
+  const mediaShapes = new Set<string>()
+  routes.forEach((route, index) => {
+    if (ids.has(route.id)) throw new Error(`duplicate route id: ${route.id}`)
+    ids.add(route.id)
+
+    const selector = selectorKeys.map((key) => String(rawRoutes[index]?.[key])).join('\u0000')
+    if (selectors.has(selector)) throw new Error(`duplicate route selector: ${selectorKeys.join(', ')}`)
+    selectors.add(selector)
+
+    if (initUris.has(route.initUri)) throw new Error(`ambiguous init URI mapping: ${route.initUri}`)
+    initUris.add(route.initUri)
+
+    const mediaShape = templateShape(route.mediaUriTemplate)
+    if (mediaShapes.has(mediaShape)) {
+      throw new Error(`ambiguous media URI mapping: ${route.mediaUriTemplate}`)
+    }
+    mediaShapes.add(mediaShape)
+  })
+}
+
+function validateRoutes(value: unknown, kind: 'dash', endpoints: Record<string, DeliveryEndpoint>): DashDeliveryRoute[]
+function validateRoutes(value: unknown, kind: 'hls', endpoints: Record<string, DeliveryEndpoint>): HlsDeliveryRoute[]
+function validateRoutes(value: unknown, kind: 'mmtp', endpoints: Record<string, DeliveryEndpoint>): MmtpDeliveryRoute[]
+function validateRoutes(
+  value: unknown,
+  kind: DeliveryPackaging,
+  endpoints: Record<string, DeliveryEndpoint>,
+): (DashDeliveryRoute | HlsDeliveryRoute | MmtpDeliveryRoute)[] {
+  if (!Array.isArray(value) || value.length === 0) throw new Error(`multicast.${kind}.routes must not be empty`)
+  const rawRoutes = value.map((route, index) => object(route, `multicast.${kind}.routes[${index}]`))
+  const routes = rawRoutes.map((route, index) => {
+    const path = `multicast.${kind}.routes[${index}]`
+    const base = validateRouteBase(route, path, endpoints)
+    if (kind === 'dash') {
+      validateMmtpDashTemplates(base, path)
+      const mmtp = object(route['mmtp'], `${path}.mmtp`)
+      if (mmtp['mode'] !== 'mfu') throw new Error(`${path}.mmtp.mode must be 'mfu'`)
+      const mode = 'mfu' as const
+      const packetId = mmtp['packetId']
+      if (!isMulticastTrackPacketId(packetId)) {
+        throw new Error(`${path}.mmtp.packetId must be an integer from 1 to 65535 (0 is the MMTP signaling flow)`)
+      }
+      const repairTrack = mmtp['repairTrack']
+      if (repairTrack !== undefined && (typeof repairTrack !== 'string' || repairTrack.trim().length === 0)) {
+        throw new Error(`${path}.mmtp.repairTrack must be a non-empty string when provided`)
+      }
+      const mediaUnitsPerObject = positiveInteger(mmtp['mediaUnitsPerObject'], `${path}.mmtp.mediaUnitsPerObject`)
+      const firstMpuSequenceNumber = mpuSequenceNumber(
+        mmtp['firstMpuSequenceNumber'],
+        `${path}.mmtp.firstMpuSequenceNumber`,
+      )
+      const firstObjectNumber = nonNegativeSafeInteger(mmtp['firstObjectNumber'], `${path}.mmtp.firstObjectNumber`)
+      const mpuSequencesPerObject = positiveInteger(mmtp['mpuSequencesPerObject'], `${path}.mmtp.mpuSequencesPerObject`)
+      if (mpuSequencesPerObject > mediaUnitsPerObject) {
+        throw new Error(`${path}.mmtp.mpuSequencesPerObject must not exceed mediaUnitsPerObject`)
+      }
+      if (firstMpuSequenceNumber + mpuSequencesPerObject - 1 > 0xffffffff) {
+        throw new Error(`${path}.mmtp first object exceeds the MMTP MPU sequence-number range`)
+      }
+      return {
+        ...base,
+        representationId: string(route['representationId'], `${path}.representationId`),
+        mmtp: {
+          trackName: string(mmtp['trackName'], `${path}.mmtp.trackName`),
+          packetId,
+          mode,
+          codec: string(mmtp['codec'], `${path}.mmtp.codec`),
+          timescale: positiveInteger(mmtp['timescale'], `${path}.mmtp.timescale`),
+          mediaUnitDurationTicks: positiveInteger(
+            mmtp['mediaUnitDurationTicks'],
+            `${path}.mmtp.mediaUnitDurationTicks`,
+          ),
+          mediaUnitsPerObject,
+          firstMpuSequenceNumber,
+          firstObjectNumber,
+          mpuSequencesPerObject,
+          ...(repairTrack === undefined ? {} : { repairTrack }),
+        },
+      }
+    }
+    if (kind === 'hls') {
+      return {
+        ...base,
+        variantId: string(route['variantId'], `${path}.variantId`),
+        trackId: string(route['trackId'], `${path}.trackId`),
+      }
+    }
+    return { ...base, trackName: string(route['trackName'], `${path}.trackName`) }
+  })
+  validateRouteUniqueness(
+    routes,
+    kind === 'dash' ? ['representationId', 'contentType'] : kind === 'hls' ? ['variantId', 'trackId'] : ['trackName'],
+    rawRoutes,
+  )
+  return routes
+}
+
+function validateV2Catalog(value: unknown): DeliveryCatalogV2 {
+  const catalog = object(value, 'catalog')
+  if (catalog['schemaVersion'] !== 2) throw new Error('catalog.schemaVersion must be 2')
+  const multicast = object(catalog['multicast'], 'multicast')
+  const packaging = multicast['packaging']
+  if (packaging !== 'dash' && packaging !== 'hls' && packaging !== 'mmtp') {
+    throw new Error("multicast.packaging must be 'dash', 'hls', or 'mmtp'")
+  }
+  const endpoints = validateEndpoints(multicast['endpoints'])
+  const deliveryPolicy = validateDeliveryPolicy(multicast['deliveryPolicy'])
+  const common = {
+    schemaVersion: 2 as const,
+    channelId: string(catalog['channelId'], 'catalog.channelId'),
+  }
+
+  if (packaging === 'dash') {
+    const dash = object(multicast['dash'], 'multicast.dash')
+    return {
+      ...common,
+      multicast: {
+        packaging,
+        endpoints,
+        deliveryPolicy,
+        dash: {
+          manifestUrl: httpUrl(dash['manifestUrl'], 'multicast.dash.manifestUrl'),
+          routes: validateRoutes(dash['routes'], packaging, endpoints),
+        },
+      },
+    }
+  }
+  if (packaging === 'hls') {
+    const hls = object(multicast['hls'], 'multicast.hls')
+    return {
+      ...common,
+      multicast: {
+        packaging,
+        endpoints,
+        deliveryPolicy,
+        hls: {
+          manifestUrl: httpUrl(hls['manifestUrl'], 'multicast.hls.manifestUrl'),
+          routes: validateRoutes(hls['routes'], packaging, endpoints),
+        },
+      },
+    }
+  }
+  const mmtp = object(multicast['mmtp'], 'multicast.mmtp')
+  return {
+    ...common,
+    multicast: {
+      packaging,
+      endpoints,
+      deliveryPolicy,
+      mmtp: { routes: validateRoutes(mmtp['routes'], packaging, endpoints) },
+    },
+  }
+}
+
+/** Parse and normalize the strict v2 delivery-catalog contract. */
+export function normalizeDeliveryCatalog(value: unknown): DeliveryCatalogV2 {
+  const catalog = object(value, 'catalog')
+  if (catalog['schemaVersion'] === 2) return validateV2Catalog(catalog)
+  if (catalog['schemaVersion'] === undefined) throw new Error('catalog.schemaVersion is required')
+  throw new Error(`unsupported catalog.schemaVersion: ${String(catalog['schemaVersion'])}`)
+}

package/src/delta-fallback-config.ts

@@ -0,0 +1,72 @@
+/**
+ * Maps one base/delta switching group's catalog FEC metadata onto
+ * {@link MediaRouter.configureDelta} (BLO-45475).
+ *
+ * Generic client policy selects WHICH group to admit (roles, groups, endpoint
+ * availability); this module owns the MMTP/FEC half of that decision — the
+ * shared repair pointer and the delta block geometry — so no player re-states
+ * the catalog FEC schema. It validates and never defaults: a group whose
+ * required metadata is absent or contradictory throws, and the caller decides
+ * that such a group invalidates the catalog rather than being skipped.
+ */
+
+import { assertDeltaFallbackConfig, type DeltaFallbackConfig } from './media-router.js'
+
+/** The catalog fields this mapping reads from one base or delta track. */
+export interface DeltaFallbackTrack {
+  name: string
+  framerate?: number
+  fec?: {
+    repairTrack?: string
+    sourceSymbols?: number
+    repairSymbols?: number
+    interleaveDepthMs?: number
+    deltaFailWindowBlocks?: number
+    deltaProbeIntervalMs?: number
+  }
+}
+
+export interface ResolvedDeltaFallback {
+  /** The repair track both base and delta name; required at the endpoint. */
+  repairTrackName: string
+  config: DeltaFallbackConfig
+}
+
+/**
+ * Resolve one switching group. Throws when either track omits
+ * `fec.repairTrack`, when the two pointers differ, when the base framerate is
+ * not positive, or when the delta omits `fec.sourceSymbols`/`repairSymbols`.
+ * Fallback-window, probe and interleave fields are read from the base first
+ * (where the catalog places them), then the delta. The assembled config is then
+ * held to {@link assertDeltaFallbackConfig}, the same check configureDelta
+ * runs, so a group this resolves is a group configureDelta accepts — including
+ * the requirement that a probe interval or an interleave depth be present.
+ */
+export function resolveDeltaFallback(base: DeltaFallbackTrack, delta: DeltaFallbackTrack): ResolvedDeltaFallback {
+  const repair = base.fec?.repairTrack
+  if (!repair) throw new Error(`[delta-fallback] base track "${base.name}" missing fec.repairTrack`)
+  const deltaFec = delta.fec
+  if (!deltaFec?.repairTrack) throw new Error(`[delta-fallback] delta track "${delta.name}" missing fec.repairTrack`)
+  if (deltaFec.repairTrack !== repair)
+    throw new Error(
+      `[delta-fallback] inconsistent repair tracks: ${base.name} references "${repair}" but ${delta.name} references "${deltaFec.repairTrack}"`
+    )
+  if (!(typeof base.framerate === 'number' && Number.isFinite(base.framerate) && base.framerate > 0))
+    throw new Error(`[delta-fallback] base track "${base.name}" missing positive framerate`)
+  if (!(isPositive(deltaFec.sourceSymbols) && isPositive(deltaFec.repairSymbols)))
+    throw new Error(`[delta-fallback] delta track "${delta.name}" missing positive fec.sourceSymbols/repairSymbols`)
+  const config: DeltaFallbackConfig = {
+    framerate: base.framerate,
+    sourceSymbols: deltaFec.sourceSymbols,
+    repairSymbols: deltaFec.repairSymbols,
+    deltaFailWindowBlocks: base.fec?.deltaFailWindowBlocks ?? deltaFec.deltaFailWindowBlocks,
+    deltaProbeIntervalMs: base.fec?.deltaProbeIntervalMs ?? deltaFec.deltaProbeIntervalMs,
+    interleaveDepthMs: base.fec?.interleaveDepthMs ?? deltaFec.interleaveDepthMs,
+  }
+  assertDeltaFallbackConfig(config, `[delta-fallback] group ${base.name}/${delta.name}`)
+  return { repairTrackName: repair, config }
+}
+
+function isPositive(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0
+}