@blockcast/mmt-container 0.4.1 → 0.5.0-main.34c7b9c2cfa0

package/src/repair-fetch.ts

@@ -22,15 +22,23 @@
  * everything.
  *
  * Priority (from the block's class, see `repairPriorityForClass`):
- *   - P0 (keyframe / unknown) and P1 (audio) dispatch as soon as they are
- *     enqueued, with no cap. Each has its own fail deadline, and a cap would
- *     turn a recoverable protected block into a stall; their number is
- *     already bounded by the blocks one fail window can hold.
- *   - P2 (delta) dispatches only while no P0/P1 is queued or in flight,
- *     earliest absolute fail deadline first. Enqueuing a P0/P1 aborts every
- *     in-flight P2 (`repair-preempted`), which returns to the queue while its
- *     block is unresolved. A P2 that never ran before its block resolved is
- *     reported as `repair-deferred`.
+ *   - P0 (keyframe / unknown) dispatches as soon as it is enqueued, with no
+ *     cap. Each has its own fail deadline, and a cap would turn a
+ *     recoverable protected block into a stall; their number is already
+ *     bounded by the blocks one fail window can hold. A P0 block that lies
+ *     below a RAP the receiver already holds complete is not requested at
+ *     all (`moot-rap`), and a P0 FETCH still running when such a RAP
+ *     arrives is cancelled (`repair-stopped`, `moot`): the receiver resumes
+ *     from that RAP (draft-ramadan-moq-fec §11.4.2).
+ *   - P1 (audio) dispatches, uncapped, while no P0 is queued or in flight;
+ *     P2 (delta) only while no P0/P1 is, earliest absolute fail deadline
+ *     first (§11.4.5 item 3).
+ *   - Only a P0 FETCH the scheduler actually sends aborts the in-flight P1
+ *     and P2 FETCHes (`repair-preempted`), which return to the queue while
+ *     their blocks are unresolved: a keyframe request that is refused, moot
+ *     or otherwise never sent cancels nothing (§11.4.5 item 3), and an audio
+ *     request never preempts. A P2 that never ran before its block resolved
+ *     is reported as `repair-deferred`.
  *   - A block reclassified to a higher class while its P2 fetch is in flight
  *     is re-issued at once under the new class's wire priority: the running
  *     FETCH is aborted (FETCH_CANCEL) and a new one sent.
@@ -394,6 +402,18 @@ export type RepairSkipReason =
   | 'presentation-delay-unavailable'
   /** A lost SS_ID in an undelimited span had no §7.5 anchor to extend it from. */
   | 'range-no-anchor'
+  /**
+   * The block lost more sources than its repair group carries symbols
+   * (sources + RSB_length < K'): no FETCH of the group can complete it, and
+   * when multicast already delivered the whole group the relay could serve
+   * only duplicates (BLO-50082).
+   */
+  | 'group-cannot-complete'
+  /**
+   * The keyframe-bearing block lies below a RAP the receiver already holds
+   * complete, so its repair would be moot (draft-ramadan-moq-fec §11.4.2).
+   */
+  | 'moot-rap'
 
 /**
  * Which term set a FETCH's deadline (BLO-33597): the multicast wait, the
@@ -477,6 +497,8 @@ export interface RepairFetchHost {
   closeIsoHoles?(packetId: number, catalogTrackName: string | undefined, start: number, length: number): void
   clearRepairForBlock(sbn: number, packetId: number, catalogTrackName?: string): void
   processRepairFromMoQ(packet: Uint8Array, ownerPacketId?: number, catalogTrackName?: string): void
+  /** This scheduler can request unicast repair: protected flows keep pending entries for it (optional). */
+  setUnicastRepair?(enabled: boolean): void
   noteRepairScheduling(
     type: 'repair-preempted' | 'repair-deferred',
     sbn: number,
@@ -504,6 +526,23 @@ export interface RepairFetchHost {
     packetId: number,
     catalogTrackName?: string,
   ): void
+  /** A running FETCH the scheduler stopped, and why (optional). */
+  noteRepairStopped?(
+    reason: RepairStopReason,
+    sbn: number,
+    packetId: number,
+    catalogTrackName?: string,
+  ): void
+  /**
+   * Whether a complete RAP above SS_ID `ssId` already reached the stream
+   * (optional; absent, none ever has). Under the bc-provenance profile only
+   * an admitted RAP counts (multicast-01 §7.2.7).
+   */
+  rapCompleteAbove?(packetId: number, catalogTrackName: string | undefined, ssId: number): boolean
+  /** Observe each complete RAP reaching a stream (optional; called synchronously). */
+  addRapCompleteObserver?(
+    observer: (packetId: number, catalogTrackName: string | undefined, ssId: number) => void,
+  ): () => void
   /**
    * A FETCH the scheduler admitted and handed to the transport (optional):
    * every attempt, a retry or a reprioritised restart included.
@@ -517,7 +556,22 @@ export interface RepairFetchHost {
   ): void
 }
 
-type StopReason = 'preempted' | 'reprioritized' | 'expired' | 'resolved' | 'reset' | 'disposed'
+/**
+ * Why the scheduler ended a running FETCH (the transport cancels it on the
+ * wire): preempted by a sent keyframe FETCH, reissued at a new class's
+ * priority, past its deadline, its block resolved, track reset or a newer
+ * request for the block, dispose, or `moot` (a RAP above the block arrived
+ * complete first, draft-ramadan-moq-fec §11.4.2).
+ */
+export type RepairStopReason =
+  | 'preempted'
+  | 'reprioritized'
+  | 'expired'
+  | 'resolved'
+  | 'reset'
+  | 'disposed'
+  | 'moot'
+type StopReason = RepairStopReason
 
 interface FetchRun {
   readonly controller: AbortController
@@ -592,6 +646,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
   ) {
     throw new Error('[RepairFetch] rangeTransport needs repairEpochReference and a host that reports undelimited losses')
   }
+  mc.setUnicastRepair?.(true)
   const entries = new Map<string, RepairEntry>()
   const warnedNoTarget = new Set<string>()
   let disposed = false
@@ -629,9 +684,43 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     entry.running = null
     run.stopped = reason
     run.controller.abort()
-    // A preempted delta returns to the queue; until it runs again nothing is
+    // A preempted request returns to the queue; until it runs again nothing is
     // in flight that could land, so the block goes back to its multicast wait.
     if (reason === 'preempted') releaseHold(entry)
+    mc.noteRepairStopped?.(reason, entry.sbn, entry.packetId, entry.catalogTrackName)
+  }
+
+  /** The last SS_ID the entry covers, or undefined while its block is undelimited. */
+  const lastSsId = (entry: RepairEntry): number | undefined => {
+    if (entry.range) return entry.sbn + entry.range.holeLength - 1
+    const length = symbolCounts(entry.sbn, entry.packetId, entry.catalogTrackName)?.authoredLength
+    return length === undefined ? undefined : entry.sbn + length - 1
+  }
+
+  /** A keyframe request whose whole block lies below a RAP already held complete. */
+  const moot = (entry: RepairEntry): boolean => {
+    if (entry.priority !== 0) return false
+    const last = lastSsId(entry)
+    if (last === undefined) return false
+    try {
+      return mc.rapCompleteAbove?.(entry.packetId, entry.catalogTrackName, last) === true
+    } catch {
+      return false
+    }
+  }
+
+  /** Drop a request no FETCH will be sent for, and say why. */
+  const skip = (entry: RepairEntry, reason: RepairSkipReason, rttMs: number | null, budgetMs: number): void => {
+    retire(entry)
+    releaseHold(entry)
+    clearEntry(entry)
+    mc.noteRepairSkipped(
+      reason,
+      { rttMs, budgetMs, priority: entry.priority },
+      entry.sbn,
+      entry.packetId,
+      entry.catalogTrackName,
+    )
   }
 
   /** The keyframe budget for a P0 block, or null: absent, throwing or not positive. */
@@ -656,24 +745,24 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
   }
 
   /**
-   * RTT admission: send only a FETCH the measured round trip says can land
-   * before the entry's deadline. A refused entry is released, not queued: the
+   * Admission: send only a FETCH whose repair group can complete the block
+   * and that the measured round trip says can land before the entry's
+   * deadline. A refused entry is released, not queued: the
    * deadline only gets closer. Returns the admitting RTT, or null when refused.
    */
   const admit = (entry: RepairEntry, now: number): number | null => {
     const budgetMs = entry.deadlineAt - now
     const rttMs = readRtt()
-    if (rttMs !== null && rttMs < budgetMs) return rttMs
-    retire(entry)
-    releaseHold(entry)
-    clearEntry(entry)
-    mc.noteRepairSkipped(
-      rttMs === null ? 'rtt-unmeasured' : 'rtt-exceeds-budget',
-      { rttMs, budgetMs, priority: entry.priority },
-      entry.sbn,
-      entry.packetId,
-      entry.catalogTrackName,
-    )
+    const reason: RepairSkipReason | null =
+      !entry.range && !groupCanComplete(entry.sbn, entry.packetId, entry.catalogTrackName)
+        ? 'group-cannot-complete'
+        : rttMs === null
+          ? 'rtt-unmeasured'
+          : rttMs < budgetMs
+            ? null
+            : 'rtt-exceeds-budget'
+    if (reason === null) return rttMs
+    skip(entry, reason, rttMs, budgetMs)
     return null
   }
 
@@ -682,16 +771,21 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     if (entry.expiry !== undefined) clearTimeout(entry.expiry)
   }
 
-  const urgentOutstanding = (): boolean => {
+  /** Whether any entry of priority below `priority` is queued or in flight. */
+  const outstandingBelow = (priority: RepairPriority): boolean => {
     for (const entry of entries.values()) {
-      if (entry.priority < 2) return true
+      if (entry.priority < priority) return true
     }
     return false
   }
 
-  const preemptDeltas = (): void => {
+  /**
+   * A keyframe FETCH is being sent: cancel every in-flight audio and delta
+   * FETCH (§11.4.5 item 3). Called only for a FETCH actually sent.
+   */
+  const preemptBestEffort = (): void => {
     for (const entry of entries.values()) {
-      if (entry.priority !== 2 || !entry.running) continue
+      if (entry.priority === 0 || !entry.running) continue
       stop(entry, 'preempted')
       note('repair-preempted', entry)
     }
@@ -721,8 +815,14 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
   /** `counted` is false for a reprioritisation restart, which is no retry. */
   const start = (entry: RepairEntry, counted = true): void => {
     const now = performance.now()
+    if (moot(entry)) {
+      skip(entry, 'moot-rap', readRtt(), entry.deadlineAt - now)
+      return
+    }
     const rttMs = admit(entry, now)
     if (rttMs === null) return
+    // Before the transport sees this request, so the cancels go out first.
+    if (entry.priority === 0) preemptBestEffort()
     if (counted) entry.attempts++
     mc.noteRepairFetchSent?.(entry.priority, entry.sbn, entry.packetId, entry.catalogTrackName, {
       rttMs,
@@ -756,7 +856,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         // A fetch still running at its block's fail bound can no longer land
         // in time. Cancel it here rather than trust the transport or the FEC
         // layer's resolution to end it: a hung P0/P1 left running would keep
-        // urgentOutstanding() true and gate every P2 for the session.
+        // outstandingBelow() true and gate every P1/P2 for the session.
         if (entry.deadlineAt <= now) {
           stop(entry, 'expired')
           retire(entry)
@@ -775,9 +875,13 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
       queued.push(entry)
     }
     for (const entry of queued) {
-      if (entry.priority < 2) start(entry)
+      if (entry.priority === 0) start(entry)
     }
-    if (urgentOutstanding()) return
+    if (outstandingBelow(1)) return
+    for (const entry of queued) {
+      if (entry.priority === 1) start(entry)
+    }
+    if (outstandingBelow(2)) return
     queued
       .filter((entry) => entry.priority === 2)
       .sort((a, b) => a.deadlineAt - b.deadlineAt || a.order - b.order)
@@ -961,7 +1065,6 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         stop(entry, 'reprioritized')
         start(entry, false)
       }
-      preemptDeltas()
       dispatch()
       return
     }
@@ -1137,7 +1240,6 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     }
     entries.set(key, entry)
     noteBudget(entry, deadline.extensionMs)
-    if (entry.priority < 2) preemptDeltas()
     dispatch()
   })
 
@@ -1226,15 +1328,33 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
       }
       entries.set(entry.key, entry)
       entry.expiry = setTimeout(dispatch, Math.max(0, entry.deadlineAt - performance.now()) + 1)
-      preemptDeltas()
       dispatch()
     })
   }
 
+  // A RAP arrived complete: a keyframe FETCH below it is moot (§11.4.2). The
+  // observer runs inside the frame push, so the cancel waits for a microtask
+  // rather than re-entering the FEC layer through the hold release.
+  const removeRapObserver = mc.addRapCompleteObserver?.((packetId) => {
+    queueMicrotask(() => {
+      if (disposed) return
+      for (const entry of [...entries.values()]) {
+        if (entry.packetId !== packetId || !entry.running || !moot(entry)) continue
+        stop(entry, 'moot')
+        retire(entry)
+        releaseHold(entry)
+        clearEntry(entry)
+      }
+      dispatch()
+    })
+  })
+
   return () => {
     disposed = true
+    mc.setUnicastRepair?.(false)
     removeResetObserver()
     removeLifecycleObserver()
+    removeRapObserver?.()
     for (const entry of [...entries.values()]) {
       clearEntry(entry)
       if (entry.running) releaseHold(entry)

package/test-vectors/catalog/negative/multicast-auth-padded-key.json

@@ -20,7 +20,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg=",
     "keyId": "2026-08",

package/test-vectors/catalog/negative/multicast-auth-reused-track-format.json

@@ -30,7 +30,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg",
     "keyId": "2026-08",

package/test-vectors/catalog/negative/multicast-auth-root-dotted-key.json

@@ -30,7 +30,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg",
     "keyId": "2026-08",

package/test-vectors/catalog/negative/multicast-auth-trailing-pad-bits.json

@@ -20,7 +20,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbh",
     "keyId": "2026-08",

package/test-vectors/repair-policy-v1.json

@@ -0,0 +1,113 @@
+{
+  "version": 1,
+  "description": "Receiver repair policy (draft-ramadan-moq-fec-01 Section 11.4.2 and Section 11.4.5 item 3, Blockcast/moqcast-draft PR #2 @ 3162ef93). Which repair FETCHes a receiver sends, which it cancels, and which it never sends. Hand-authored from the specification, NOT generated by any implementation (BLO-49776).",
+  "scope": [
+    "Section 11.4 applies only to a multicast or AMT leg with a MoQ session (fec-01 11.4). These cases describe that leg; a receiver with no repair FETCH path records ABSENT, not a pass.",
+    "schedulerCases drive a repair scheduler. Every block spans K' = 4 SS_IDs, so block B covers SS_IDs B..B+3. Track video is a source track (packetId 1, keyframe or delta blocks); track audio is packetId 2 (audio blocks). A block is named track/SS_Start.",
+    "Best-effort (delta and audio) requests in schedulerCases are presumed covered by unexpired credit under fec-01 11.4.5 item 2; that credit is a precondition of each case, not something the case exercises.",
+    "A RAP 'held complete at ssId' is a keyframe access unit at SS_ID ssId that the receiver holds complete: admitted complete under the multicast-01 7.2.7 profile, received or recovered complete outside it. A block lies below it when the block's last SS_ID is less than ssId; a RAP at or inside the block does not make the block moot.",
+    "fetched lists every FETCH the receiver sends, in order. cancelled lists every sent FETCH it then cancels (FETCH_CANCEL on the wire). skipped names requests made but not sent, with the receiver's reason; stopped names sent FETCHes stopped, with the stop reason. A list not given is expected empty.",
+    "assistedCases drive one block of a protected flow (multicast-01 7.2.7) that is one symbol short of SSB_length, with unlisted repair symbols pooled for it. Each unlisted symbol triggers one unlisted-assisted decode in a scratch decoder; outcome 'fail' is a failed decode, 'recover' a decode whose recovered data unit admission accepts, 'recover-unadmitted' a decode whose recovered data unit admission refuses.",
+    "status names where a case's rule comes from: 'fec-01' is a -01 requirement; 'libmmt interpretation' is our reading where -01 is silent; 'regression' rows were already required at moqcast-draft main 615a9a8 and are kept to pin standing behaviour.",
+    "A keyframe request refused before its FETCH is sent (libmmt's reliable-path RTT check) is libmmt-local and deviates from the fec-01 11.4.2 MUST, so it is pinned in libmmt's own suite (repair-fetch-keyframe-budget.test.ts), not here. The 11.4.5 item 3 rule that a block 11.4.2 does not request cancels nothing is exercised by keyframe-below-complete-rap-not-requested."
+  ],
+  "schedulerCases": [
+    {
+      "name": "keyframe-below-complete-rap-not-requested",
+      "status": "fec-01",
+      "rule": "fec-01 11.4.2: a keyframe-bearing block at its FEC deadline is requested unless it lies below a RAP already held complete; 11.4.5 item 3: a block whose repair 11.4.2 does not request cancels nothing (case a).",
+      "ops": [
+        { "op": "fire", "track": "video", "block": 20, "class": "delta" },
+        { "op": "rapHeld", "ssId": 4 },
+        { "op": "fire", "track": "video", "block": 0, "class": "keyframe" }
+      ],
+      "expect": {
+        "fetched": ["video/20"],
+        "skipped": [{ "block": "video/0", "reason": "moot-rap" }]
+      }
+    },
+    {
+      "name": "control-rap-inside-block-is-requested",
+      "status": "libmmt interpretation",
+      "rule": "Control for the case above. fec-01 does not define 'lies below'; libmmt reads it so that a RAP at the block's own last SS_ID is part of the block, so the block is not below it and is requested.",
+      "ops": [
+        { "op": "rapHeld", "ssId": 3 },
+        { "op": "fire", "track": "video", "block": 0, "class": "keyframe" }
+      ],
+      "expect": { "fetched": ["video/0"] }
+    },
+    {
+      "name": "rap-completes-mid-fetch-cancels",
+      "status": "regression",
+      "rule": "fec-01 11.4.2 (already a SHOULD at main 615a9a8): a RAP completing while a keyframe repair is outstanding makes that repair moot and the receiver cancels it; a block above the RAP keeps its FETCH (case b).",
+      "ops": [
+        { "op": "fire", "track": "video", "block": 0, "class": "keyframe" },
+        { "op": "fire", "track": "video", "block": 8, "class": "keyframe" },
+        { "op": "rapComplete", "ssId": 5 }
+      ],
+      "expect": {
+        "fetched": ["video/0", "video/8"],
+        "cancelled": ["video/0"],
+        "stopped": [{ "block": "video/0", "reason": "moot" }]
+      }
+    },
+    {
+      "name": "audio-request-preempts-nothing",
+      "status": "fec-01",
+      "rule": "fec-01 11.4.5 item 3: only the keyframe repair 11.4.2 requests cancels best-effort FETCHes; an audio request cancels nothing.",
+      "ops": [
+        { "op": "fire", "track": "video", "block": 20, "class": "delta" },
+        { "op": "fire", "track": "audio", "block": 0, "class": "audio" }
+      ],
+      "expect": { "fetched": ["video/20", "audio/0"] }
+    },
+    {
+      "name": "sent-keyframe-repair-cancels-delta-and-audio",
+      "status": "regression",
+      "rule": "fec-01 11.4.5 item 3 (standing at main 615a9a8): a keyframe repair FETCH that is sent cancels the outstanding delta and audio FETCHes (case c-pos).",
+      "ops": [
+        { "op": "fire", "track": "video", "block": 20, "class": "delta" },
+        { "op": "fire", "track": "audio", "block": 0, "class": "audio" },
+        { "op": "fire", "track": "video", "block": 40, "class": "keyframe" }
+      ],
+      "expect": {
+        "fetched": ["video/20", "audio/0", "video/40"],
+        "cancelled": ["video/20", "audio/0"],
+        "stopped": [
+          { "block": "video/20", "reason": "preempted" },
+          { "block": "audio/0", "reason": "preempted" }
+        ]
+      }
+    }
+  ],
+  "assistedCases": [
+    {
+      "name": "two-failed-assisted-decodes-then-refused",
+      "status": "fec-01",
+      "rule": "multicast-01 7.2.7 step 2, referenced by fec-01 11.4: at most two unlisted-assisted decodes may fail per block; a failed decode's pooled symbol is discarded and a fresh one retried; a third is refused (case d).",
+      "decodes": ["fail", "fail", "fail"],
+      "expect": { "scratchDecodes": 2, "refused": 1, "recovered": false }
+    },
+    {
+      "name": "assisted-decode-recovers-on-retry",
+      "status": "fec-01",
+      "rule": "Control for the case above: after one failed decode, the retry on a fresh pooled symbol recovers the block (case d).",
+      "decodes": ["fail", "recover"],
+      "expect": { "scratchDecodes": 2, "refused": 0, "recovered": true }
+    },
+    {
+      "name": "recovered-but-unadmitted-is-unrecovered",
+      "status": "fec-01",
+      "rule": "multicast-01 7.2.7 / fec-01 11.4.2: a data unit recovered but refused by admission does not complete the block; the block stays unrecovered and is still due its repair at the FEC deadline (case e).",
+      "decodes": ["recover-unadmitted"],
+      "expect": { "scratchDecodes": 1, "refused": 0, "recovered": false }
+    },
+    {
+      "name": "unadmitted-recovery-counts-toward-decode-cap",
+      "status": "fec-01",
+      "rule": "multicast-01 7.2.7: a decode none of whose recovered packets is admitted recovers nothing, so it counts toward the two-decode cap like a failed decode (case e).",
+      "decodes": ["recover-unadmitted", "fail", "fail"],
+      "expect": { "scratchDecodes": 2, "refused": 1, "recovered": false }
+    }
+  ]
+}

package/dist/manifest-auth-plan.d.ts

@@ -1,31 +0,0 @@
-import type { ManifestKey } from '@blockcast/mmt-manifest-verify';
-import { type ResolvedMulticastAuthFlow } from './multicast-auth-catalog.js';
-/**
- * The bc-provenance version 2 plan a receiver binds from one catalog
- * (draft-ramadan-moq-multicast-01 7.2.6): the key set, `minEpoch`, and one
- * flow per protected endpoint. The record verifier and the 7.2.7 state machine
- * consume it; this plan holds no verification state.
- */
-export interface ManifestAuthPlan {
-    keys: readonly ManifestKey[];
-    minEpoch: number;
-    flows: readonly ResolvedMulticastAuthFlow[];
-    /** Every `manifestTrack` a flow names, for a unicast receiver to subscribe. */
-    manifestTracks: readonly string[];
-    /** The key that signs a record of `kid` at `epoch`; `undefined` drops it.
-     * Key selection only: it does not apply `minEpoch`, which the record
-     * verifier checks (BLO-49771). */
-    keyFor(kid: number, epoch: number): Uint8Array | undefined;
-    /** The flow whose records arrive on `(S, G, manifestPort)`. */
-    flowForManifestPort(source: string, groupAddress: string, manifestPort: number): ResolvedMulticastAuthFlow | undefined;
-    /** The flow a manifest track mirrors. */
-    flowForManifestTrack(manifestTrack: string): ResolvedMulticastAuthFlow | undefined;
-}
-/** Build the plan, or `undefined` for an unprotected catalog. Throws where
- * `resolveMulticastAuthCatalog` does: no key set, or authentication pinned
- * by `requireAuth` on a catalog without `multicast.auth`. */
-export declare function createManifestAuthPlan(catalog: unknown, options?: {
-    requireAuth?: boolean;
-    catalogNamespace?: string;
-}): ManifestAuthPlan | undefined;
-//# sourceMappingURL=manifest-auth-plan.d.ts.map

package/dist/manifest-auth-plan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest-auth-plan.d.ts","sourceRoot":"","sources":["../src/manifest-auth-plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAIL,KAAK,yBAAyB,EAC/B,MAAM,6BAA6B,CAAA;AAEpC;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,SAAS,WAAW,EAAE,CAAA;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,SAAS,yBAAyB,EAAE,CAAA;IAC3C,+EAA+E;IAC/E,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC;;sCAEkC;IAClC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAA;IAC1D,+DAA+D;IAC/D,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS,CAAA;IACtH,yCAAyC;IACzC,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS,CAAA;CACnF;AAED;;6DAE6D;AAC7D,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,gBAAgB,GAAG,SAAS,CAkB9B"}