@amazon/vinyl 3.2.2 → 3.2.3-next.20261001143710

package/dist/test/integ.js

@@ -5832,7 +5832,8 @@
       return true;
     }
     /**
-     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     * Executes a provided function once per each key/value pair in the Map,
+     * ordered from least recently used to most.
      *
      * @param callback A callback to invoke for every element in the cache.
      * @param thisArg Value to use as this when executing callback
@@ -5877,8 +5878,8 @@
       let value = void 0;
       const memoized = () => {
         if (!cached) {
-          cached = true;
           value = inner();
+          cached = true;
         }
         return value;
       };
@@ -5907,9 +5908,9 @@
       const memoized = (...args) => {
         const key = keyProvider(...args);
         if (!hasValue || cachedKey !== key) {
-          hasValue = true;
-          cachedKey = key;
           cachedValue = inner(...args);
+          cachedKey = key;
+          hasValue = true;
         }
         return cachedValue;
       };
@@ -5972,7 +5973,8 @@
     charCode === 13 || // '\r' (carriage return)
     charCode === 10;
   }
-  var encodedEntitiesRegex = /&(#(\d+)|\w+);/gi;
+  var encodedEntitiesRegex = /&(?:#(?:x([\da-f]+)|(\d+))|(\w+));/gi;
+  var MAX_CODE_POINT = 1114111;
   var predefinedDecodeEntities = /* @__PURE__ */ new Map([
     ["apos", "'"],
     ["amp", "&"],
@@ -5981,20 +5983,22 @@
     ["quot", '"']
   ]);
   function decodeEntities(str, namedEntities = predefinedDecodeEntities) {
-    if (encodedEntitiesRegex.test(str)) {
-      return str.replace(
-        encodedEntitiesRegex,
-        (substring, entityName, codePoint) => {
-          if (codePoint !== void 0)
-            return String.fromCharCode(parseInt(codePoint));
-          const entityValue = namedEntities.get(entityName.toLowerCase());
-          if (!entityValue) return substring;
-          return entityValue;
+    return str.replace(
+      encodedEntitiesRegex,
+      (substring, hex, decimal, entityName) => {
+        var _a3;
+        if (hex == null && decimal == null) {
+          return (_a3 = namedEntities.get(entityName.toLowerCase())) != null ? _a3 : substring;
         }
-      );
-    } else {
-      return str;
-    }
+        const codePoint = hex != null ? parseInt(hex, 16) : parseInt(decimal, 10);
+        if (codePoint > MAX_CODE_POINT || isSurrogate(codePoint))
+          return substring;
+        return String.fromCodePoint(codePoint);
+      }
+    );
+  }
+  function isSurrogate(codePoint) {
+    return codePoint >= 55296 && codePoint <= 57343;
   }
   var standardEntityValueToNames = flipMap(predefinedDecodeEntities);
   function eqStr(a, b, ignoreCase = false) {
@@ -8056,7 +8060,11 @@ ${this.lastInitStack}` : "";
       __publicField(this, "onDownloadSpeedChange", () => {
         var _a3;
         const downlink = (_a3 = this.deps.networkInformation) == null ? void 0 : _a3.downlink;
-        const estimatedSpeed = downlink ? downlink * 1024 * 1024 : this.options.unknownDownlinkBandwidthEstimate;
+        const estimatedSpeed = downlink ? (
+          // Megabits are decimal, matching the measured `bytes * 8 / seconds`
+          // this estimate is averaged with.
+          downlink * 1e6
+        ) : this.options.unknownDownlinkBandwidthEstimate;
         updateStatMetrics(
           this._metrics.estimatedDownlinkBandwidth,
           estimatedSpeed,
@@ -8546,38 +8554,41 @@ ${this.lastInitStack}` : "";
       this.dispatch("request", { requestInfo });
       let lastResult = null;
       let currentTry = 0;
-      do {
-        ++currentTry;
-        const attemptInfo = {
-          currentTry,
-          timestamp: Date.now()
-        };
-        this.dispatch("requestAttemptStart", {
-          requestInfo,
-          attemptInfo
-        });
-        lastResult = await this.doRequest(
-          requestInfo,
-          requestOptions,
-          attemptInfo,
-          timeoutController
-        ).catch((reason) => {
-          var _a4;
-          const completeInfo = {
-            ok: false,
-            type: ((_a4 = requestOptions.abort) == null ? void 0 : _a4.aborted()) ? "abort" /* ABORT */ : "internal" /* INTERNAL */,
-            requestInfo,
-            reason,
-            willRetry: false,
-            timestamp: Date.now(),
-            retryAfter: null
+      try {
+        do {
+          ++currentTry;
+          const attemptInfo = {
+            currentTry,
+            timestamp: Date.now()
           };
-          return { info: completeInfo, response: null };
-        });
+          this.dispatch("requestAttemptStart", {
+            requestInfo,
+            attemptInfo
+          });
+          lastResult = await this.doRequest(
+            requestInfo,
+            requestOptions,
+            attemptInfo,
+            timeoutController
+          ).catch((reason) => {
+            var _a4;
+            const completeInfo = {
+              ok: false,
+              type: ((_a4 = requestOptions.abort) == null ? void 0 : _a4.aborted()) ? "abort" /* ABORT */ : "internal" /* INTERNAL */,
+              requestInfo,
+              reason,
+              willRetry: false,
+              timestamp: Date.now(),
+              retryAfter: null
+            };
+            return { info: completeInfo, response: null };
+          });
+          this.reportMetricsEntry(lastResult.info);
+          this.dispatch("requestAttemptComplete", lastResult.info);
+        } while (!lastResult.info.ok && lastResult.info.willRetry);
+      } finally {
         timeoutController.dispose();
-        this.reportMetricsEntry(lastResult.info);
-        this.dispatch("requestAttemptComplete", lastResult.info);
-      } while (!lastResult.info.ok && lastResult.info.willRetry);
+      }
       this.dispatch("requestComplete", lastResult.info);
       if (lastResult.info.ok) return lastResult.response;
       else throw new RequestError(lastResult.response, lastResult.info);
@@ -8942,6 +8953,13 @@ ${this.lastInitStack}` : "";
   function bufferToByteArray(buffer) {
     return buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
   }
+  function bufferToArrayBuffer(buffer) {
+    if (buffer instanceof ArrayBuffer) return buffer;
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength
+    );
+  }
   function buffersEqual(bufferA, bufferB) {
     if (bufferA === bufferB) return true;
     if (!bufferA && !bufferB) return true;
@@ -10268,7 +10286,11 @@ ${this.lastInitStack}` : "";
         logVerbose(this, "nextAd");
         try {
           const ad = await adBreakState2.nextAd();
-          if (this.disposed || adBreakState2.completedReason) return;
+          if (this.disposed) return;
+          if (adBreakState2.completedReason) {
+            if (!this.adBreakState) await nextBreak();
+            return;
+          }
           if (ad) {
             this.startAd(ad);
           } else {
@@ -10402,12 +10424,18 @@ ${this.lastInitStack}` : "";
         const currProgress = pC.currentTimePercent;
         const progressStart = adState.timeStart / pC.duration;
         if (!adState.quartile.first && currProgress > 0.25 && progressStart < AD_START_TOLERANCE) {
+          adState.quartile.first = true;
+          logDebug(this, "adFirstQuartile", adState.ad);
           this.dispatch("adFirstQuartile", createAdProgressEvent(adState));
         }
         if (!adState.quartile.midpoint && currProgress > 0.5 && progressStart < 0.25 + AD_START_TOLERANCE) {
+          adState.quartile.midpoint = true;
+          logDebug(this, "adMidpoint", adState.ad);
           this.dispatch("adMidpoint", createAdProgressEvent(adState));
         }
         if (!adState.quartile.third && currProgress > 0.75 && progressStart < 0.5 + AD_START_TOLERANCE) {
+          adState.quartile.third = true;
+          logDebug(this, "adThirdQuartile", adState.ad);
           this.dispatch("adThirdQuartile", createAdProgressEvent(adState));
         }
       }
@@ -11143,7 +11171,9 @@ ${this.lastInitStack}` : "";
         (length) => length === validators.length
       );
       return createDeepValidator(
-        substitute(locale10.tuple, { value: validators.join(", ") }),
+        substitute(locale10.tuple, {
+          value: validators.map((validator) => validator.description).join(", ")
+        }),
         (input, options, path) => {
           const errors = [];
           errors.push(
@@ -11448,7 +11478,7 @@ ${this.lastInitStack}` : "";
   };
   var _NumberSchema = class _NumberSchema extends ValueSchema {
     /**
-     * The base Object validator validating that the input is an object.
+     * The base NumberSchema instance validating that the input is a number.
      */
     static get base() {
       if (this._base == null)
@@ -11734,7 +11764,7 @@ ${this.lastInitStack}` : "";
   };
   var _StringSchema = class _StringSchema extends ValueSchema {
     /**
-     * The base SetSchema instance validating that the input is a Set.
+     * The base StringSchema instance validating that the input is a string.
      */
     static get base() {
       if (this._base == null)
@@ -12515,6 +12545,7 @@ ${this.lastInitStack}` : "";
     const url = resolveUrl(assetListUrl, baseUrl);
     const response = await requestWithRetry(url);
     const json = await readResponseBody(response, "json");
+    const assetListBaseUrl = response.url || url;
     const assets = (_a3 = json.ASSETS) != null ? _a3 : [];
     const ads = assets.map((asset, i) => {
       var _a4;
@@ -12522,7 +12553,14 @@ ${this.lastInitStack}` : "";
         id: `${rangeId}-${i}`,
         startTime,
         duration: (_a4 = asset.DURATION) != null ? _a4 : null,
-        uri: resolveUrl(asset.URI, baseUrl)
+        // Each Asset-Description "URI" MUST be an absolute URI, so the base
+        // only applies to non-conforming lists. As a leniency (not a spec
+        // rule), resolve against the asset list the URI was read from, as
+        // for any relative reference in a retrieved document (RFC 3986
+        // §5.1.3): asset lists are commonly served by an ad server rather
+        // than alongside the playlist.
+        // @see https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-22#appendix-D.2
+        uri: resolveUrl(asset.URI, assetListBaseUrl)
       };
     });
     return { ads, skipControl: parseSkipControl(json["SKIP-CONTROL"]) };
@@ -12813,7 +12851,7 @@ ${this.lastInitStack}` : "";
       __publicField(this, "_disposed", false);
       __publicField(this, "messageHandler", (event) => {
         this.dispatch("message", {
-          message: event.message.buffer
+          message: bufferToArrayBuffer(event.message)
         });
       });
       __publicField(this, "errorHandler", () => {
@@ -12956,11 +12994,7 @@ ${this.lastInitStack}` : "";
       return "StandardCommonMediaKeySession";
     }
     generateRequest() {
-      const initData = this.initData;
-      return this.session.generateRequest(
-        this.initDataType,
-        initData instanceof ArrayBuffer ? initData : initData.buffer
-      ).catch(createDrmErrorHandler());
+      return this.session.generateRequest(this.initDataType, this.initData).catch(createDrmErrorHandler());
     }
     update(key) {
       if (this.disposed) throw new DisposedError();
@@ -13068,7 +13102,7 @@ ${this.lastInitStack}` : "";
       __publicField(this, "_disposed", false);
       __publicField(this, "messageHandler", (event) => {
         this.dispatch("message", {
-          message: event.message.buffer
+          message: bufferToArrayBuffer(event.message)
         });
       });
       __publicField(this, "errorHandler", () => {
@@ -13966,7 +14000,7 @@ ${this.lastInitStack}` : "";
 
   // src/drm/util/extractContentId.ts
   function extractContentId(initData) {
-    const bufferStr = bufferToUtf16(initData.buffer);
+    const bufferStr = bufferToUtf16(bufferToArrayBuffer(initData));
     const matches = bufferStr.match(/skd:\/\/(.+)$/);
     if (!matches) {
       throw new ValidationError("No contentId match", ErrorOrigin.MEDIA);
@@ -14632,20 +14666,21 @@ ${this.lastInitStack}` : "";
     let abs = Math.abs(value);
     const years = Math.floor(abs / Y);
     abs -= years * Y;
-    const months = Math.floor(abs % Y / M);
+    const months = Math.floor(abs / M);
     const days = Math.floor(abs % M / D);
     const hours = Math.floor(abs % D / H);
     const minutes = Math.floor(abs % H / I);
     const seconds = abs % I;
-    let isoString = `${sign}P`;
-    if (years > 0) isoString += `${years}Y`;
-    if (months > 0) isoString += `${months}M`;
-    if (days > 0) isoString += `${days}D`;
-    isoString += "T";
-    if (hours > 0) isoString += `${hours}H`;
-    if (minutes > 0) isoString += `${minutes}M`;
-    if (seconds > 0 || !value) isoString += `${roundToNearest(seconds, 1e-3)}S`;
-    return isoString;
+    let date = "";
+    if (years > 0) date += `${years}Y`;
+    if (months > 0) date += `${months}M`;
+    if (days > 0) date += `${days}D`;
+    let time = "";
+    if (hours > 0) time += `${hours}H`;
+    if (minutes > 0) time += `${minutes}M`;
+    if (seconds > 0) time += `${roundToNearest(seconds, 1e-3)}S`;
+    if (!date && !time) time = "0S";
+    return `${sign}P${date}${time && `T${time}`}`;
   }
 
   // ../vinyl-mpd-parser/src/error/parsingError.ts
@@ -16791,14 +16826,16 @@ ${this.lastInitStack}` : "";
         return;
       }
       const byteLength = streamingSegment.data.byteLength;
-      if (byteLength > appendSize) {
+      const remaining = byteLength - this.appendOffset;
+      const firstAppend = this.appendOffset === 0;
+      if (remaining > appendSize) {
         const newOffset = this.appendOffset + appendSize;
         const chunk = streamingSegment.data.slice(
           this.appendOffset,
           newOffset
         );
         await sourceBufferController.append(chunk);
-        if (this.appendOffset === 0) {
+        if (firstAppend) {
           this.buffered.push(streamingSegment);
         }
         this.appendOffset = newOffset;
@@ -16807,9 +16844,13 @@ ${this.lastInitStack}` : "";
           `appended chunk, this.appendOffset: ${this.appendOffset}`
         );
       } else {
-        await sourceBufferController.append(streamingSegment.data);
-        this.appendOffset = streamingSegment.data.byteLength;
-        this.buffered.push(streamingSegment);
+        await sourceBufferController.append(
+          firstAppend ? streamingSegment.data : streamingSegment.data.slice(this.appendOffset)
+        );
+        this.appendOffset = byteLength;
+        if (firstAppend) {
+          this.buffered.push(streamingSegment);
+        }
       }
       if (!tail) this.refreshHead();
     }
@@ -17092,6 +17133,7 @@ ${this.lastInitStack}` : "";
       this.activateDisposer.dispose();
       this.activateDisposer = null;
       ++this.durationToken;
+      this.durationSet = false;
       try {
         URL.revokeObjectURL(this.objectUrl);
       } catch (error) {
@@ -17640,6 +17682,7 @@ ${this.lastInitStack}` : "";
     dispose() {
       this._disposed = true;
       this.callbacks.length = 0;
+      this.n = 0;
     }
     notify(value, previousValue) {
       this._changeId++;
@@ -17755,23 +17798,26 @@ ${this.lastInitStack}` : "";
       providers[key] = provider;
       current[key] = provider.value;
     }
-    return externalData(current, (setData) => {
+    let published = __spreadValues({}, current);
+    const publish = (setData) => {
+      published = __spreadValues({}, current);
+      setData(published);
+    };
+    return externalData(published, (setData) => {
       const subs = [];
+      let subscribing = true;
       for (const key of keys) {
-        const provider = providers[key];
-        let isFirst = true;
         subs.push(
-          provider.onData((value) => {
-            if (isFirst) {
-              isFirst = false;
-              return;
-            }
+          providers[key].onData((value) => {
             current[key] = value;
-            setData(__spreadValues({}, current));
+            if (!subscribing) publish(setData);
           })
         );
       }
-      setData(current);
+      subscribing = false;
+      if (keys.some((key) => current[key] !== published[key])) {
+        publish(setData);
+      }
       return () => {
         for (const unsub of subs) unsub();
       };
@@ -19194,10 +19240,16 @@ ${this.lastInitStack}` : "";
     return out;
   }
   function isTextAdaptationSet(adaptationSet) {
+    var _a3;
     if (adaptationSet.contentType === "text") return true;
     const mt = adaptationSet.mimeType;
     if (mt && mt.startsWith("text/")) return true;
-    return false;
+    return ((_a3 = adaptationSet.Representation) != null ? _a3 : []).some(
+      (representation) => {
+        var _a4;
+        return (_a4 = representation.mimeType) == null ? void 0 : _a4.startsWith("text/");
+      }
+    );
   }
   function isSidecarTextMime(mimeType) {
     if (mimeType == null) return true;
@@ -19455,7 +19507,7 @@ ${this.lastInitStack}` : "";
     const cues = [];
     const styles = [];
     let i = 1;
-    while (i < lines.length && lines[i] !== "") i++;
+    while (i < lines.length && lines[i] !== "" && !lines[i].includes("-->")) i++;
     while (i < lines.length) {
       if (lines[i] === "") {
         i++;
@@ -22617,7 +22669,9 @@ ${this.lastInitStack}` : "";
       audioConfig: null,
       videoConfig: null,
       audioDecodeTime: 0,
-      videoDecodeTime: 0
+      videoDecodeTime: 0,
+      audioTrackId: null,
+      videoTrackId: null
     };
     return { transmux: (data2) => transmux(state, data2) };
   }
@@ -22672,11 +22726,12 @@ ${this.lastInitStack}` : "";
         sampleRate: sampleRate2,
         audioSpecificConfig: buildAudioSpecificConfig(firstFrame)
       };
+      state.audioTrackId = 1;
       buildInitSegment(
         state,
         moov(
           audioTrak({
-            trackId: 1,
+            trackId: state.audioTrackId,
             sampleRate: state.audioConfig.sampleRate,
             channelCount: state.audioConfig.channelConfiguration,
             sampleEntry: mp4aSampleEntry(state.audioConfig)
@@ -22703,7 +22758,7 @@ ${this.lastInitStack}` : "";
     const duration = frames.length * samplesPerFrame / sampleRate;
     const moofBox = moof({
       sequenceNumber: state.sequenceNumber++,
-      trackId: 1,
+      trackId: state.audioTrackId,
       baseDecodeTime: state.audioDecodeTime,
       samples
     });
@@ -22809,9 +22864,10 @@ ${this.lastInitStack}` : "";
     if (!state.initSegment && (audioConfig || videoConfig)) {
       const traks = [];
       if (videoConfig) {
+        state.videoTrackId = traks.length + 1;
         traks.push(
           videoTrak({
-            trackId: traks.length + 1,
+            trackId: state.videoTrackId,
             width: videoConfig.width,
             height: videoConfig.height,
             sampleEntry: avc1SampleEntry(videoConfig)
@@ -22819,9 +22875,10 @@ ${this.lastInitStack}` : "";
         );
       }
       if (audioConfig) {
+        state.audioTrackId = traks.length + 1;
         traks.push(
           audioTrak({
-            trackId: traks.length + 1,
+            trackId: state.audioTrackId,
             sampleRate: audioConfig.sampleRate,
             channelCount: audioConfig.channelConfiguration,
             sampleEntry: mp4aSampleEntry(audioConfig)
@@ -22832,8 +22889,8 @@ ${this.lastInitStack}` : "";
     }
     const fragments = [];
     let duration = 0;
-    if (videoConfig && videoNalus.length > 0) {
-      const trackId = 1;
+    if (videoConfig && videoNalus.length > 0 && state.videoTrackId != null) {
+      const trackId = state.videoTrackId;
       const accessUnits = [];
       let pendingParams = [];
       for (const nalu of videoNalus) {
@@ -22900,8 +22957,8 @@ ${this.lastInitStack}` : "";
         duration = accessUnits.length * frameDuration / MPEG_TIMESCALE;
       }
     }
-    if (audioConfig && audioRawData && audioFrames.length > 0) {
-      const trackId = videoConfig ? 2 : 1;
+    if (audioConfig && audioRawData && audioFrames.length > 0 && state.audioTrackId != null) {
+      const trackId = state.audioTrackId;
       const samplesPerFrame = 1024;
       const samples = [];
       const parts = [];
@@ -23201,7 +23258,11 @@ ${this.lastInitStack}` : "";
       async getSegment(time, affordance = 0) {
         var _a3;
         const playlist = await data2.getMediaPlaylist(playlistUri);
-        const playlistBaseUrl = resolveUrl(playlistUri, baseUrl);
+        const playlistBaseUrl = getPlaylistBaseUrl(
+          playlist,
+          playlistUri,
+          baseUrl
+        );
         const segments = buildSegmentTimeline(
           deps,
           playlistBaseUrl,
@@ -23248,9 +23309,13 @@ ${this.lastInitStack}` : "";
     const variant2 = data2.mainPlaylist.variants[0];
     const media = await data2.getMediaPlaylist(variant2.uri);
     const contentDuration = media.ended ? media.segments.reduce((sum, s) => sum + s.duration, 0) : null;
-    const playlistBaseUrl = resolveUrl(variant2.uri, data2.baseUrl);
+    const playlistBaseUrl = getPlaylistBaseUrl(media, variant2.uri, data2.baseUrl);
     return discoverHlsInterstitials(media, playlistBaseUrl, contentDuration);
   }
+  function getPlaylistBaseUrl(playlist, playlistUri, mainBaseUrl) {
+    var _a3;
+    return (_a3 = playlist.baseUrl) != null ? _a3 : resolveUrl(playlistUri, mainBaseUrl);
+  }
 
   // src/track/hls/createDefaultHlsManifestTransformer.ts
   function createDefaultHlsManifestTransformer(deps) {
@@ -23383,8 +23448,11 @@ ${this.lastInitStack}` : "";
     const variantUrl = resolveUrl(uri, baseUrl);
     const response = await requestWithRetry(variantUrl, requestInit, { abort });
     const text = await readResponseBody(response, "text");
-    const queryParams = parseQueryParams(response.url || variantUrl);
-    return parseMediaPlaylist(text, defines, queryParams);
+    const playlistUrl = response.url || variantUrl;
+    const queryParams = parseQueryParams(playlistUrl);
+    return __spreadProps(__spreadValues({}, parseMediaPlaylist(text, defines, queryParams)), {
+      baseUrl: playlistUrl
+    });
   }
   function parseQueryParams(url) {
     const queryStart = url.indexOf("?");
@@ -23836,6 +23904,9 @@ ${this.lastInitStack}` : "";
       for (const cachedTrack of this.trackCache.values()) {
         cachedTrack.clearPrefetch();
       }
+      for (const adTracks of this.adTracksByParent.values()) {
+        for (const adTrack of adTracks.values()) adTrack.clearPrefetch();
+      }
     }
     clearQueue() {
       this.setQueue(this._current, []);
@@ -27307,6 +27378,47 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         await flush();
         expect(c.currentAdBreak).toBeNull();
       });
+      it("still enters a pending break when skipped while its ads resolve", async () => {
+        var _a3;
+        const c = createController();
+        let resolveAds = () => void 0;
+        const entered = [];
+        await setContent(
+          c,
+          trackAds(
+            makeBreak({
+              id: "b1",
+              startTime: 0,
+              duration: 30,
+              ads: () => new Promise((resolve) => {
+                resolveAds = resolve;
+              })
+            }),
+            makeBreak({
+              id: "b2",
+              startTime: 1,
+              duration: 30,
+              ads: [
+                {
+                  id: "a2",
+                  startTime: 1,
+                  duration: 10,
+                  uri: "ad2.m3u8"
+                }
+              ]
+            })
+          )
+        );
+        c.on("adBreakEntered", (e) => entered.push(e.adBreak.id));
+        updateTime(2);
+        await flush();
+        expect(entered).toEqual(["b1"]);
+        c.skipAdBreak();
+        resolveAds([]);
+        await flush();
+        expect(entered).toEqual(["b1", "b2"]);
+        expect((_a3 = c.currentAdBreak) == null ? void 0 : _a3.id).toBe("b2");
+      });
     });
     describe("a break with no ads", () => {
       it("completes immediately with a resume position and plays no ad", async () => {
@@ -27587,6 +27699,35 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         await flush();
         expect(thirds).toEqual(["a1"]);
       });
+      it("dispatches each quartile at most once per ad", async () => {
+        const c = createController();
+        const events = [];
+        c.on("adFirstQuartile", () => events.push("first"));
+        c.on("adMidpoint", () => events.push("mid"));
+        c.on("adThirdQuartile", () => events.push("third"));
+        await setContent(
+          c,
+          trackAds(makeBreak({ startTime: 0, duration: 10 }))
+        );
+        updateTime(0);
+        await flush();
+        playbackController.dispatch("playing", {});
+        playbackController.duration = 10;
+        playbackController.playbackRate = 1;
+        for (const [percent, time] of [
+          [0.3, 3],
+          [0.4, 4],
+          [0.6, 6],
+          [0.7, 7],
+          [0.8, 8],
+          [0.9, 9]
+        ]) {
+          playbackController.currentTimePercent = percent;
+          updateTime(time);
+          await flush();
+        }
+        expect(events).toEqual(["first", "mid", "third"]);
+      });
       it("does not emit quartiles or throw when the ad duration is zero", async () => {
         const c = createController();
         const events = [];
@@ -28630,8 +28771,9 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         clientAttributes: {}
       }, overrides);
     }
-    function okJsonResponse(body) {
+    function okJsonResponse(body, url = "") {
       return {
+        url,
         ok: true,
         status: 200,
         headers: { get: () => null },
@@ -28800,7 +28942,7 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
           "https://example.com/ads.json"
         );
         expect(ads.length).toBe(2);
-        expect(ads[0].uri).toBe("https://cdn.example.com/media/mid1.m3u8");
+        expect(ads[0].uri).toBe("https://example.com/mid1.m3u8");
         expect(ads[0].duration).toBe(10);
         expect(ads[1].uri).toBe("https://cdn.example.com/mid2.m3u8");
         expect(ads[1].duration).toBeNull();
@@ -28808,6 +28950,33 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         globalThis.fetch = origFetch;
       }
     });
+    it("resolves relative asset URIs against the redirected asset list URL", async () => {
+      const origFetch = globalThis.fetch;
+      const fetchSpy = jasmine.createSpy("fetch").and.resolveTo(
+        okJsonResponse(
+          { ASSETS: [{ URI: "mid1.m3u8" }] },
+          "https://ads.example.net/v2/ads.json"
+        )
+      );
+      globalThis.fetch = fetchSpy;
+      try {
+        const playlist = makePlaylist({
+          dateRanges: [
+            makeRange({
+              duration: 10,
+              clientAttributes: {
+                "X-ASSET-LIST": "https://example.com/redirected.json"
+              }
+            })
+          ]
+        });
+        const breaks = await discoverHlsInterstitials(playlist, BASE);
+        const ads = await resolveValueProvider(breaks[0].ads);
+        expect(ads[0].uri).toBe("https://ads.example.net/v2/mid1.m3u8");
+      } finally {
+        globalThis.fetch = origFetch;
+      }
+    });
     it("caches the X-ASSET-LIST fetch across calls", async () => {
       const origFetch = globalThis.fetch;
       const fetchSpy = jasmine.createSpy("fetch").and.resolveTo(okJsonResponse({ ASSETS: [{ URI: "x.m3u8" }] }));
@@ -30185,10 +30354,10 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         });
       });
       describe("when created", () => {
-        it("calls session.generateRequest() with the initData buffer", () => {
+        it("calls session.generateRequest() with the initData", () => {
           expect(
             mediaKeySession.generateRequest
-          ).toHaveBeenCalledOnceWith("cenc", initData.buffer);
+          ).toHaveBeenCalledOnceWith("cenc", initData);
           mediaKeySession.generateRequest.calls.reset();
           const arrayBuffer = new ArrayBuffer(0);
           standardCommonMediaKeySession = new StandardCommonMediaKeySession(
@@ -30201,6 +30370,21 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
             mediaKeySession.generateRequest
           ).toHaveBeenCalledOnceWith("cenc", arrayBuffer);
         });
+        it("passes only the bytes an offset initData view spans", () => {
+          mediaKeySession.generateRequest.calls.reset();
+          const view = new Uint8Array([1, 2, 3, 4, 5]).subarray(1, 4);
+          standardCommonMediaKeySession = new StandardCommonMediaKeySession(
+            mediaKeySession,
+            mimeType,
+            "cenc",
+            view
+          );
+          const [, passed] = mediaKeySession.generateRequest.calls.mostRecent().args;
+          expectIterableEquals(
+            new Uint8Array(bufferToArrayBuffer(passed)),
+            [2, 3, 4]
+          );
+        });
         describe("when session.generateRequest rejects", () => {
           it("emits an error event", async () => {
             mediaKeySession.generateRequest.and.rejectWith(
@@ -32658,6 +32842,13 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         ).toBe("example0");
       });
     });
+    describe("with an offset view", () => {
+      it("reads only the bytes the view spans", () => {
+        const padded = createContentIdByteArray("\0\0skd://example0\0\0");
+        const view = padded.subarray(4, padded.byteLength - 4);
+        expect(extractContentId(view)).toBe("example0");
+      });
+    });
     describe("without match", () => {
       it("throws ValidationError", () => {
         expect(() => {
@@ -35951,6 +36142,24 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
           expect(sourceBufferController.append).toHaveBeenCalledTimes(1);
         });
       });
+      describe("when the append budget grows while a segment is partly appended", () => {
+        it("appends only the bytes remaining in the segment", async () => {
+          bufferingController.dispose();
+          bufferingController = createBufferingController({
+            maxAppendSize: { audio: 500 },
+            minBuffer: 6
+          });
+          bufferingController.activate();
+          setSegmentList([200, 400]);
+          await open();
+          await setTime(5);
+          expect(getMostRecentAppendData().byteLength).toBe(300);
+          sourceBufferController.append.calls.reset();
+          await setTime(15.5);
+          const appended = sourceBufferController.append.calls.allArgs().map(([data2]) => data2.byteLength);
+          expect(appended[0]).toBe(100);
+        });
+      });
       describe("when contentType is undefined", () => {
         it("uses DEFAULT_MAX_APPEND_SIZE for max byte length", async () => {
           setSegmentList(
@@ -36712,6 +36921,28 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         );
         expect(() => controller.deactivate()).not.toThrow();
       });
+      it("does not report a re-activated media source as ready to append", async () => {
+        open();
+        await flushPromises();
+        const firstRef = controller.createSourceBuffer("audio", "audio/mp4");
+        expect(controller.readyToAppend).withContext("ready on the first media source").toBeTrue();
+        firstRef.dispose();
+        controller.deactivate();
+        const secondSource = new MockMediaSource();
+        implementEventFakes(secondSource);
+        secondSource.addSourceBuffer.and.callFake(
+          () => new MockSourceBuffer()
+        );
+        mediaSourceFactory.and.returnValue(secondSource);
+        controller.activate();
+        await flushPromises();
+        controller.createSourceBuffer("audio", "audio/mp4");
+        expect(controller.readyToAppend).withContext("duration not yet set on the new media source").toBeFalse();
+        secondSource.readyState = "open";
+        secondSource.dispatchEvent(mockEvent("sourceopen"));
+        await flushPromises();
+        expect(controller.readyToAppend).withContext("ready once the new duration is set").toBeTrue();
+      });
     });
     describe("duration", () => {
       it("sets media source duration after sourceopen", async () => {
@@ -38474,6 +38705,11 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
       expect(drmProtectionValidator.isValid({ keySystem: 123 })).toBeFalse();
     });
   });
+  describe("ALL_CONTENT_TYPES", () => {
+    it("provides a comprehensive list of all content types", () => {
+      expectTypeStrictlyEquals(true);
+    });
+  });
 
   // test/unit/streaming/MediaTimeline.test.ts
   describe("getMediaPeriodAtTime", () => {
@@ -41230,6 +41466,18 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
       expect(result.length).toBe(1);
       expect(result[0].language).toBe("es");
     });
+    it("discovers a text AdaptationSet by its Representation mimeType", () => {
+      const m = manifest3(`
+            <AdaptationSet lang="fr">
+              <Representation id="fr-sub" mimeType="text/vtt" bandwidth="100">
+                <BaseURL>fr.vtt</BaseURL>
+              </Representation>
+            </AdaptationSet>`);
+      const result = discoverDashTextTracks(m, baseUrl);
+      expect(result.length).toBe(1);
+      expect(result[0].language).toBe("fr");
+      expect(result[0].uri).toBe("https://example.com/dash/fr.vtt");
+    });
     it("classifies kind=captions when role=caption is set", () => {
       const m = manifest3(`
             <AdaptationSet contentType="text" lang="en" mimeType="text/vtt">
@@ -41284,6 +41532,10 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
             </AdaptationSet>`);
       expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
     });
+    it("skips a non-text AdaptationSet with no Representation", () => {
+      const m = manifest3(`<AdaptationSet contentType="audio"/>`);
+      expect(discoverDashTextTracks(m, baseUrl)).toEqual([]);
+    });
     it("skips text AdaptationSets carrying segmented codecs (stpp/wvtt)", () => {
       const m = manifest3(`
             <AdaptationSet contentType="text" mimeType="application/mp4" codecs="stpp">
@@ -42315,6 +42567,29 @@ hi`;
       expect(cues.length).toBe(1);
       expect(cues[0].text).toBe("hi");
     });
+    it("parses a cue that follows the signature with no blank line", () => {
+      const text = `WEBVTT
+00:00:01.000 --> 00:00:02.000
+hi
+
+00:00:03.000 --> 00:00:04.000
+there`;
+      const cues = parseWebVtt(text).cues;
+      expect(cues.length).toBe(2);
+      expect(cues[0].startTime).toBe(1);
+      expect(cues[0].text).toBe("hi");
+      expect(cues[1].text).toBe("there");
+    });
+    it("keeps header lines as header when a cue follows with no blank line", () => {
+      const text = `WEBVTT
+Kind: captions
+00:00:01.000 --> 00:00:02.000
+hi`;
+      const cues = parseWebVtt(text).cues;
+      expect(cues.length).toBe(1);
+      expect(cues[0].id).toBeNull();
+      expect(cues[0].text).toBe("hi");
+    });
     it("handles trailing identifier without timing line", () => {
       const text = `WEBVTT
 
@@ -43704,6 +43979,13 @@ x`);
     });
   });
 
+  // test/unit/text/TextTrack.test.ts
+  describe("ALL_TEXT_TRACK_EVENTS", () => {
+    it("provides a comprehensive list of all text track events", () => {
+      expectTypeStrictlyEquals(true);
+    });
+  });
+
   // test/unit/text/VttCueStyle.test.ts
   describe("VttCueStyle", () => {
     describe("isVttCue", () => {
@@ -48810,6 +49092,29 @@ x`);
       );
       fetchSpy.and.callThrough();
     });
+    it("resolves segment and map URIs against the media playlist baseUrl", async () => {
+      const variant2 = createVariant("v1.m3u8", 128e3);
+      const playlist = __spreadProps(__spreadValues({}, createMediaPlaylist([10])), {
+        // The media playlist was redirected away from the main playlist's
+        // directory.
+        baseUrl: "https://redirect.example.net/hls/v1.m3u8"
+      });
+      const manifestData2 = createManifestData([variant2], playlist);
+      const fetchSpy = spyOn(globalThis, "fetch").and.callFake(
+        () => Promise.resolve(new Response(new ArrayBuffer(100)))
+      );
+      const timeline = buildHlsMediaTimeline(deps, manifestData2);
+      const quality = timeline.periods[0].qualities[0];
+      const segment = await quality.getSegment(5);
+      await segment.initData();
+      await segment.data();
+      const urls = fetchSpy.calls.allArgs().map(([input]) => String(input));
+      expect(urls).toEqual([
+        "https://redirect.example.net/hls/init.mp4",
+        "https://redirect.example.net/hls/seg0.m4s"
+      ]);
+      fetchSpy.and.callThrough();
+    });
     it("getDuration throws when no variants", async () => {
       const manifestData2 = createManifestData([], createMediaPlaylist([]));
       const timeline = buildHlsMediaTimeline(deps, manifestData2);
@@ -49487,6 +49792,29 @@ x`);
         "https://example.com/path/audio.m3u8"
       );
     });
+    it("sets the baseUrl from the response URL", async () => {
+      mockRequester.request.and.callFake(() => {
+        const resp = new Response(mediaM3u8);
+        Object.defineProperty(resp, "url", {
+          value: "https://redirected.com/hls/audio.m3u8"
+        });
+        return Promise.resolve(resp);
+      });
+      const playlist = await fetchMediaPlaylist({
+        uri: "audio.m3u8",
+        baseUrl: "https://example.com/path/main.m3u8",
+        defines: void 0
+      });
+      expect(playlist.baseUrl).toBe("https://redirected.com/hls/audio.m3u8");
+    });
+    it("falls back to the requested URL when the response has no URL", async () => {
+      const playlist = await fetchMediaPlaylist({
+        uri: "audio.m3u8",
+        baseUrl: "https://example.com/path/main.m3u8",
+        defines: void 0
+      });
+      expect(playlist.baseUrl).toBe("https://example.com/path/audio.m3u8");
+    });
     it("resolves EXT-X-DEFINE:QUERYPARAM from the playlist URL query string", async () => {
       mockRequester.request.and.callFake(
         () => Promise.resolve(
@@ -52120,49 +52448,6 @@ x`);
           expect(track2.clearPrefetch).toHaveBeenCalledTimes(1);
         }
       });
-      it("also clears prefetch on preloaded ad tracks", async () => {
-        pending(
-          "REVIEW: the refactor no longer proactively preloads ad tracks discovered on the current track (ad tracks are created on adEntered only). Decide: intended removal (delete this spec) or regression (restore discovery-time ad preloading)."
-        );
-        const [main] = createLoadOptionsList(1);
-        trackController.load(main);
-        const track2 = trackController.activeTrack;
-        const ads = {
-          trackUri: main.uri,
-          adBreaks: [
-            {
-              id: "b1",
-              startTime: 5,
-              duration: 10,
-              placement: "midroll",
-              restrict: {},
-              once: false,
-              resumeOffset: null,
-              playoutLimit: null,
-              resolutionTimeOffset: null,
-              skipControl: () => null,
-              ads: () => Promise.resolve([
-                {
-                  id: "a1",
-                  startTime: 5,
-                  duration: 10,
-                  uri: "https://ads/a.m3u8"
-                }
-              ])
-            }
-          ]
-        };
-        track2.ads = ads;
-        track2.dispatch("adsChange", { previous: null, current: ads });
-        await Promise.resolve();
-        await Promise.resolve();
-        await Promise.resolve();
-        const adTrack = trackController.getCachedTrack(
-          "https://ads/a.m3u8"
-        );
-        trackController.clearPrefetch();
-        expect(adTrack.clearPrefetch).toHaveBeenCalled();
-      });
     });
     describe("clearQueue", () => {
       it("clears the queue without unloading the current track", async () => {
@@ -52667,6 +52952,19 @@ x`);
         expect(adTrack).withContext("midroll ad track warmed").toBeDefined();
         expect(adTrack.preload).toHaveBeenCalled();
       });
+      it("clears prefetch on a preloaded ad track", async () => {
+        const [main] = createLoadOptionsList(1);
+        factoryGivingBreak(main.uri, []);
+        trackController.load(main);
+        await flushAds();
+        deps.adController.dispatch("adPreload", {
+          adBreak: midrollBreak("https://ads/mid.m3u8")
+        });
+        await flushAds();
+        const adTrack = created.get("https://ads/mid.m3u8");
+        trackController.clearPrefetch();
+        expect(adTrack.clearPrefetch).toHaveBeenCalledTimes(1);
+      });
       it("ignores adPreload when there is no parent track", () => {
         expect(
           () => deps.adController.dispatch("adPreload", {
@@ -52862,21 +53160,6 @@ x`);
           objectContaining23({ startTime: 3 })
         );
       });
-      it("skips the deferred resume if interrupted before the frame", async () => {
-        pending(
-          "REVIEW: content resume on adBreakCompleted is now synchronous (no deferred/interruptible frame), so this interruption guard no longer applies. Decide: intended or restore deferral."
-        );
-        const [main] = createLoadOptionsList(1);
-        trackController.load(main);
-        const changeSpy = createEventSpy(trackController, "trackActivated");
-        deps.adController.dispatch("adBreakCompleted", {
-          adBreak: adBreak("midroll"),
-          resumePosition: 5
-        });
-        deps.adController.currentAd = __spreadProps(__spreadValues({}, ad), { id: "other" });
-        await clock.tick();
-        expect(changeSpy).not.toHaveBeenCalled();
-      });
       it("advances to the next track after a postroll ad when one exists", async () => {
         var _a3;
         const list = createLoadOptionsList(2);
@@ -55810,13 +56093,15 @@ x`);
             await expectTrackCanSeekTo(player, 5);
           });
           it("can continue seeking", async () => {
-            const nextEnded = nextEventAsPromise(player, "ended");
+            let nextEnded = nextEventAsPromise(player, "ended");
             await expectTrackCanSeekTo(player, 999);
             await nextEnded;
             await expectTrackCanSeekTo(player, 0);
             await expectTrackCanSeekTo(player, 5);
             await expectTrackCanSeekTo(player, 15);
             await expectTrackCanSeekTo(player, 35);
+            await player.play();
+            nextEnded = nextEventAsPromise(player, "ended");
             await expectTrackCanSeekTo(player, 999);
             await nextEnded;
           });