@blockcast/mmt-container 0.1.0 → 0.3.0-main.288475b64b3e

package/dist/block-policy.js

@@ -0,0 +1,466 @@
+// src/block-policy.ts
+import { deriveFecInterleaveDepth } from "@blockcast/mmt-fec";
+function repairPriorityForClass(blockClass) {
+  switch (blockClass) {
+    case "keyframe":
+    case "unknown":
+      return 0;
+    case "audio":
+      return 1;
+    case "delta":
+      return 2;
+  }
+}
+function exactInteger(numerator, denominator) {
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator === 0) {
+    return null;
+  }
+  const quotient = numerator / denominator;
+  const rounded = Math.round(quotient);
+  if (rounded < 1) return null;
+  const representationError = 2 * Number.EPSILON * Math.abs(quotient);
+  return Math.abs(quotient - rounded) <= representationError ? rounded : null;
+}
+function isPositiveFinite(value) {
+  return value !== void 0 && Number.isFinite(value) && value > 0;
+}
+function deriveBlockClassifierGeometry(input) {
+  if (!isPositiveFinite(input.interleaveDepthMs)) {
+    throw new Error(
+      `[BlockPolicy] interleaveDepthMs=${input.interleaveDepthMs} is not a positive block span; the catalog validator rejects this`
+    );
+  }
+  if (input.trackKind === "audio") return { trackKind: "audio" };
+  if (!isPositiveFinite(input.framerate)) {
+    return { trackKind: "video", mode: "all-protected", reason: "framerate-absent" };
+  }
+  const framerate = input.framerate;
+  let keyframeInterval;
+  if (isPositiveFinite(input.keyframeIntervalTicks) && isPositiveFinite(input.timescale)) {
+    keyframeInterval = { ticks: input.keyframeIntervalTicks, timescale: input.timescale };
+  } else if (isPositiveFinite(input.keyframeIntervalMs)) {
+    keyframeInterval = { ticks: input.keyframeIntervalMs, timescale: 1e3 };
+  } else {
+    return { trackKind: "video", mode: "all-protected", reason: "keyframe-cadence-absent" };
+  }
+  const gopFrames = exactInteger(keyframeInterval.ticks * framerate, keyframeInterval.timescale);
+  if (gopFrames === null) {
+    return {
+      trackKind: "video",
+      mode: "all-protected",
+      reason: "keyframe-interval-not-integral"
+    };
+  }
+  const frameDurationMs = 1e3 / framerate;
+  const interleaveUnits = deriveFecInterleaveDepth(input.interleaveDepthMs, frameDurationMs);
+  if (interleaveUnits >= gopFrames) {
+    return { trackKind: "video", mode: "all-protected", reason: "block-spans-gop" };
+  }
+  return {
+    trackKind: "video",
+    mode: "classifying",
+    frameDurationMs,
+    interleaveUnits,
+    gopFrames,
+    keyframeInterval
+  };
+}
+function keyframeIntervalMediaTicks(geometry, mediaTimescale) {
+  if (geometry.trackKind !== "video" || geometry.mode !== "classifying") return null;
+  if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0) return null;
+  const { ticks, timescale } = geometry.keyframeInterval;
+  if (!Number.isSafeInteger(ticks) || !Number.isSafeInteger(timescale)) return null;
+  const scaled = BigInt(ticks) * BigInt(mediaTimescale);
+  const divisor = BigInt(timescale);
+  if (scaled % divisor !== 0n) return null;
+  return scaled / divisor;
+}
+function compareDataUnitStarts(a, b) {
+  return a.movieFragment - b.movieFragment || a.idx - b.idx || a.offset - b.offset;
+}
+var BlockClassifier = class {
+  #geometry;
+  #mode;
+  #reason;
+  /**
+   * False once the stream showed that an MPU boundary does not bound its
+   * RAPs (a RAP inside an MPU, or an MPU longer than a GOP). Recorded in
+   * every mode: the stall/conceal decision relies on it even when the
+   * catalog geometry already runs the classifier `all-protected`.
+   */
+  #mpuBoundsRaps = true;
+  #blocks = /* @__PURE__ */ new Map();
+  /**
+   * P1 ledger, kept for the MPUs within the classification horizon (the
+   * highest MPU seen and the one before it): the SBN span of every source
+   * packet of each MPU, and each MPU's data-unit starts in authored order.
+   * Valid only within one continuous SBN sequence; a source discontinuity
+   * clears it (`noteSourceDiscontinuity`).
+   */
+  #mpuSbnSpans = /* @__PURE__ */ new Map();
+  #dataUnitStarts = /* @__PURE__ */ new Map();
+  #highestMpu = null;
+  /** MPU → movie_fragment_sequence_number observed in it. */
+  #mpuFragments = /* @__PURE__ */ new Map();
+  #lastRap = null;
+  constructor(geometry) {
+    this.#geometry = geometry;
+    this.#mode = "classifying";
+    this.#reason = null;
+    this.reset(geometry);
+  }
+  get geometry() {
+    return this.#geometry;
+  }
+  get mode() {
+    return this.#mode;
+  }
+  get reason() {
+    return this.#reason;
+  }
+  /**
+   * Whether "same MPU on both sides of a gap" still proves the gap held no
+   * RAP. It stops holding for the rest of the epoch once a RAP was received
+   * inside an MPU or an MPU ran longer than a GOP.
+   */
+  get mpuBoundsRaps() {
+    return this.#mpuBoundsRaps;
+  }
+  /** Begin a fresh epoch (catalog change or track reset). */
+  reset(geometry = this.#geometry) {
+    this.#geometry = geometry;
+    this.#blocks.clear();
+    this.#clearContiguityLedger();
+    this.#mpuFragments.clear();
+    this.#lastRap = null;
+    this.#mpuBoundsRaps = true;
+    if (geometry.trackKind === "video" && geometry.mode === "all-protected") {
+      this.#mode = "all-protected";
+      this.#reason = geometry.reason;
+    } else {
+      this.#mode = "classifying";
+      this.#reason = null;
+    }
+  }
+  /**
+   * Retire this classifier (its stream moves to a new catalog epoch). Every
+   * block it had classified `delta` loses the evidence behind that class and
+   * reads `unknown` from now on; the returned changes say so.
+   */
+  retire() {
+    const changes = [];
+    for (const [sbn, block] of this.#blocks) {
+      if (block.cls !== "delta") continue;
+      block.cls = "unknown";
+      changes.push({
+        kind: "reclassified",
+        sbn,
+        from: "delta",
+        to: "unknown",
+        evidence: "classifier-disabled"
+      });
+    }
+    return changes;
+  }
+  /**
+   * The stream's SBN sequence restarted (FECManager source discontinuity:
+   * a publisher restart, or the SS_ID space wrapped). Authored order and SBN
+   * order are comparable only within one continuous sequence, so the P1
+   * ledger starts again.
+   */
+  noteSourceDiscontinuity() {
+    this.#clearContiguityLedger();
+  }
+  /** Register a block that exists without evidence (a vanished block). */
+  touch(sbn) {
+    this.#blockFor(sbn);
+  }
+  /** Forget a resolved block. */
+  forget(sbn) {
+    this.#blocks.delete(sbn);
+  }
+  classOf(sbn) {
+    if (this.#geometry.trackKind === "audio") return "audio";
+    return this.#blocks.get(sbn)?.cls ?? "unknown";
+  }
+  /** Record one first-arrival source symbol's evidence for block `sbn`. */
+  observe(sbn, evidence) {
+    if (this.#geometry.trackKind === "audio") return [];
+    const changes = [];
+    const block = this.#blockFor(sbn);
+    if (evidence.rap) block.rapSeen = true;
+    if (evidence.mpu !== void 0) block.mpus.add(evidence.mpu);
+    if (evidence.idx !== void 0) {
+      block.idxMin = block.idxMin === void 0 ? evidence.idx : Math.min(block.idxMin, evidence.idx);
+      block.idxMax = block.idxMax === void 0 ? evidence.idx : Math.max(block.idxMax, evidence.idx);
+    }
+    if (evidence.rap && evidence.idx !== void 0 && evidence.idx !== 0) {
+      this.#mpuBoundsRaps = false;
+    }
+    const violation = this.#checkInvariants(sbn, block, evidence);
+    if (violation !== null) changes.push(...this.#disable(violation));
+    const next = this.#classify(block);
+    if (next !== block.cls && this.#allowed(block.cls, next)) {
+      changes.push({
+        kind: "reclassified",
+        sbn,
+        from: block.cls,
+        to: next,
+        evidence: this.#evidenceFor(block, next)
+      });
+      block.cls = next;
+    }
+    return changes;
+  }
+  /**
+   * Record a RAP frame released in order. Released MPU-start RAPs of MPUs m
+   * and m+n must be exactly n keyframe intervals apart in the media
+   * timescale, compared as integers.
+   *
+   * Comparing only consecutive MPUs would miss exactly the case the window
+   * rule cannot survive: a short MPU whose successor's RAP was lost (that
+   * RAP-bearing block is the one a wrong G calls delta), because the next
+   * released RAP then belongs to m+2. Every MPU is one interval long, so the
+   * span to any later released RAP proves or refutes all MPUs in between.
+   */
+  noteReleasedRap(mpu, presentationTime, mediaTimescale) {
+    if (this.#geometry.trackKind === "audio" || this.#mode === "all-protected") {
+      return [];
+    }
+    const interval = keyframeIntervalMediaTicks(this.#geometry, mediaTimescale);
+    if (interval === null) return this.#disable("keyframe-interval-not-media-integral");
+    const previous = this.#lastRap;
+    if (previous !== null && previous.mpu === mpu && previous.mediaTimescale === mediaTimescale) {
+      return [];
+    }
+    this.#lastRap = { mpu, presentationTime, mediaTimescale };
+    if (previous === null || mpu < previous.mpu || previous.mediaTimescale !== mediaTimescale) {
+      return [];
+    }
+    if (presentationTime - previous.presentationTime === interval * BigInt(mpu - previous.mpu)) {
+      return [];
+    }
+    return this.#disable("rap-spacing-mismatch");
+  }
+  #blockFor(sbn) {
+    let block = this.#blocks.get(sbn);
+    if (!block) {
+      block = { rapSeen: false, mpus: /* @__PURE__ */ new Set(), cls: "unknown" };
+      this.#blocks.set(sbn, block);
+    }
+    return block;
+  }
+  #checkInvariants(sbn, block, evidence) {
+    if (this.#mode === "all-protected" || this.#geometry.trackKind !== "video") return null;
+    const geometry = this.#geometry;
+    if (geometry.mode !== "classifying") return null;
+    if (evidence.rap && evidence.idx !== void 0 && evidence.idx !== 0) {
+      return "rap-not-mpu-start";
+    }
+    if (evidence.idx !== void 0 && evidence.idx >= geometry.gopFrames) {
+      return "mpu-longer-than-gop";
+    }
+    if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0 && block.idxMax - block.idxMin >= geometry.interleaveUnits) {
+      return "block-wider-than-interleave";
+    }
+    if (evidence.mpu !== void 0 && evidence.movieFragment !== void 0) {
+      const fragment = this.#mpuFragments.get(evidence.mpu);
+      if (fragment === void 0) {
+        this.#mpuFragments.set(evidence.mpu, evidence.movieFragment);
+        for (const mpu of this.#mpuFragments.keys()) {
+          if (mpu + 1 < evidence.mpu) this.#mpuFragments.delete(mpu);
+        }
+      } else if (fragment !== evidence.movieFragment) {
+        return "mpu-multiple-fragments";
+      }
+    }
+    if (evidence.mpu !== void 0 && this.#contradictsAuthoredOrder(sbn, evidence.mpu, evidence)) {
+      return "block-not-contiguous";
+    }
+    return null;
+  }
+  #clearContiguityLedger() {
+    this.#mpuSbnSpans.clear();
+    this.#dataUnitStarts.clear();
+    this.#highestMpu = null;
+  }
+  /**
+   * P1 check for one source packet of MPU `mpu` in block `sbn`, then record
+   * it. True when some recorded packet's authored order and SBN order
+   * disagree with this one's (see the class comment). Only positions the
+   * wire states are compared: MPU order for every packet, and data-unit
+   * order for packets that carry a DU header. A packet of one data unit
+   * that continues into the next block carries no DU header and so only
+   * takes part through its MPU, which is exactly what makes an adjacent
+   * straddle consistent.
+   */
+  #contradictsAuthoredOrder(sbn, mpu, evidence) {
+    for (const [other, span2] of this.#mpuSbnSpans) {
+      if (other < mpu && span2.max > sbn) return true;
+      if (other > mpu && span2.min < sbn) return true;
+    }
+    const inHorizon = this.#highestMpu === null || mpu + 1 >= this.#highestMpu;
+    let insertAt = -1;
+    let starts;
+    let start;
+    if (evidence.idx !== void 0) {
+      start = {
+        movieFragment: evidence.movieFragment ?? 0,
+        idx: evidence.idx,
+        offset: evidence.offset ?? 0,
+        sbn
+      };
+      starts = this.#dataUnitStarts.get(mpu);
+      if (starts !== void 0) {
+        let lo = 0;
+        let hi = starts.length;
+        while (lo < hi) {
+          const mid = lo + hi >>> 1;
+          if (compareDataUnitStarts(starts[mid], start) < 0) lo = mid + 1;
+          else hi = mid;
+        }
+        const at = starts[lo];
+        if (at !== void 0 && compareDataUnitStarts(at, start) === 0) {
+          if (at.sbn !== sbn) return true;
+        } else {
+          const before = starts[lo - 1];
+          if (before !== void 0 && before.sbn > sbn) return true;
+          if (at !== void 0 && at.sbn < sbn) return true;
+          insertAt = lo;
+        }
+      }
+    }
+    if (!inHorizon) return false;
+    const span = this.#mpuSbnSpans.get(mpu);
+    if (span === void 0) this.#mpuSbnSpans.set(mpu, { min: sbn, max: sbn });
+    else {
+      if (sbn < span.min) span.min = sbn;
+      if (sbn > span.max) span.max = sbn;
+    }
+    if (start !== void 0) {
+      if (starts === void 0) this.#dataUnitStarts.set(mpu, [start]);
+      else if (insertAt >= 0) starts.splice(insertAt, 0, start);
+    }
+    if (this.#highestMpu === null || mpu > this.#highestMpu) {
+      this.#highestMpu = mpu;
+      for (const other of [...this.#mpuSbnSpans.keys()]) {
+        if (other + 1 < mpu) {
+          this.#mpuSbnSpans.delete(other);
+          this.#dataUnitStarts.delete(other);
+        }
+      }
+    }
+    return false;
+  }
+  #disable(reason) {
+    if (reason === "rap-not-mpu-start" || reason === "mpu-longer-than-gop") {
+      this.#mpuBoundsRaps = false;
+    }
+    if (this.#mode === "all-protected") return [];
+    this.#mode = "all-protected";
+    this.#reason = reason;
+    const changes = [{ kind: "mode", mode: "all-protected", reason }];
+    for (const [sbn, block] of this.#blocks) {
+      if (block.cls !== "delta") continue;
+      block.cls = "unknown";
+      changes.push({
+        kind: "reclassified",
+        sbn,
+        from: "delta",
+        to: "unknown",
+        evidence: "classifier-disabled"
+      });
+    }
+    return changes;
+  }
+  #classify(block) {
+    if (block.rapSeen || block.mpus.size >= 2) return "keyframe";
+    if (this.#mode === "all-protected") return "unknown";
+    const geometry = this.#geometry;
+    if (geometry.trackKind !== "video" || geometry.mode !== "classifying") return "unknown";
+    if (block.mpus.size === 1 && block.idxMin !== void 0 && block.idxMax !== void 0) {
+      const span = geometry.interleaveUnits - 1;
+      if (block.idxMax - span >= 1 && block.idxMin + span <= geometry.gopFrames - 1) {
+        return "delta";
+      }
+    }
+    return "unknown";
+  }
+  #allowed(from, to) {
+    if (from === "keyframe") return false;
+    if (from === "unknown") return to === "delta" || to === "keyframe";
+    if (from === "delta") return to === "keyframe";
+    return false;
+  }
+  #evidenceFor(block, to) {
+    if (to === "delta") return "window";
+    return block.rapSeen ? "rap" : "mpu-span";
+  }
+};
+function durationMs(units, before) {
+  if (before.durationTicks === void 0 || before.timescale === void 0 || before.timescale <= 0) {
+    return null;
+  }
+  return units * before.durationTicks * 1e3 / before.timescale;
+}
+function decideGap(input) {
+  const { before, after } = input;
+  let action;
+  let reason;
+  let missingFrames = null;
+  if (input.trackKind === "audio") {
+    action = "conceal";
+    reason = "audio-discontinuity";
+    if (!input.discontinuity && before.pts !== void 0 && after.pts !== void 0 && before.durationTicks !== void 0 && Number.isSafeInteger(before.durationTicks) && before.durationTicks > 0) {
+      const auDuration = BigInt(before.durationTicks);
+      const missingTicks = after.pts - before.pts - auDuration;
+      const bound = input.maxMissingUnits;
+      if (missingTicks > 0n && missingTicks % auDuration === 0n && bound !== null && missingTicks / auDuration <= BigInt(bound)) {
+        reason = "audio-gap";
+        missingFrames = Number(missingTicks / auDuration);
+      }
+    }
+  } else if (input.discontinuity) {
+    action = "stall";
+    reason = "discontinuity";
+  } else if (after.rap) {
+    action = "conceal";
+    reason = "rap-next";
+  } else if (before.mpu === void 0 || after.mpu === void 0) {
+    action = "stall";
+    reason = "rap-unknown";
+  } else if (before.mpu !== after.mpu) {
+    action = "stall";
+    reason = "rap-lost";
+  } else {
+    action = "conceal";
+    reason = "delta-lost";
+    if (before.idx !== void 0 && after.idx !== void 0) {
+      const missing = after.idx - before.idx - 1;
+      missingFrames = missing > 0 ? missing : null;
+    }
+  }
+  return Object.freeze({
+    version: 2,
+    type: "gap",
+    stream: Object.freeze({
+      packetId: input.stream.packetId,
+      catalogTrackName: input.stream.catalogTrackName
+    }),
+    trackKind: input.trackKind,
+    action,
+    reason,
+    blocks: Object.freeze([...input.blocks]),
+    missingFrames,
+    missingMs: missingFrames === null ? null : durationMs(missingFrames, before),
+    epoch: input.epoch
+  });
+}
+export {
+  BlockClassifier,
+  decideGap,
+  deriveBlockClassifierGeometry,
+  keyframeIntervalMediaTicks,
+  repairPriorityForClass
+};
+//# sourceMappingURL=block-policy.js.map

package/dist/block-policy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/block-policy.ts"],
+  "sourcesContent": ["/**\n * Keyframe-protected FEC repair policy.\n *\n * Every FEC block still gets in-band FEC decode. What this module decides is\n * (1) which blocks may hold a keyframe (RAP), so a block short of K at its\n * repair deadline can be repaired over QUIC with the right priority, and\n * (2) what a sink must do with the first frame released after a gap: stall\n * until the next RAP, or conceal and keep playing.\n *\n * The two decisions are deliberately independent. Classification only sets\n * repair priority. The stall/conceal decision is made again per released gap\n * from the media that is actually missing, so a wrong classification can only\n * lower a block's repair priority; it can never make playback wrong.\n *\n * Everything here is derived from catalog-authored timing and in-band MMTP\n * evidence. There are no timers, no cadence heuristics, and no defaults: a\n * track whose geometry cannot be derived exactly runs in the defined\n * fail-closed mode `all-protected`, where every block is treated as possibly\n * keyframe-bearing.\n *\n * All three players (moqtail, hang, Shaka) consume this one implementation.\n */\n\nimport { deriveFecInterleaveDepth } from '@blockcast/mmt-fec'\n\n// \u2500\u2500\u2500 Classes and priorities \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Repair class of one FEC block.\n *\n * - `keyframe`: the block holds (or held) a RAP / MPU start.\n * - `delta`: the block provably holds only non-RAP video frames.\n * - `unknown`: neither could be proven; treated exactly like `keyframe`.\n * - `audio`: an audio block.\n */\nexport type BlockClass = 'keyframe' | 'delta' | 'unknown' | 'audio'\n\n/** Repair priority. Lower is more urgent. */\nexport type RepairPriority = 0 | 1 | 2\n\nexport type TrackKind = 'video' | 'audio'\n\n/** P0 = keyframe/unknown (stall-preventing), P1 = audio, P2 = delta. */\nexport function repairPriorityForClass(blockClass: BlockClass): RepairPriority {\n  switch (blockClass) {\n    case 'keyframe':\n    case 'unknown':\n      return 0\n    case 'audio':\n      return 1\n    case 'delta':\n      return 2\n  }\n}\n\n// \u2500\u2500\u2500 Geometry \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type ClassifierMode = 'classifying' | 'all-protected'\n\n/** Why a track runs `all-protected`. */\nexport type ClassifierReason =\n  // Geometry (catalog) reasons.\n  | 'framerate-absent'\n  | 'keyframe-cadence-absent'\n  | 'keyframe-interval-not-integral'\n  | 'block-spans-gop'\n  /**\n   * The catalog keyframe interval is not an exact integer number of ticks\n   * in the media track's own timescale (ISO-BMFF `mdhd`), so released RAP\n   * spacing cannot be verified and hold-last cannot predict the next RAP.\n   * Nothing is wrong with the stream; the cadence is simply unprovable.\n   */\n  | 'keyframe-interval-not-media-integral'\n  /**\n   * Another stream on this packetId was configured with its own geometry\n   * and this one was not, so no geometry provably belongs to it (ABR rungs\n   * sharing a packetId).\n   */\n  | 'stream-geometry-absent'\n  // In-band invariant violations (positive evidence only).\n  | 'rap-not-mpu-start'\n  | 'mpu-longer-than-gop'\n  | 'block-not-contiguous'\n  | 'rap-spacing-mismatch'\n  | 'mpu-multiple-fragments'\n  | 'block-wider-than-interleave'\n\n/** Raw catalog timing for one track. Never a resolved cadence. */\nexport interface BlockClassifierGeometryInput {\n  readonly trackKind: TrackKind\n  /** Catalog `framerate` (frames per second). */\n  readonly framerate?: number\n  /** Catalog `fec.interleaveDepthMs`: the full FEC block span (\u00A75.1). */\n  readonly interleaveDepthMs: number\n  /** Catalog track `timescale` for `keyframeIntervalTicks`. */\n  readonly timescale?: number\n  /** Catalog `keyframeIntervalTicks` (preferred when the timescale is present). */\n  readonly keyframeIntervalTicks?: number\n  /** Catalog `keyframeIntervalMs`. */\n  readonly keyframeIntervalMs?: number\n}\n\n/** Exact keyframe interval as a rational number of seconds: ticks / timescale. */\nexport interface KeyframeInterval {\n  readonly ticks: number\n  readonly timescale: number\n}\n\nexport type BlockClassifierGeometry =\n  | { readonly trackKind: 'audio' }\n  | {\n      readonly trackKind: 'video'\n      readonly mode: 'classifying'\n      /** F: one frame's duration in milliseconds (1000 / framerate). */\n      readonly frameDurationMs: number\n      /** D: media units per FEC block (deriveFecInterleaveDepth). */\n      readonly interleaveUnits: number\n      /** G: frames per GOP. */\n      readonly gopFrames: number\n      readonly keyframeInterval: KeyframeInterval\n    }\n  | {\n      readonly trackKind: 'video'\n      readonly mode: 'all-protected'\n      readonly reason: ClassifierReason\n    }\n\n/**\n * Integer value of `numerator / denominator` when it is one, else null.\n *\n * Catalog framerates are JSON numbers, so an NTSC rate arrives as the double\n * nearest 30000/1001. One multiply and one divide each add at most half an\n * ulp of relative error (IEEE-754), so a quotient within two ulps of an\n * integer IS that integer; anything further is genuinely non-integral.\n */\nfunction exactInteger(numerator: number, denominator: number): number | null {\n  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator === 0) {\n    return null\n  }\n  const quotient = numerator / denominator\n  const rounded = Math.round(quotient)\n  if (rounded < 1) return null\n  const representationError = 2 * Number.EPSILON * Math.abs(quotient)\n  return Math.abs(quotient - rounded) <= representationError ? rounded : null\n}\n\nfunction isPositiveFinite(value: number | undefined): value is number {\n  return value !== undefined && Number.isFinite(value) && value > 0\n}\n\n/**\n * Derive the per-track classifier geometry from raw catalog fields.\n *\n * `all-protected` is the policy's defined fail-closed state, not a default:\n * it is returned with the exact reason. The only throw is for a value the\n * catalog validator already rejects (a non-positive block span).\n */\nexport function deriveBlockClassifierGeometry(\n  input: BlockClassifierGeometryInput,\n): BlockClassifierGeometry {\n  if (!isPositiveFinite(input.interleaveDepthMs)) {\n    throw new Error(\n      `[BlockPolicy] interleaveDepthMs=${input.interleaveDepthMs} is not a positive block span; ` +\n        'the catalog validator rejects this',\n    )\n  }\n  if (input.trackKind === 'audio') return { trackKind: 'audio' }\n\n  if (!isPositiveFinite(input.framerate)) {\n    return { trackKind: 'video', mode: 'all-protected', reason: 'framerate-absent' }\n  }\n  const framerate = input.framerate\n\n  let keyframeInterval: KeyframeInterval\n  if (isPositiveFinite(input.keyframeIntervalTicks) && isPositiveFinite(input.timescale)) {\n    keyframeInterval = { ticks: input.keyframeIntervalTicks, timescale: input.timescale }\n  } else if (isPositiveFinite(input.keyframeIntervalMs)) {\n    keyframeInterval = { ticks: input.keyframeIntervalMs, timescale: 1000 }\n  } else {\n    return { trackKind: 'video', mode: 'all-protected', reason: 'keyframe-cadence-absent' }\n  }\n\n  const gopFrames = exactInteger(keyframeInterval.ticks * framerate, keyframeInterval.timescale)\n  if (gopFrames === null) {\n    return {\n      trackKind: 'video',\n      mode: 'all-protected',\n      reason: 'keyframe-interval-not-integral',\n    }\n  }\n\n  const frameDurationMs = 1000 / framerate\n  const interleaveUnits = deriveFecInterleaveDepth(input.interleaveDepthMs, frameDurationMs)\n  if (interleaveUnits >= gopFrames) {\n    return { trackKind: 'video', mode: 'all-protected', reason: 'block-spans-gop' }\n  }\n\n  return {\n    trackKind: 'video',\n    mode: 'classifying',\n    frameDurationMs,\n    interleaveUnits,\n    gopFrames,\n    keyframeInterval,\n  }\n}\n\n/**\n * The keyframe interval expressed in a media track's timescale, or null when\n * the geometry is not `classifying` or the interval is not an exact integer\n * number of media ticks.\n */\nexport function keyframeIntervalMediaTicks(\n  geometry: BlockClassifierGeometry,\n  mediaTimescale: number,\n): bigint | null {\n  if (geometry.trackKind !== 'video' || geometry.mode !== 'classifying') return null\n  if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0) return null\n  const { ticks, timescale } = geometry.keyframeInterval\n  if (!Number.isSafeInteger(ticks) || !Number.isSafeInteger(timescale)) return null\n  const scaled = BigInt(ticks) * BigInt(mediaTimescale)\n  const divisor = BigInt(timescale)\n  if (scaled % divisor !== 0n) return null\n  return scaled / divisor\n}\n\n// \u2500\u2500\u2500 Evidence \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * In-band evidence from ONE first-arrival source symbol received from the\n * network. Recovered symbols and repair symbols never contribute, and the\n * MFU `priority > 0x80` hint is not evidence.\n */\nexport interface SourceSymbolEvidence {\n  /** The MMTP header R (RAP) bit. */\n  readonly rap: boolean\n  /** MPU_sequence_number, when parsed from this packet. */\n  readonly mpu?: number\n  /**\n   * 0-based sample position within the MPU: the MFU DU-header\n   * `sample_number` minus one (ISO/IEC 23008-1 numbers samples from 1, and\n   * the parser rejects `sample_number` 0). Present only when this packet\n   * carried a DU header.\n   */\n  readonly idx?: number\n  /** movie_fragment_sequence_number from the DU header, when present. */\n  readonly movieFragment?: number\n  /**\n   * DU-header `offset`: the data unit's authored byte position within its\n   * sample (0 for a whole-sample data unit, the partition boundary for a\n   * subsample data unit). Present only with `idx`; absent reads as 0.\n   */\n  readonly offset?: number\n  /**\n   * The MMTP header packet_sequence_number (contiguous per packet_id). Not\n   * classification evidence: FECManager uses it to bound how many blocks the\n   * producer can have started between two source symbols, so an outage is\n   * never mistaken for a source restart.\n   */\n  readonly packetSequenceNumber?: number\n}\n\nexport type ReclassificationEvidence = 'rap' | 'mpu-span' | 'window' | 'classifier-disabled'\n\nexport type ClassifierChange =\n  | {\n      readonly kind: 'reclassified'\n      readonly sbn: number\n      readonly from: BlockClass\n      readonly to: BlockClass\n      readonly evidence: ReclassificationEvidence\n    }\n  | {\n      readonly kind: 'mode'\n      readonly mode: 'all-protected'\n      readonly reason: ClassifierReason\n    }\n\ninterface BlockEvidence {\n  rapSeen: boolean\n  mpus: Set<number>\n  idxMin?: number\n  idxMax?: number\n  cls: BlockClass\n}\n\n/** A data-unit start (a packet carrying a DU header) and the block it is in. */\ninterface DataUnitStart {\n  readonly movieFragment: number\n  readonly idx: number\n  readonly offset: number\n  readonly sbn: number\n}\n\n/** Authored order of two data-unit starts of one MPU. */\nfunction compareDataUnitStarts(\n  a: Omit<DataUnitStart, 'sbn'>,\n  b: Omit<DataUnitStart, 'sbn'>,\n): number {\n  return a.movieFragment - b.movieFragment || a.idx - b.idx || a.offset - b.offset\n}\n\n/**\n * Per-stream block classifier.\n *\n * Classes only move toward more protection or narrower evidence:\n * `unknown\u2192delta` and `unknown\u2192keyframe` / `delta\u2192keyframe` on evidence, and\n * `delta\u2192unknown` when an invariant disables classification. `keyframe` is\n * terminal.\n *\n * The delta window rule rests on three premises, each guarded by an\n * invariant that fires on positive evidence only:\n *\n * - P1: the source packets of one block are one contiguous run of the\n *   stream's authored order, and blocks follow each other in SBN order\n *   (`block-not-contiguous`). The producer assigns SS_IDs in authored order\n *   and a block is the SS_ID range [SBN*K, SBN*K + K), so this holds for a\n *   block that closes at K symbols in the middle of a frame: that frame's\n *   fragments then land in two ADJACENT blocks, which is still one run each.\n *   A frame split across adjacent blocks is not a violation.\n * - P2: that run touches at most D media units, counting a frame continued\n *   from the previous block (`block-wider-than-interleave`). The producer\n *   counts a media-unit boundary only once the open block holds a symbol.\n * - P3: an MPU starts with its only RAP and holds at most G frames\n *   (`rap-not-mpu-start`, `mpu-longer-than-gop`, `rap-spacing-mismatch`), in\n *   one movie fragment (`mpu-multiple-fragments`).\n *\n * P1 and P2 are what make a block's frames contiguous and lie within\n * [idxMax \u2212 D + 1, idxMin + D \u2212 1] of its MPU. What refutes P1 is a pair of\n * source packets whose wire-stated authored order and SBN order disagree:\n * a later MPU in an earlier block, a later data unit of one MPU (by\n * movie_fragment_sequence_number, sample_number, then DU offset) in an\n * earlier block, or one data unit in two blocks. That is the signature of a\n * round-robin interleave, which scatters one run over several concurrent\n * blocks. Non-adjacency alone is not: a sample larger than K packets\n * legitimately spans blocks SBN..SBN+n.\n */\nexport class BlockClassifier {\n  #geometry: BlockClassifierGeometry\n  #mode: ClassifierMode\n  #reason: ClassifierReason | null\n  /**\n   * False once the stream showed that an MPU boundary does not bound its\n   * RAPs (a RAP inside an MPU, or an MPU longer than a GOP). Recorded in\n   * every mode: the stall/conceal decision relies on it even when the\n   * catalog geometry already runs the classifier `all-protected`.\n   */\n  #mpuBoundsRaps = true\n  #blocks = new Map<number, BlockEvidence>()\n  /**\n   * P1 ledger, kept for the MPUs within the classification horizon (the\n   * highest MPU seen and the one before it): the SBN span of every source\n   * packet of each MPU, and each MPU's data-unit starts in authored order.\n   * Valid only within one continuous SBN sequence; a source discontinuity\n   * clears it (`noteSourceDiscontinuity`).\n   */\n  #mpuSbnSpans = new Map<number, { min: number; max: number }>()\n  #dataUnitStarts = new Map<number, DataUnitStart[]>()\n  #highestMpu: number | null = null\n  /** MPU \u2192 movie_fragment_sequence_number observed in it. */\n  #mpuFragments = new Map<number, number>()\n  #lastRap: { mpu: number; presentationTime: bigint; mediaTimescale: number } | null = null\n\n  constructor(geometry: BlockClassifierGeometry) {\n    this.#geometry = geometry\n    this.#mode = 'classifying'\n    this.#reason = null\n    this.reset(geometry)\n  }\n\n  get geometry(): BlockClassifierGeometry {\n    return this.#geometry\n  }\n\n  get mode(): ClassifierMode {\n    return this.#mode\n  }\n\n  get reason(): ClassifierReason | null {\n    return this.#reason\n  }\n\n  /**\n   * Whether \"same MPU on both sides of a gap\" still proves the gap held no\n   * RAP. It stops holding for the rest of the epoch once a RAP was received\n   * inside an MPU or an MPU ran longer than a GOP.\n   */\n  get mpuBoundsRaps(): boolean {\n    return this.#mpuBoundsRaps\n  }\n\n  /** Begin a fresh epoch (catalog change or track reset). */\n  reset(geometry: BlockClassifierGeometry = this.#geometry): void {\n    this.#geometry = geometry\n    this.#blocks.clear()\n    this.#clearContiguityLedger()\n    this.#mpuFragments.clear()\n    this.#lastRap = null\n    this.#mpuBoundsRaps = true\n    if (geometry.trackKind === 'video' && geometry.mode === 'all-protected') {\n      this.#mode = 'all-protected'\n      this.#reason = geometry.reason\n    } else {\n      this.#mode = 'classifying'\n      this.#reason = null\n    }\n  }\n\n  /**\n   * Retire this classifier (its stream moves to a new catalog epoch). Every\n   * block it had classified `delta` loses the evidence behind that class and\n   * reads `unknown` from now on; the returned changes say so.\n   */\n  retire(): ClassifierChange[] {\n    const changes: ClassifierChange[] = []\n    for (const [sbn, block] of this.#blocks) {\n      if (block.cls !== 'delta') continue\n      block.cls = 'unknown'\n      changes.push({\n        kind: 'reclassified',\n        sbn,\n        from: 'delta',\n        to: 'unknown',\n        evidence: 'classifier-disabled',\n      })\n    }\n    return changes\n  }\n\n  /**\n   * The stream's SBN sequence restarted (FECManager source discontinuity:\n   * a publisher restart, or the SS_ID space wrapped). Authored order and SBN\n   * order are comparable only within one continuous sequence, so the P1\n   * ledger starts again.\n   */\n  noteSourceDiscontinuity(): void {\n    this.#clearContiguityLedger()\n  }\n\n  /** Register a block that exists without evidence (a vanished block). */\n  touch(sbn: number): void {\n    this.#blockFor(sbn)\n  }\n\n  /** Forget a resolved block. */\n  forget(sbn: number): void {\n    this.#blocks.delete(sbn)\n  }\n\n  classOf(sbn: number): BlockClass {\n    if (this.#geometry.trackKind === 'audio') return 'audio'\n    return this.#blocks.get(sbn)?.cls ?? 'unknown'\n  }\n\n  /** Record one first-arrival source symbol's evidence for block `sbn`. */\n  observe(sbn: number, evidence: SourceSymbolEvidence): ClassifierChange[] {\n    if (this.#geometry.trackKind === 'audio') return []\n    const changes: ClassifierChange[] = []\n    const block = this.#blockFor(sbn)\n\n    if (evidence.rap) block.rapSeen = true\n    if (evidence.mpu !== undefined) block.mpus.add(evidence.mpu)\n    if (evidence.idx !== undefined) {\n      block.idxMin = block.idxMin === undefined ? evidence.idx : Math.min(block.idxMin, evidence.idx)\n      block.idxMax = block.idxMax === undefined ? evidence.idx : Math.max(block.idxMax, evidence.idx)\n    }\n\n    // A RAP inside an MPU refutes \"an MPU boundary bounds RAPs\" whatever the\n    // classifier mode, because gap decisions rely on it in every mode.\n    if (evidence.rap && evidence.idx !== undefined && evidence.idx !== 0) {\n      this.#mpuBoundsRaps = false\n    }\n\n    const violation = this.#checkInvariants(sbn, block, evidence)\n    if (violation !== null) changes.push(...this.#disable(violation))\n\n    const next = this.#classify(block)\n    if (next !== block.cls && this.#allowed(block.cls, next)) {\n      changes.push({\n        kind: 'reclassified',\n        sbn,\n        from: block.cls,\n        to: next,\n        evidence: this.#evidenceFor(block, next),\n      })\n      block.cls = next\n    }\n    return changes\n  }\n\n  /**\n   * Record a RAP frame released in order. Released MPU-start RAPs of MPUs m\n   * and m+n must be exactly n keyframe intervals apart in the media\n   * timescale, compared as integers.\n   *\n   * Comparing only consecutive MPUs would miss exactly the case the window\n   * rule cannot survive: a short MPU whose successor's RAP was lost (that\n   * RAP-bearing block is the one a wrong G calls delta), because the next\n   * released RAP then belongs to m+2. Every MPU is one interval long, so the\n   * span to any later released RAP proves or refutes all MPUs in between.\n   */\n  noteReleasedRap(\n    mpu: number,\n    presentationTime: bigint,\n    mediaTimescale: number,\n  ): ClassifierChange[] {\n    if (this.#geometry.trackKind === 'audio' || this.#mode === 'all-protected') {\n      return []\n    }\n    // Verification compares integers in the media timescale. When the\n    // catalog interval is not an exact tick count there, spacing is\n    // unprovable: fail closed, naming the cause, rather than blaming the\n    // encoder with rap-spacing-mismatch on a perfectly spaced RAP.\n    const interval = keyframeIntervalMediaTicks(this.#geometry, mediaTimescale)\n    if (interval === null) return this.#disable('keyframe-interval-not-media-integral')\n    const previous = this.#lastRap\n    // A further RAP inside an already-anchored MPU is not an MPU start; the\n    // MPU keeps its first RAP as the spacing anchor (rap-not-mpu-start owns\n    // mid-MPU RAPs).\n    if (previous !== null && previous.mpu === mpu && previous.mediaTimescale === mediaTimescale) {\n      return []\n    }\n    this.#lastRap = { mpu, presentationTime, mediaTimescale }\n    if (\n      previous === null ||\n      mpu < previous.mpu ||\n      previous.mediaTimescale !== mediaTimescale\n    ) {\n      return []\n    }\n    if (\n      presentationTime - previous.presentationTime === interval * BigInt(mpu - previous.mpu)\n    ) {\n      return []\n    }\n    return this.#disable('rap-spacing-mismatch')\n  }\n\n  #blockFor(sbn: number): BlockEvidence {\n    let block = this.#blocks.get(sbn)\n    if (!block) {\n      block = { rapSeen: false, mpus: new Set(), cls: 'unknown' }\n      this.#blocks.set(sbn, block)\n    }\n    return block\n  }\n\n  #checkInvariants(\n    sbn: number,\n    block: BlockEvidence,\n    evidence: SourceSymbolEvidence,\n  ): ClassifierReason | null {\n    if (this.#mode === 'all-protected' || this.#geometry.trackKind !== 'video') return null\n    const geometry = this.#geometry\n    if (geometry.mode !== 'classifying') return null\n    if (evidence.rap && evidence.idx !== undefined && evidence.idx !== 0) {\n      return 'rap-not-mpu-start'\n    }\n    if (evidence.idx !== undefined && evidence.idx >= geometry.gopFrames) {\n      return 'mpu-longer-than-gop'\n    }\n    // A block closes at the latest after D media units, so the DU headers it\n    // carries from one MPU lie within D consecutive positions. A wider span\n    // means the producer closes blocks some other way (at K symbols, or\n    // round-robin across concurrent blocks) and the window rule is void.\n    if (\n      block.mpus.size === 1 &&\n      block.idxMin !== undefined &&\n      block.idxMax !== undefined &&\n      block.idxMax - block.idxMin >= geometry.interleaveUnits\n    ) {\n      return 'block-wider-than-interleave'\n    }\n    if (evidence.mpu !== undefined && evidence.movieFragment !== undefined) {\n      const fragment = this.#mpuFragments.get(evidence.mpu)\n      if (fragment === undefined) {\n        this.#mpuFragments.set(evidence.mpu, evidence.movieFragment)\n        // One entry per MPU still inside the classification horizon.\n        for (const mpu of this.#mpuFragments.keys()) {\n          if (mpu + 1 < evidence.mpu) this.#mpuFragments.delete(mpu)\n        }\n      } else if (fragment !== evidence.movieFragment) {\n        // sample_number is then a position within a movie fragment, not\n        // within the MPU, and the window rule's geometry does not hold.\n        return 'mpu-multiple-fragments'\n      }\n    }\n    if (evidence.mpu !== undefined && this.#contradictsAuthoredOrder(sbn, evidence.mpu, evidence)) {\n      return 'block-not-contiguous'\n    }\n    return null\n  }\n\n  #clearContiguityLedger(): void {\n    this.#mpuSbnSpans.clear()\n    this.#dataUnitStarts.clear()\n    this.#highestMpu = null\n  }\n\n  /**\n   * P1 check for one source packet of MPU `mpu` in block `sbn`, then record\n   * it. True when some recorded packet's authored order and SBN order\n   * disagree with this one's (see the class comment). Only positions the\n   * wire states are compared: MPU order for every packet, and data-unit\n   * order for packets that carry a DU header. A packet of one data unit\n   * that continues into the next block carries no DU header and so only\n   * takes part through its MPU, which is exactly what makes an adjacent\n   * straddle consistent.\n   */\n  #contradictsAuthoredOrder(sbn: number, mpu: number, evidence: SourceSymbolEvidence): boolean {\n    // Every packet of MPU m precedes every packet of MPU m' > m.\n    for (const [other, span] of this.#mpuSbnSpans) {\n      if (other < mpu && span.max > sbn) return true\n      if (other > mpu && span.min < sbn) return true\n    }\n    const inHorizon = this.#highestMpu === null || mpu + 1 >= this.#highestMpu\n    let insertAt = -1\n    let starts: DataUnitStart[] | undefined\n    let start: DataUnitStart | undefined\n    if (evidence.idx !== undefined) {\n      start = {\n        movieFragment: evidence.movieFragment ?? 0,\n        idx: evidence.idx,\n        offset: evidence.offset ?? 0,\n        sbn,\n      }\n      starts = this.#dataUnitStarts.get(mpu)\n      if (starts !== undefined) {\n        let lo = 0\n        let hi = starts.length\n        while (lo < hi) {\n          const mid = (lo + hi) >>> 1\n          if (compareDataUnitStarts(starts[mid]!, start) < 0) lo = mid + 1\n          else hi = mid\n        }\n        const at = starts[lo]\n        if (at !== undefined && compareDataUnitStarts(at, start) === 0) {\n          // One data unit has one first packet: seen in another block, the\n          // SBN-to-authored-order map is not a function.\n          if (at.sbn !== sbn) return true\n        } else {\n          const before = starts[lo - 1]\n          if (before !== undefined && before.sbn > sbn) return true\n          if (at !== undefined && at.sbn < sbn) return true\n          insertAt = lo\n        }\n      }\n    }\n    if (!inHorizon) return false\n    const span = this.#mpuSbnSpans.get(mpu)\n    if (span === undefined) this.#mpuSbnSpans.set(mpu, { min: sbn, max: sbn })\n    else {\n      if (sbn < span.min) span.min = sbn\n      if (sbn > span.max) span.max = sbn\n    }\n    if (start !== undefined) {\n      if (starts === undefined) this.#dataUnitStarts.set(mpu, [start])\n      else if (insertAt >= 0) starts.splice(insertAt, 0, start)\n    }\n    if (this.#highestMpu === null || mpu > this.#highestMpu) {\n      this.#highestMpu = mpu\n      for (const other of [...this.#mpuSbnSpans.keys()]) {\n        if (other + 1 < mpu) {\n          this.#mpuSbnSpans.delete(other)\n          this.#dataUnitStarts.delete(other)\n        }\n      }\n    }\n    return false\n  }\n\n  #disable(reason: ClassifierReason): ClassifierChange[] {\n    if (reason === 'rap-not-mpu-start' || reason === 'mpu-longer-than-gop') {\n      this.#mpuBoundsRaps = false\n    }\n    if (this.#mode === 'all-protected') return []\n    this.#mode = 'all-protected'\n    this.#reason = reason\n    const changes: ClassifierChange[] = [{ kind: 'mode', mode: 'all-protected', reason }]\n    for (const [sbn, block] of this.#blocks) {\n      if (block.cls !== 'delta') continue\n      block.cls = 'unknown'\n      changes.push({\n        kind: 'reclassified',\n        sbn,\n        from: 'delta',\n        to: 'unknown',\n        evidence: 'classifier-disabled',\n      })\n    }\n    return changes\n  }\n\n  #classify(block: BlockEvidence): BlockClass {\n    if (block.rapSeen || block.mpus.size >= 2) return 'keyframe'\n    if (this.#mode === 'all-protected') return 'unknown'\n    const geometry = this.#geometry\n    if (geometry.trackKind !== 'video' || geometry.mode !== 'classifying') return 'unknown'\n    if (\n      block.mpus.size === 1 &&\n      block.idxMin !== undefined &&\n      block.idxMax !== undefined\n    ) {\n      // A block closes every D media units, so its frames are contiguous and\n      // lie in [idxMax \u2212 D + 1, idxMin + D \u2212 1] of MPU m. Index 0 is the only\n      // RAP of an MPU and G bounds its length.\n      const span = geometry.interleaveUnits - 1\n      if (block.idxMax - span >= 1 && block.idxMin + span <= geometry.gopFrames - 1) {\n        return 'delta'\n      }\n    }\n    return 'unknown'\n  }\n\n  #allowed(from: BlockClass, to: BlockClass): boolean {\n    if (from === 'keyframe') return false\n    if (from === 'unknown') return to === 'delta' || to === 'keyframe'\n    if (from === 'delta') return to === 'keyframe'\n    return false\n  }\n\n  #evidenceFor(block: BlockEvidence, to: BlockClass): ReclassificationEvidence {\n    if (to === 'delta') return 'window'\n    return block.rapSeen ? 'rap' : 'mpu-span'\n  }\n}\n\n// \u2500\u2500\u2500 Stall vs conceal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport interface GapStreamIdentity {\n  readonly packetId: number\n  /** Non-empty catalog identity, or null when the producer has no track name. */\n  readonly catalogTrackName: string | null\n}\n\n/** What the sink knows about one side of a released gap. */\nexport interface GapFrameEvidence {\n  /**\n   * Codec-aware RAP check: `MmtpContainerParser.isKeyframe(data, rapFlag,\n   * codec)`, bitstream-only for recovered frames. Never the priority hint.\n   */\n  readonly rap: boolean\n  /**\n   * MPU_sequence_number of the frame. Omit it once the stream showed that\n   * an MPU boundary does not bound its RAPs (`BlockClassifier.mpuBoundsRaps`):\n   * same-MPU then no longer proves a gap lost only deltas.\n   */\n  readonly mpu?: number\n  /** 0-based sample position within the MPU, when the geometry verifies it. */\n  readonly idx?: number\n  /** Authored presentation time in `timescale` ticks. */\n  readonly pts?: bigint\n  /** Authored sample duration in `timescale` ticks. */\n  readonly durationTicks?: number\n  /** The media timescale of `pts` and `durationTicks`. */\n  readonly timescale?: number\n}\n\nexport type FrameGapAction = 'stall' | 'conceal'\n\nexport type FrameGapReason =\n  | 'rap-lost'\n  | 'rap-unknown'\n  | 'discontinuity'\n  | 'delta-lost'\n  | 'rap-next'\n  | 'audio-gap'\n  | 'audio-discontinuity'\n\n/**\n * The decision attached to the first frame released after a gap\n * (`RoutedFrameMeta.gapBefore`). It is the same frozen object the manager\n * emits as its `gap` repair lifecycle event, so a sink that acts on the frame\n * and an observer that counts events see one fact.\n */\nexport interface FrameGapDecision {\n  readonly version: 2\n  readonly type: 'gap'\n  readonly stream: GapStreamIdentity\n  readonly trackKind: TrackKind\n  readonly action: FrameGapAction\n  readonly reason: FrameGapReason\n  /** FEC blocks in the gap whose media was lost (failed or vanished). */\n  readonly blocks: readonly number[]\n  /** Missing video frames or audio access units, when exactly known. */\n  readonly missingFrames: number | null\n  /** Authored duration of the missing media in milliseconds, when known. */\n  readonly missingMs: number | null\n  /** Manager epoch of the stream when the decision was made. */\n  readonly epoch: number\n}\n\nexport interface DecideGapInput {\n  readonly stream: GapStreamIdentity\n  readonly trackKind: TrackKind\n  /** Last frame released before the gap. */\n  readonly before: GapFrameEvidence\n  /** First frame released after the gap. */\n  readonly after: GapFrameEvidence\n  /** The stream restarted (FEC SBN went backwards or the publisher reset). */\n  readonly discontinuity: boolean\n  readonly blocks: readonly number[]\n  /**\n   * The most media units the gap can hold: the FEC blocks spanned from the\n   * frame before to the frame after, times D (media units per block,\n   * ceil(interleaveDepthMs / unit duration), \u00A75.1). A block touches at most D\n   * units whether it closes at D or at K symbols. Null when the span or D is\n   * unknown. An audio PTS delta that implies more AUs than this is a clock\n   * jump, not loss, and re-anchors instead of concealing every slot.\n   */\n  readonly maxMissingUnits: number | null\n  readonly epoch: number\n}\n\nfunction durationMs(units: number, before: GapFrameEvidence): number | null {\n  if (\n    before.durationTicks === undefined ||\n    before.timescale === undefined ||\n    before.timescale <= 0\n  ) {\n    return null\n  }\n  return (units * before.durationTicks * 1000) / before.timescale\n}\n\n/**\n * Pure stall/conceal decision for the first frame released after a gap.\n *\n * Video stalls only when a RAP may be inside the gap: the frame after it is\n * not a RAP and either sits in another MPU (`rap-lost`) or the MPU cannot be\n * proven on both sides (`rap-unknown`), or the stream restarted\n * (`discontinuity`). A gap inside one MPU lost only deltas (`delta-lost`) and\n * a RAP after the gap resynchronises by itself (`rap-next`). Audio never\n * stalls: an exact gap is concealed per access unit (`audio-gap`), anything\n * else re-anchors at the next frame (`audio-discontinuity`).\n */\nexport function decideGap(input: DecideGapInput): FrameGapDecision {\n  const { before, after } = input\n  let action: FrameGapAction\n  let reason: FrameGapReason\n  let missingFrames: number | null = null\n\n  if (input.trackKind === 'audio') {\n    action = 'conceal'\n    reason = 'audio-discontinuity'\n    if (\n      !input.discontinuity &&\n      before.pts !== undefined &&\n      after.pts !== undefined &&\n      before.durationTicks !== undefined &&\n      Number.isSafeInteger(before.durationTicks) &&\n      before.durationTicks > 0\n    ) {\n      const auDuration = BigInt(before.durationTicks)\n      const missingTicks = after.pts - before.pts - auDuration\n      const bound = input.maxMissingUnits\n      if (\n        missingTicks > 0n &&\n        missingTicks % auDuration === 0n &&\n        bound !== null &&\n        missingTicks / auDuration <= BigInt(bound)\n      ) {\n        reason = 'audio-gap'\n        missingFrames = Number(missingTicks / auDuration)\n      }\n    }\n  } else if (input.discontinuity) {\n    action = 'stall'\n    reason = 'discontinuity'\n  } else if (after.rap) {\n    action = 'conceal'\n    reason = 'rap-next'\n  } else if (before.mpu === undefined || after.mpu === undefined) {\n    action = 'stall'\n    reason = 'rap-unknown'\n  } else if (before.mpu !== after.mpu) {\n    action = 'stall'\n    reason = 'rap-lost'\n  } else {\n    action = 'conceal'\n    reason = 'delta-lost'\n    if (before.idx !== undefined && after.idx !== undefined) {\n      const missing = after.idx - before.idx - 1\n      missingFrames = missing > 0 ? missing : null\n    }\n  }\n\n  return Object.freeze({\n    version: 2 as const,\n    type: 'gap' as const,\n    stream: Object.freeze({\n      packetId: input.stream.packetId,\n      catalogTrackName: input.stream.catalogTrackName,\n    }),\n    trackKind: input.trackKind,\n    action,\n    reason,\n    blocks: Object.freeze([...input.blocks]),\n    missingFrames,\n    missingMs: missingFrames === null ? null : durationMs(missingFrames, before),\n    epoch: input.epoch,\n  })\n}\n"],
+  "mappings": "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",
+  "names": ["span"]
+}