@blockcast/mmt-container 0.5.0 → 1.0.0-main.215b8665a0eb

package/README.md

@@ -270,7 +270,7 @@ per-commit `0.1.0-main.<sha>` prerelease from `stamp-prerelease.mjs`), and a
 > Superseded by BLO-40665. Every package is now bumped in lockstep by a `v*`
 > tag and the sibling ranges move with it, so the objection above no longer
 > applies -- it was an argument against bumping *one* package. The set is at
-> `0.5.0`; see `RELEASES.md`.
+> `1.0.0`; see `RELEASES.md`.
 
 #### Track-role convention (Phase 14)
 

package/dist/browser-runtime.js

@@ -7090,6 +7090,299 @@ function validateSwitchingSetTiming(tracks) {
   return { ok: false, expectedTicks, mismatches };
 }
 
+// src/fec-catalog.ts
+var DEFAULT_SCHEMES = ["reed-solomon", "raptorq"];
+var DEFAULT_PROFILES = ["moq-object-v1", "iso-ssbg1-v1"];
+var RS_MAX_BLOCK = 255;
+var RAPTORQ_MAX_K = 56403;
+var MAX_24 = 16777215;
+var ISO_MIN_T = 14;
+var GEOMETRY_KEYS = [
+  "scheme",
+  "blockProfile",
+  "mmtpMode",
+  "timescale",
+  "symbolSize",
+  "interleaveDepthMs",
+  "reorderToleranceMs",
+  "sourceSymbols",
+  "fec"
+];
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+var isInt = (v) => typeof v === "number" && Number.isInteger(v);
+var intIn = (v, lo, hi = Number.MAX_SAFE_INTEGER) => isInt(v) && v >= lo && v <= hi;
+var profileAdmits = (profile, packaging) => profile !== "iso-ssbg1-v1" || packaging === "mmtp";
+function validateFecCatalog(catalog, receiver = {}) {
+  const schemes = receiver.schemes ?? DEFAULT_SCHEMES;
+  const profiles = receiver.blockProfiles ?? DEFAULT_PROFILES;
+  const overlays = receiver.overlays ?? true;
+  const all = [];
+  const report = (code, path, inst) => {
+    const issue = { code, path };
+    all.push(issue);
+    inst?.issues.push(issue);
+  };
+  const tracks = isObj(catalog) && Array.isArray(catalog.tracks) ? catalog.tracks : [];
+  if (!isObj(catalog) || !Array.isArray(catalog.tracks)) report("fec_member", "/tracks");
+  let rejectAll = false;
+  tracks.forEach((t, ti) => {
+    if (!isObj(t)) return;
+    if (has(t, "enhancementRepair")) {
+      rejectAll = true;
+      report("fec_enhancement_repair", `/tracks/${ti}/enhancementRepair`);
+    }
+    if (Array.isArray(t.fec))
+      t.fec.forEach((o, ii) => {
+        if (isObj(o) && has(o, "enhancementRepair")) {
+          rejectAll = true;
+          report("fec_enhancement_repair", `/tracks/${ti}/fec/${ii}/enhancementRepair`);
+        }
+      });
+  });
+  const key = (ns, name) => JSON.stringify([ns ?? null, name]);
+  const byName = /* @__PURE__ */ new Map();
+  tracks.forEach((t, ti) => {
+    if (isObj(t) && typeof t.name === "string") {
+      const k = key(t.namespace, t.name);
+      if (!byName.has(k)) byName.set(k, ti);
+    }
+  });
+  const trackAt = (ti) => tracks[ti];
+  const insts = [];
+  tracks.forEach((t, ti) => {
+    if (!isObj(t) || !has(t, "fec") || t.packaging === "fec-repair" || t.packaging === "fec-source") return;
+    if (!Array.isArray(t.fec)) {
+      report("fec_member", `/tracks/${ti}/fec`);
+      return;
+    }
+    t.fec.forEach((o, ii) => {
+      const path = `/tracks/${ti}/fec/${ii}`;
+      const inst = {
+        path,
+        ti,
+        track: t,
+        obj: isObj(o) ? o : null,
+        id: null,
+        unavailable: false,
+        overlay: false,
+        issues: [],
+        layer0: null,
+        symbolNamed: null,
+        attached: []
+      };
+      insts.push(inst);
+      if (!inst.obj) return report("fec_member", path, inst);
+      const o2 = inst.obj;
+      if (!has(o2, "instanceId")) inst.id = 0;
+      else if (intIn(o2.instanceId, 0, 255)) inst.id = o2.instanceId;
+      else report("fec_member", `${path}/instanceId`, inst);
+      inst.overlay = has(o2, "scope");
+    });
+  });
+  const declaresFec = insts.length > 0;
+  for (const inst of insts) {
+    const o = inst.obj;
+    if (!o) continue;
+    const avail = (field, impl) => {
+      const p = `${inst.path}/${field}`;
+      const absent = field === "scheme" ? "fec_scheme_absent" : "fec_block_profile_absent";
+      const unimpl = field === "scheme" ? "fec_scheme_unimplemented" : "fec_block_profile_unimplemented";
+      if (!has(o, field)) return report(absent, p, inst), false;
+      if (typeof o[field] !== "string") return report("fec_member", p, inst), true;
+      if (!impl.includes(o[field])) return report(unimpl, p, inst), false;
+      return true;
+    };
+    if (!avail("scheme", schemes) || !avail("blockProfile", profiles)) inst.unavailable = true;
+    else if (typeof o.blockProfile === "string" && !profileAdmits(o.blockProfile, inst.track.packaging)) {
+      report("fec_block_profile_packaging", `${inst.path}/blockProfile`, inst);
+      inst.unavailable = true;
+    }
+  }
+  const live = (i) => !i.unavailable;
+  for (const inst of insts.filter(live)) {
+    const o = inst.obj;
+    if (!o) continue;
+    const p = inst.path;
+    for (const m of ["sourceSymbols", "repairSymbols", "symbolSize"])
+      if (!intIn(o[m], 1)) report("fec_member", `${p}/${m}`, inst);
+    if (typeof o.repairTrack !== "string") report("fec_member", `${p}/repairTrack`, inst);
+    if (has(o, "symbolTrack") && typeof o.symbolTrack !== "string") report("fec_member", `${p}/symbolTrack`, inst);
+    if (has(o, "interleaveDepthMs")) {
+      const d = o.interleaveDepthMs;
+      if (!intIn(d, 0) || d === 0 && o.blockProfile !== "iso-ssbg1-v1")
+        report("fec_member", `${p}/interleaveDepthMs`, inst);
+    }
+    if (has(o, "reorderToleranceMs")) {
+      const r = o.reorderToleranceMs;
+      if (typeof r !== "number" || !Number.isFinite(r) || r < 0) report("fec_member", `${p}/reorderToleranceMs`, inst);
+    }
+    if (has(o, "label") && typeof o.label !== "string") report("fec_member", `${p}/label`, inst);
+    if (inst.overlay && o.scope !== "keyframe") report("fec_member", `${p}/scope`, inst);
+  }
+  const idGroups = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    if (inst.id !== null) {
+      const k = `${inst.ti}:${inst.id}`;
+      idGroups.set(k, [...idGroups.get(k) ?? [], inst]);
+    }
+  for (const group of idGroups.values())
+    if (group.length > 1)
+      for (const inst of group.filter(live))
+        report("fec_instance_id", inst.obj && has(inst.obj, "instanceId") ? `${inst.path}/instanceId` : inst.path, inst);
+  const nameUses = /* @__PURE__ */ new Map();
+  for (const inst of insts)
+    for (const field of ["repairTrack", "symbolTrack"])
+      if (inst.obj && typeof inst.obj[field] === "string") {
+        const k = key(inst.track.namespace, inst.obj[field]);
+        nameUses.set(k, [...nameUses.get(k) ?? [], { inst, field }]);
+      }
+  const namedBy = /* @__PURE__ */ new Map();
+  for (const [k, uses] of nameUses) {
+    const tj = byName.get(k);
+    for (const { inst, field } of uses) {
+      const path = `${inst.path}/${field}`;
+      if (tj === void 0 || trackAt(tj).packaging !== (field === "repairTrack" ? "fec-repair" : "fec-source")) {
+        if (live(inst)) report("fec_naming", path, inst);
+      } else if (uses.length > 1) {
+        if (live(inst)) report("fec_naming", path, inst);
+        if (!namedBy.has(tj)) namedBy.set(tj, inst);
+      } else {
+        namedBy.set(tj, inst);
+        if (field === "repairTrack") inst.layer0 = tj;
+        else inst.symbolNamed = tj;
+      }
+    }
+  }
+  const owner = /* @__PURE__ */ new Map();
+  if (declaresFec)
+    tracks.forEach((t, tj) => {
+      if (!isObj(t) || t.packaging !== "fec-repair" && t.packaging !== "fec-source") return;
+      const tp = `/tracks/${tj}`;
+      const named = namedBy.get(tj);
+      if (named) {
+        owner.set(tj, named);
+        if (!live(named)) return;
+        if (has(t, "source") && t.source !== named.track.name) report("fec_resolution", `${tp}/source`, named);
+        if (has(t, "instanceId") && t.instanceId !== named.id) report("fec_resolution", `${tp}/instanceId`, named);
+        return;
+      }
+      if (!has(t, "source")) return report("fec_orphan", tp);
+      const id = has(t, "instanceId") ? t.instanceId : 0;
+      const src = typeof t.source === "string" ? byName.get(key(t.namespace, t.source)) : void 0;
+      const target = src === void 0 ? void 0 : insts.find((i) => i.ti === src && i.id === id);
+      if (!target) return report("fec_naming", has(t, "instanceId") && src !== void 0 ? `${tp}/instanceId` : `${tp}/source`);
+      owner.set(tj, target);
+      target.attached.push(tj);
+    });
+  for (const [tj, inst] of owner) {
+    if (!live(inst)) continue;
+    const t = trackAt(tj);
+    const tp = `/tracks/${tj}`;
+    const symbol = t.packaging === "fec-source";
+    if (has(t, "source") && typeof t.source !== "string") report("fec_member", `${tp}/source`, inst);
+    if (has(t, "instanceId") && !intIn(t.instanceId, 0, 255)) report("fec_member", `${tp}/instanceId`, inst);
+    for (const m of ["repairLayer", "repairSymbols"]) {
+      if (!has(t, m)) continue;
+      if (symbol || !intIn(t[m], m === "repairLayer" ? 0 : 1)) report("fec_member", `${tp}/${m}`, inst);
+    }
+    if (has(t, "priority") && !intIn(t.priority, symbol ? 0 : 192, 255)) report("fec_member", `${tp}/priority`, inst);
+    for (const k of Object.keys(t))
+      if (GEOMETRY_KEYS.includes(k) || k.startsWith("groupDuration")) report("fec_track_geometry", `${tp}/${k}`, inst);
+  }
+  for (const inst of insts.filter(live)) {
+    const o = inst.obj;
+    if (!o) continue;
+    const repairs = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-repair");
+    const symbols = inst.attached.filter((tj) => trackAt(tj).packaging === "fec-source");
+    if (symbols.length + (inst.symbolNamed !== null ? 1 : 0) > 1)
+      for (const tj of symbols) report("fec_symbol_tracks", `/tracks/${tj}`, inst);
+    const l0 = inst.layer0 === null ? null : trackAt(inst.layer0);
+    const l0p = `/tracks/${inst.layer0}`;
+    if (inst.overlay) {
+      if (l0 && has(l0, "repairLayer")) report("fec_overlay", `${l0p}/repairLayer`, inst);
+      for (const tj of repairs)
+        report("fec_overlay", has(trackAt(tj), "repairLayer") ? `/tracks/${tj}/repairLayer` : `/tracks/${tj}`, inst);
+    } else {
+      if (l0 && has(l0, "repairLayer") && l0.repairLayer !== 0) report("fec_layers", `${l0p}/repairLayer`, inst);
+      if (l0 && has(l0, "repairSymbols") && intIn(o.repairSymbols, 1) && l0.repairSymbols !== o.repairSymbols)
+        report("fec_layer0", `${l0p}/repairSymbols`, inst);
+      const layers = [];
+      for (const tj of repairs) {
+        const t = trackAt(tj);
+        if (!has(t, "repairLayer")) report("fec_member", `/tracks/${tj}/repairLayer`, inst);
+        else if (t.repairLayer === 0) report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+        else if (intIn(t.repairLayer, 1)) layers.push({ tj, layer: t.repairLayer });
+        if (!has(t, "repairSymbols")) report("fec_member", `/tracks/${tj}/repairSymbols`, inst);
+      }
+      const counts = /* @__PURE__ */ new Map();
+      for (const { layer } of layers) counts.set(layer, (counts.get(layer) ?? 0) + 1);
+      let missing = 1;
+      while (counts.has(missing)) missing++;
+      for (const { tj, layer } of layers)
+        if (counts.get(layer) > 1 || layer > missing) report("fec_layers", `/tracks/${tj}/repairLayer`, inst);
+      const chain = [
+        { layer: 0, tj: inst.layer0, pri: l0 && intIn(l0.priority, 192, 255) ? l0.priority : l0 && has(l0, "priority") ? null : 240 },
+        ...layers.map(({ tj, layer }) => {
+          const pr = trackAt(tj).priority;
+          return { layer, tj, pri: intIn(pr, 192, 255) ? pr : null };
+        })
+      ].sort((a, b) => a.layer - b.layer);
+      let prev = null;
+      for (const c of chain) {
+        if (c.pri === null) continue;
+        if (prev !== null && c.pri < prev) report("fec_priority", `/tracks/${c.tj}/priority`, inst);
+        prev = Math.max(prev ?? c.pri, c.pri);
+      }
+    }
+    const K = o.sourceSymbols;
+    const T = o.symbolSize;
+    const P0 = o.repairSymbols;
+    if (intIn(K, 1) && intIn(P0, 1)) {
+      let P = P0;
+      if (!inst.overlay)
+        for (const tj of repairs) {
+          const t = trackAt(tj);
+          if (intIn(t.repairLayer, 1) && intIn(t.repairSymbols, 1)) P += t.repairSymbols;
+        }
+      if (P > MAX_24 || K + P - 1 > MAX_24) report("fec_bounds", inst.path, inst);
+      else if (o.scheme === "reed-solomon" && K + P > RS_MAX_BLOCK) report("fec_bounds", inst.path, inst);
+    }
+    if (o.scheme === "raptorq" && intIn(K, 1) && K > RAPTORQ_MAX_K) report("fec_bounds", `${inst.path}/sourceSymbols`, inst);
+    if (intIn(T, 1)) {
+      if (o.scheme === "raptorq" && T % 8 !== 0) report("fec_bounds", `${inst.path}/symbolSize`, inst);
+      else if (o.blockProfile === "iso-ssbg1-v1" && T < ISO_MIN_T) report("fec_bounds", `${inst.path}/symbolSize`, inst);
+    }
+  }
+  const overlayTracks = new Set(insts.filter((i) => live(i) && i.overlay).map((i) => i.ti));
+  for (const ti of overlayTracks) {
+    const ofTrack = insts.filter((i) => i.ti === ti && live(i));
+    const ovs = ofTrack.filter((i) => i.overlay);
+    if (!overlays) {
+      for (const ov of ovs) report("fec_overlay_unsupported", `${ov.path}/scope`, ov);
+      for (const i of ofTrack) i.issues.length === 0 && i.issues.push({ code: "fec_overlay_unsupported", path: `${ovs[0].path}/scope` });
+      continue;
+    }
+    if (ovs.length > 1) for (const ov of ovs) report("fec_overlay", `${ov.path}/scope`, ov);
+    for (const ov of ovs)
+      if (ov.obj?.blockProfile !== "iso-ssbg1-v1") report("fec_overlay", `${ov.path}/blockProfile`, ov);
+    const cause = ovs.flatMap((ov) => ov.issues).find((x) => x.code === "fec_overlay");
+    if (cause) {
+      for (const ov of ovs) if (ov.issues.length === 0) ov.issues.push(cause);
+    }
+  }
+  return {
+    instances: insts.map((i) => ({
+      path: i.path,
+      track: typeof i.track.name === "string" ? i.track.name : null,
+      instanceId: i.id,
+      outcome: rejectAll || !i.unavailable && i.issues.length > 0 ? "violation" : i.unavailable ? "unavailable" : "ok",
+      issues: i.issues
+    })),
+    issues: all
+  };
+}
+
 // node_modules/@blockcast/mmt-transport/dist/multicast-tier.js
 function endpointKey(endpoint) {
   return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
@@ -19622,8 +19915,6 @@ var MmtpRouter = class {
   // Callbacks (legacy — used when per-track callbacks are not registered)
   #onVideoFrame = null;
   #onAudioFrame = null;
-  // Init segment (ftyp+moov) from MMTP MPU metadata — needed for MSE SourceBuffer
-  #onInitSegment = null;
   // Per-track init segment callbacks keyed by packetId
   #trackInitCallbacks = /* @__PURE__ */ new Map();
   // Track whether init has been delivered per physical stream — prevent duplicates
@@ -19886,11 +20177,10 @@ var MmtpRouter = class {
     };
   }
   /**
-   * Init segments delivered for a packetId with no `onTrackInit` handler
-   * since construction, whether the deprecated aggregate `onInitSegment`
-   * callback then received them or nothing did. A supported deployment reads
-   * 0 here; a non-zero value is the evidence that blocks removing the
-   * aggregate callback (MOQT-01, BLO-21181).
+   * Init segments rejected since construction because their packetId had no
+   * `onTrackInit` handler. A rejected init is delivered nowhere; there is no
+   * aggregate fallback (removed in 1.0.0, MOQT-01 / BLO-21181). A supported
+   * deployment reads 0 here.
    */
   get unmappedInitDeliveryCount() {
     return this.#unmappedInitDeliveries;
@@ -20067,20 +20357,10 @@ var MmtpRouter = class {
   onTrackPacket(packetId, cb) {
     this.#trackPacketCallbacks.set(packetId, cb);
   }
-  /**
-   * Register an init segment callback (ftyp+moov from MMTP MPU metadata).
-   * Receives an init only for a packetId with no `onTrackInit` handler.
-   *
-   * @deprecated Use onTrackInit(packetId, cb). Still delivered as a fallback;
-   * removed in the 1.0.0 major, no earlier than one minor release after this
-   * deprecation reaches the `latest` dist-tag (BLO-21181). Count fallback
-   * deliveries with `unmappedInitDeliveryCount`.
-   */
-  onInitSegment(cb) {
-    this.#onInitSegment = cb;
-  }
   /** Register an init segment callback for a specific MMTP packetId.
-   *  Called when FT=0 init arrives via direct source or FEC recovery. */
+   *  Called when FT=0 init arrives via direct source or FEC recovery. An init
+   *  for a packetId with no handler is rejected and counted by
+   *  `unmappedInitDeliveryCount`. */
   onTrackInit(packetId, cb) {
     this.#trackInitCallbacks.set(packetId, cb);
   }
@@ -21480,16 +21760,15 @@ var MmtpRouter = class {
     if (this.#trackInitDelivered.has(streamKey)) return;
     if (data.byteLength <= 8) return;
     this.#trackInitDelivered.add(streamKey);
+    const track = `packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`}`;
     const cb = this.#trackInitCallbacks.get(packetId);
-    if (cb) {
-      cb(data);
-    } else {
+    if (!cb) {
       this.#unmappedInitDeliveries++;
-      this.#onInitSegment?.(data);
+      console.log(`[MmtpRouter] Init rejected for ${track}: no onTrackInit handler`);
+      return;
     }
-    console.log(
-      `[MmtpRouter] Init delivered for packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`} (${data.byteLength}B)`
-    );
+    cb(data);
+    console.log(`[MmtpRouter] Init delivered for ${track} (${data.byteLength}B)`);
   }
   /**
    * Core MMTP packet processing — source packets → play + FEC, repair → FEC only.
@@ -22989,6 +23268,10 @@ function getMulticastGlobals() {
 function hasMulticastGateway() {
   return typeof getMulticastGlobals().multicast?.subscribe === "function";
 }
+function senderOf(event) {
+  const sourceAddress = event.sourceAddress;
+  return typeof sourceAddress === "string" ? sourceAddress : void 0;
+}
 function normalizeBytesEventDetail(detail) {
   const value = detail && typeof detail === "object" && "data" in detail ? detail.data : detail;
   if (value instanceof Uint8Array) return value;
@@ -23035,7 +23318,8 @@ var MulticastTransport = class {
     bytesReceived: 0,
     packetsDroppedUnregisteredPid: 0,
     packetsDroppedUnparseable: 0,
-    packetsDroppedSignaling: 0
+    packetsDroppedSignaling: 0,
+    packetsDroppedForeignSender: 0
   };
   // join() calls by how they resolved; see joinStats.
   #joinsSucceeded = 0;
@@ -23060,6 +23344,11 @@ var MulticastTransport = class {
   // per packet once a count outgrows the small-integer range.
   #acceptedBytesByPacketId = /* @__PURE__ */ new Map();
   #packetIds = null;
+  // The sender S this join's accepted packets came from, once known; see
+  // packetsDroppedForeignSender. Cleared by every join and by a silence
+  // failback, so a replacement publisher is not locked out.
+  #sender = void 0;
+  #lockedTo;
   // What the live join delivers with each accepted packet. A field, not a
   // listener closure, so an in-place admission change (setContext) applies
   // from the next packet on without rejoining.
@@ -23081,9 +23370,15 @@ var MulticastTransport = class {
   #joinGeneration = 0;
   // The provider to subscribe through; window.multicast when unset.
   #gateway;
+  /**
+   * `lockedTo` reads the sender another transport is locked to (a repair
+   * group follows its media join, whose publisher sends both). While it reads
+   * a sender, this join admits only that one; until then its own lock applies.
+   */
   constructor(onPacket, options = {}) {
     this.#onPacket = onPacket;
     this.#gateway = options.gateway;
+    this.#lockedTo = options.lockedTo;
   }
   static isAvailable() {
     return hasMulticastGateway();
@@ -23092,6 +23387,7 @@ var MulticastTransport = class {
     const generation = ++this.#joinGeneration;
     this.#releaseSubscription();
     this.#dataPlaneLive = false;
+    this.#sender = void 0;
     if (this.#disposed) return this.#declined(generation, "disposed");
     const gateway = this.#gateway ?? getMulticastGlobals().multicast;
     if (typeof gateway?.subscribe !== "function") {
@@ -23133,7 +23429,8 @@ var MulticastTransport = class {
       }
       this.#subscription = subscription;
       const live = () => !this.#disposed && generation === this.#joinGeneration;
-      const packetListener = subscriptionDeliversPacketBatches(subscription) ? {
+      const anySource = !config.sourceAddress && !config.senderAddress && !config.atsc3;
+      const packetListener = !anySource && subscriptionDeliversPacketBatches(subscription) ? {
         type: "packets",
         listener: (event) => {
           if (!live()) return;
@@ -23143,7 +23440,7 @@ var MulticastTransport = class {
         type: "bytes",
         listener: (event) => {
           if (!live()) return;
-          if (this.#deliver(event.detail)) this.#resetWatchdog();
+          if (this.#deliver(event.detail, senderOf(event))) this.#resetWatchdog();
         }
       };
       this.#packetListener = packetListener;
@@ -23234,13 +23531,13 @@ var MulticastTransport = class {
    * One packet from the subscription: filter, count, and hand it to the
    * callback. Returns whether it was delivered; the caller notes liveness.
    */
-  #deliver(detail) {
+  #deliver(detail, sourceAddress) {
     const packet = normalizeBytesEventDetail(detail);
     if (!packet) {
       this.#stats.packetsDroppedUnparseable++;
       return false;
     }
-    if (!this.#acceptPacket(packet)) return false;
+    if (!this.#acceptPacket(packet, sourceAddress)) return false;
     this.#onPacket(packet, this.#context);
     return true;
   }
@@ -23281,11 +23578,15 @@ var MulticastTransport = class {
       throw failures[0];
     }
   }
-  /** Feed a raw packet from an external source (e.g., AMT tunnel or ASM subscription). */
-  feedPacket(data, context) {
+  /**
+   * Feed a raw packet from an external source (e.g., AMT tunnel or ASM
+   * subscription). `sourceAddress` is the datagram's sender when the source
+   * knows it; see packetsDroppedForeignSender.
+   */
+  feedPacket(data, context, sourceAddress) {
     if (this.#disposed) return;
     const packet = data instanceof Uint8Array ? data : new Uint8Array(data);
-    if (!this.#acceptPacket(packet)) return;
+    if (!this.#acceptPacket(packet, sourceAddress)) return;
     this.#onPacket(packet, context);
     this.#resetWatchdog();
   }
@@ -23435,6 +23736,10 @@ var MulticastTransport = class {
   get withdrawnPacketIdDrops() {
     return this.#withdrawnPacketIdDrops;
   }
+  /** The sender this join is locked to; undefined until one is known. */
+  get sender() {
+    return this.#sender;
+  }
   /** Whether a subscription is live: joined, and not yet released or replaced. */
   get joined() {
     return this.#subscription !== null;
@@ -23597,11 +23902,16 @@ var MulticastTransport = class {
     this.#withdrawnPacketIds.clear();
   }
   /** The ingress filter; an accepted packet is counted here, once. */
-  #acceptPacket(packet) {
+  #acceptPacket(packet, sourceAddress) {
+    const owner = this.#lockedTo?.() ?? this.#sender;
+    if (sourceAddress !== void 0 && owner !== void 0 && sourceAddress !== owner) {
+      this.#stats.packetsDroppedForeignSender++;
+      return false;
+    }
     const packetId = readMMTPPacketId(packet);
     if (packetId === null) {
       if (!this.#packetIds) {
-        this.#countAccepted(packet, null);
+        this.#countAccepted(packet, null, sourceAddress);
         return true;
       }
       this.#stats.packetsDroppedUnparseable++;
@@ -23612,14 +23922,15 @@ var MulticastTransport = class {
       return false;
     }
     if (!this.#packetIds || this.#packetIds.has(packetId)) {
-      this.#countAccepted(packet, packetId);
+      this.#countAccepted(packet, packetId, sourceAddress);
       return true;
     }
     this.#recordUnregisteredPidDrop(packetId);
     return false;
   }
   /** Receive counters for one accepted packet; `packetId` is null when it has none. */
-  #countAccepted(packet, packetId) {
+  #countAccepted(packet, packetId, sourceAddress) {
+    this.#sender ??= sourceAddress;
     this.#stats.packetsReceived++;
     this.#stats.bytesReceived += packet.byteLength;
     if (packetId === null) return;
@@ -23690,6 +24001,7 @@ var MulticastTransport = class {
       console.warn(
         `[MulticastTransport] No packets for ${this.#failbackWindowMs}ms; failing back to MoQ`
       );
+      this.#sender = void 0;
       this.#onFailback({ kind: "silence", windowMs: this.#failbackWindowMs });
     }, delayMs);
   }
@@ -26440,7 +26752,7 @@ function catalogAmtNetworkSource(networkSource) {
   }
   return void 0;
 }
-function intIn(value, min, max) {
+function intIn2(value, min, max) {
   return Number.isInteger(value) && value >= min && value <= max;
 }
 function catalogAtsc3NetworkSource(networkSource) {
@@ -26448,12 +26760,12 @@ function catalogAtsc3NetworkSource(networkSource) {
   for (const raw of entries) {
     if (!raw || typeof raw !== "object") continue;
     const ns = raw;
-    if (ns.type !== "atsc3" || !intIn(ns.frequency, 1, Number.MAX_SAFE_INTEGER)) continue;
+    if (ns.type !== "atsc3" || !intIn2(ns.frequency, 1, Number.MAX_SAFE_INTEGER)) continue;
     const slsUri = typeof ns.slsUri === "string" ? ns.slsUri.trim() : "";
     return {
       frequency: ns.frequency,
-      ...intIn(ns.plpId, 0, 63) ? { plpId: ns.plpId } : {},
-      ...intIn(ns.serviceId, 0, 65535) ? { serviceId: ns.serviceId } : {},
+      ...intIn2(ns.plpId, 0, 63) ? { plpId: ns.plpId } : {},
+      ...intIn2(ns.serviceId, 0, 65535) ? { serviceId: ns.serviceId } : {},
       ...slsUri ? { slsUri } : {}
     };
   }
@@ -27704,10 +28016,6 @@ var MulticastManager = class {
   onTrackPacket(packetId, cb) {
     this.#router.onTrackPacket(packetId, cb);
   }
-  /** @deprecated Use onTrackInit(packetId, cb); see MmtpRouter.onInitSegment. */
-  onInitSegment(cb) {
-    this.#router.onInitSegment(cb);
-  }
   onTrackInit(packetId, cb) {
     this.#router.onTrackInit(packetId, cb);
   }
@@ -27931,15 +28239,21 @@ var MulticastManager = class {
         tracks: Object.freeze(endpoint.tracks.map(({ name, packetId }) => Object.freeze({ name, packetId }))),
         ...endpoint.flow === void 0 ? {} : { flow: endpoint.flow }
       };
-      const onPacket = (packet) => {
-        if (!released) this.#router.feedPacket(packet, "multicast", ingress);
+      let sender;
+      const onPacket = (packet, sourceAddress) => {
+        if (released) return;
+        if (sourceAddress !== void 0 && sourceAddress !== (this.#transport.sender ?? (sender ??= sourceAddress))) return;
+        this.#router.feedPacket(packet, "multicast", ingress);
       };
       const fail = (error) => console.warn(`[MulticastManager] repair group ${endpoint.group}:${endpoint.port} not joined`, error);
       if (typeof provider === "function") {
         Promise.resolve().then(() => provider(endpoint, onPacket)).then((release2) => released ? safely(release2) : releases.push(release2), fail);
         continue;
       }
-      const transport = new MulticastTransport((packet) => onPacket(packet), { gateway: provider });
+      const transport = new MulticastTransport((packet) => onPacket(packet), {
+        gateway: provider,
+        lockedTo: () => this.#transport.sender
+      });
       releases.push(() => transport.dispose());
       void transport.join({
         sourceAddress: endpoint.source,
@@ -28218,8 +28532,8 @@ var MulticastManager = class {
    *  transport attribution in FEC path counters.
    *  The `router` accessor above is already public.
    */
-  feedPacket(data, ingress) {
-    this.#transport.feedPacket(data, ingress);
+  feedPacket(data, ingress, sourceAddress) {
+    this.#transport.feedPacket(data, ingress, sourceAddress);
   }
   /**
    * Declare how packets given to feedPacket() reach this manager. A consumer
@@ -31716,6 +32030,7 @@ export {
   splitH264SampleNalUnits,
   unwrapMulticastPacket,
   validateCmsfMmtpCatalog,
+  validateFecCatalog,
   validateMulticastContainerContract,
   validateRepairTrackFields,
   validateSwitchingSetTiming,