@videojs/spf 10.0.0-beta.30 → 10.0.0-beta.32

package/dist/dev/network/bandwidth-estimator.d.ts

@@ -2,21 +2,21 @@
 /**
  * Dual EWMA Bandwidth Estimator
  *
- * Estimates available bandwidth using two EWMA calculations with different
- * half-lives, taking the minimum of both. This approach (from Shaka Player):
+ * Estimates available bandwidth using two EWMA calculations with different half-lives, taking the minimum of both. This
+ * approach (from Shaka Player):
  *
  * - **Fast EWMA** (2s half-life): Reacts quickly to bandwidth drops
  * - **Slow EWMA** (5s half-life): Provides stability during fluctuations
  * - **min(fast, slow)**: Adapts down quickly, up slowly
  *
- * This naturally provides asymmetric behavior needed for good QoE:
- * avoiding stalls (quick downgrade) while preventing oscillation (slow upgrade).
+ * This naturally provides asymmetric behavior needed for good QoE: avoiding stalls (quick downgrade) while preventing
+ * oscillation (slow upgrade).
  */
 /**
  * Bandwidth estimator state.
  *
- * This state structure will be managed by O1 (State Container).
- * Functions in this module operate on this state immutably.
+ * This state structure will be managed by O1 (State Container). Functions in this module operate on this state
+ * immutably.
  */
 interface BandwidthState {
   /** Fast-moving EWMA estimate (raw, uncorrected). */
@@ -30,9 +30,7 @@ interface BandwidthState {
   /** Total bytes sampled across all valid samples. */
   bytesSampled: number;
 }
-/**
- * Configuration for bandwidth estimation.
- */
+/** Configuration for bandwidth estimation. */
 interface BandwidthConfig {
   /** Half-life for fast EWMA in seconds. */
   fastHalfLife: number;

package/dist/dev/network/bandwidth-estimator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bandwidth-estimator.d.ts","names":[],"sources":["../../../src/network/bandwidth-estimator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAsBiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA"}
+{"version":3,"file":"bandwidth-estimator.d.ts","names":[],"sources":["../../../src/network/bandwidth-estimator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAsBiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA"}

package/dist/dev/network/bandwidth-estimator.js

@@ -3,15 +3,15 @@ import { applyZeroFactor, calculateEwma } from "./ewma.js";
 /**
 * Dual EWMA Bandwidth Estimator
 *
-* Estimates available bandwidth using two EWMA calculations with different
-* half-lives, taking the minimum of both. This approach (from Shaka Player):
+* Estimates available bandwidth using two EWMA calculations with different half-lives, taking the minimum of both. This
+* approach (from Shaka Player):
 *
 * - **Fast EWMA** (2s half-life): Reacts quickly to bandwidth drops
 * - **Slow EWMA** (5s half-life): Provides stability during fluctuations
 * - **min(fast, slow)**: Adapts down quickly, up slowly
 *
-* This naturally provides asymmetric behavior needed for good QoE:
-* avoiding stalls (quick downgrade) while preventing oscillation (slow upgrade).
+* This naturally provides asymmetric behavior needed for good QoE: avoiding stalls (quick downgrade) while preventing
+* oscillation (slow upgrade).
 */
 /**
 * Default bandwidth estimator configuration.
@@ -28,22 +28,21 @@ const DEFAULT_BANDWIDTH_CONFIG = {
 /**
 * Add a bandwidth sample from a segment download.
 *
-* Samples are filtered based on:
-* - Minimum bytes (filters TTFB-dominated small segments)
-* - Minimum duration (filters cached responses)
+* Samples are filtered based on: - Minimum bytes (filters TTFB-dominated small segments) - Minimum duration (filters
+* cached responses)
 *
 * Valid samples update both fast and slow EWMA estimates.
 *
+* @example
+*   let state = { fastEstimate: 0, fastTotalWeight: 0, ... };
+*   // Sample: 1MB in 1 second
+*   state = sampleBandwidth(state, 1000, 1_000_000);
+*
 * @param state - Current estimator state
 * @param durationMs - Download duration in milliseconds
 * @param numBytes - Number of bytes downloaded
 * @param config - Optional estimator configuration (uses defaults if not provided)
 * @returns New estimator state with sample incorporated (or unchanged if filtered)
-*
-* @example
-* let state = { fastEstimate: 0, fastTotalWeight: 0, ... };
-* // Sample: 1MB in 1 second
-* state = sampleBandwidth(state, 1000, 1_000_000);
 */
 function sampleBandwidth(state, durationMs, numBytes, config = DEFAULT_BANDWIDTH_CONFIG) {
 	const updatedBytesSampled = state.bytesSampled + numBytes;
@@ -68,21 +67,21 @@ function sampleBandwidth(state, durationMs, numBytes, config = DEFAULT_BANDWIDTH
 /**
 * Get the current bandwidth estimate.
 *
-* Returns the **minimum** of the fast and slow EWMA estimates.
-* This provides the key asymmetric behavior:
+* Returns the **minimum** of the fast and slow EWMA estimates. This provides the key asymmetric behavior:
+*
 * - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)
 * - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)
 *
-* Uses default estimate until enough data has been sampled — and when no
-* estimator state exists at all (`state === undefined`).
+* Uses default estimate until enough data has been sampled — and when no estimator state exists at all (`state ===
+* undefined`).
+*
+* @example
+*   const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default
 *
 * @param state - Current estimator state, or `undefined` before any samples have been collected
 * @param defaultEstimate - Fallback estimate before sufficient samples (bps)
 * @param config - Optional estimator configuration (uses defaults if not provided)
 * @returns Bandwidth estimate in bits per second
-*
-* @example
-* const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default
 */
 function getBandwidthEstimate(state, defaultEstimate, config = DEFAULT_BANDWIDTH_CONFIG) {
 	if (!state || state.bytesSampled < config.minTotalBytes) return defaultEstimate;

package/dist/dev/network/bandwidth-estimator.js.map

@@ -1 +1 @@
-{"version":3,"file":"bandwidth-estimator.js","names":[],"sources":["../../../src/network/bandwidth-estimator.ts"],"sourcesContent":["/**\n * Dual EWMA Bandwidth Estimator\n *\n * Estimates available bandwidth using two EWMA calculations with different\n * half-lives, taking the minimum of both. This approach (from Shaka Player):\n *\n * - **Fast EWMA** (2s half-life): Reacts quickly to bandwidth drops\n * - **Slow EWMA** (5s half-life): Provides stability during fluctuations\n * - **min(fast, slow)**: Adapts down quickly, up slowly\n *\n * This naturally provides asymmetric behavior needed for good QoE:\n * avoiding stalls (quick downgrade) while preventing oscillation (slow upgrade).\n */\n\nimport { applyZeroFactor, calculateEwma } from './ewma';\n\n/**\n * Bandwidth estimator state.\n *\n * This state structure will be managed by O1 (State Container).\n * Functions in this module operate on this state immutably.\n */\nexport interface BandwidthState {\n  /** Fast-moving EWMA estimate (raw, uncorrected). */\n  fastEstimate: number;\n  /** Total weight accumulated in fast EWMA. */\n  fastTotalWeight: number;\n  /** Slow-moving EWMA estimate (raw, uncorrected). */\n  slowEstimate: number;\n  /** Total weight accumulated in slow EWMA. */\n  slowTotalWeight: number;\n  /** Total bytes sampled across all valid samples. */\n  bytesSampled: number;\n}\n\n/**\n * Configuration for bandwidth estimation.\n */\nexport interface BandwidthConfig {\n  /** Half-life for fast EWMA in seconds. */\n  fastHalfLife: number;\n  /** Half-life for slow EWMA in seconds. */\n  slowHalfLife: number;\n  /** Minimum total bytes before trusting the estimate. */\n  minTotalBytes: number;\n  /** Minimum bytes per sample to count (filters TTFB-dominated samples). */\n  minBytes: number;\n  /** Minimum sample duration in ms (filters cached responses). */\n  minDuration: number;\n}\n\n/**\n * Default bandwidth estimator configuration.\n *\n * Values match Shaka Player defaults based on experimentation.\n */\nexport const DEFAULT_BANDWIDTH_CONFIG: BandwidthConfig = {\n  fastHalfLife: 2, // 2 seconds\n  slowHalfLife: 5, // 5 seconds\n  minTotalBytes: 128_000, // 128 KB\n  minBytes: 16_000, // 16 KB\n  minDuration: 5, // 5 ms\n};\n\n/**\n * Add a bandwidth sample from a segment download.\n *\n * Samples are filtered based on:\n * - Minimum bytes (filters TTFB-dominated small segments)\n * - Minimum duration (filters cached responses)\n *\n * Valid samples update both fast and slow EWMA estimates.\n *\n * @param state - Current estimator state\n * @param durationMs - Download duration in milliseconds\n * @param numBytes - Number of bytes downloaded\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns New estimator state with sample incorporated (or unchanged if filtered)\n *\n * @example\n * let state = { fastEstimate: 0, fastTotalWeight: 0, ... };\n * // Sample: 1MB in 1 second\n * state = sampleBandwidth(state, 1000, 1_000_000);\n */\nexport function sampleBandwidth(\n  state: BandwidthState,\n  durationMs: number,\n  numBytes: number,\n  config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG\n): BandwidthState {\n  // Always track bytes for startup phase calculation\n  const updatedBytesSampled = state.bytesSampled + numBytes;\n\n  // Filter: Ignore samples below minimum bytes (TTFB-dominated)\n  // Small segments' download time is mostly connection setup latency,\n  // which would artificially lower our bandwidth estimate\n  if (numBytes < config.minBytes) {\n    return { ...state, bytesSampled: updatedBytesSampled };\n  }\n\n  // Filter: Ignore samples faster than minimum duration (cached responses)\n  // Cached responses load nearly instantly and would artificially inflate\n  // our bandwidth estimate\n  if (durationMs < config.minDuration) {\n    return { ...state, bytesSampled: updatedBytesSampled };\n  }\n\n  // Calculate bandwidth in bits per second\n  // Formula: (bytes * 8 bits/byte * 1000 ms/s) / ms = bits/s\n  const bandwidth = (8000 * numBytes) / durationMs;\n\n  // Weight by duration in seconds\n  // Longer downloads are more reliable indicators of true bandwidth\n  const weight = durationMs / 1000;\n\n  return {\n    fastEstimate: calculateEwma(state.fastEstimate, bandwidth, weight, config.fastHalfLife),\n    fastTotalWeight: state.fastTotalWeight + weight,\n    slowEstimate: calculateEwma(state.slowEstimate, bandwidth, weight, config.slowHalfLife),\n    slowTotalWeight: state.slowTotalWeight + weight,\n    bytesSampled: updatedBytesSampled,\n  };\n}\n\n/**\n * Get the current bandwidth estimate.\n *\n * Returns the **minimum** of the fast and slow EWMA estimates.\n * This provides the key asymmetric behavior:\n * - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)\n * - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)\n *\n * Uses default estimate until enough data has been sampled — and when no\n * estimator state exists at all (`state === undefined`).\n *\n * @param state - Current estimator state, or `undefined` before any samples have been collected\n * @param defaultEstimate - Fallback estimate before sufficient samples (bps)\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns Bandwidth estimate in bits per second\n *\n * @example\n * const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default\n */\nexport function getBandwidthEstimate(\n  state: BandwidthState | undefined,\n  defaultEstimate: number,\n  config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG\n): number {\n  // Use default until we have enough samples to trust our estimate\n  if (!state || state.bytesSampled < config.minTotalBytes) {\n    return defaultEstimate;\n  }\n\n  // Apply zero-factor correction to both estimates\n  const fastEstimate = applyZeroFactor(state.fastEstimate, state.fastTotalWeight, config.fastHalfLife);\n\n  const slowEstimate = applyZeroFactor(state.slowEstimate, state.slowTotalWeight, config.slowHalfLife);\n\n  // Take the minimum - this is the key insight from Shaka Player\n  // It naturally provides \"down quickly, up slowly\" behavior\n  return Math.min(fastEstimate, slowEstimate);\n}\n\n/**\n * Check if the estimator has enough data to provide a reliable estimate.\n *\n * Requires both:\n * - Enough total bytes sampled (minTotalBytes threshold)\n * - At least one valid EWMA sample (totalWeight > 0)\n *\n * @param state - Current estimator state\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns True if we've sampled enough bytes to trust the estimate\n *\n * @example\n * if (hasGoodEstimate(state)) {\n *   const estimate = getBandwidthEstimate(state, 5_000_000);\n * }\n */\nexport function hasGoodEstimate(state: BandwidthState, config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG): boolean {\n  // Need enough total bytes AND at least one valid EWMA sample\n  return state.bytesSampled >= config.minTotalBytes && state.fastTotalWeight > 0 && state.slowTotalWeight > 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwDA,MAAa,2BAA4C;CACvD,cAAc;CACd,cAAc;CACd,eAAe;CACf,UAAU;CACV,aAAa;AACf;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,gBACd,OACA,YACA,UACA,SAA0B,0BACV;CAEhB,MAAM,sBAAsB,MAAM,eAAe;CAKjD,IAAI,WAAW,OAAO,UACpB,OAAO;EAAE,GAAG;EAAO,cAAc;CAAoB;CAMvD,IAAI,aAAa,OAAO,aACtB,OAAO;EAAE,GAAG;EAAO,cAAc;CAAoB;CAKvD,MAAM,YAAa,MAAO,WAAY;CAItC,MAAM,SAAS,aAAa;CAE5B,OAAO;EACL,cAAc,cAAc,MAAM,cAAc,WAAW,QAAQ,OAAO,YAAY;EACtF,iBAAiB,MAAM,kBAAkB;EACzC,cAAc,cAAc,MAAM,cAAc,WAAW,QAAQ,OAAO,YAAY;EACtF,iBAAiB,MAAM,kBAAkB;EACzC,cAAc;CAChB;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qBACd,OACA,iBACA,SAA0B,0BAClB;CAER,IAAI,CAAC,SAAS,MAAM,eAAe,OAAO,eACxC,OAAO;CAIT,MAAM,eAAe,gBAAgB,MAAM,cAAc,MAAM,iBAAiB,OAAO,YAAY;CAEnG,MAAM,eAAe,gBAAgB,MAAM,cAAc,MAAM,iBAAiB,OAAO,YAAY;CAInG,OAAO,KAAK,IAAI,cAAc,YAAY;AAC5C"}
+{"version":3,"file":"bandwidth-estimator.js","names":[],"sources":["../../../src/network/bandwidth-estimator.ts"],"sourcesContent":["/**\n * Dual EWMA Bandwidth Estimator\n *\n * Estimates available bandwidth using two EWMA calculations with different half-lives, taking the minimum of both. This\n * approach (from Shaka Player):\n *\n * - **Fast EWMA** (2s half-life): Reacts quickly to bandwidth drops\n * - **Slow EWMA** (5s half-life): Provides stability during fluctuations\n * - **min(fast, slow)**: Adapts down quickly, up slowly\n *\n * This naturally provides asymmetric behavior needed for good QoE: avoiding stalls (quick downgrade) while preventing\n * oscillation (slow upgrade).\n */\n\nimport { applyZeroFactor, calculateEwma } from './ewma';\n\n/**\n * Bandwidth estimator state.\n *\n * This state structure will be managed by O1 (State Container). Functions in this module operate on this state\n * immutably.\n */\nexport interface BandwidthState {\n  /** Fast-moving EWMA estimate (raw, uncorrected). */\n  fastEstimate: number;\n  /** Total weight accumulated in fast EWMA. */\n  fastTotalWeight: number;\n  /** Slow-moving EWMA estimate (raw, uncorrected). */\n  slowEstimate: number;\n  /** Total weight accumulated in slow EWMA. */\n  slowTotalWeight: number;\n  /** Total bytes sampled across all valid samples. */\n  bytesSampled: number;\n}\n\n/** Configuration for bandwidth estimation. */\nexport interface BandwidthConfig {\n  /** Half-life for fast EWMA in seconds. */\n  fastHalfLife: number;\n  /** Half-life for slow EWMA in seconds. */\n  slowHalfLife: number;\n  /** Minimum total bytes before trusting the estimate. */\n  minTotalBytes: number;\n  /** Minimum bytes per sample to count (filters TTFB-dominated samples). */\n  minBytes: number;\n  /** Minimum sample duration in ms (filters cached responses). */\n  minDuration: number;\n}\n\n/**\n * Default bandwidth estimator configuration.\n *\n * Values match Shaka Player defaults based on experimentation.\n */\nexport const DEFAULT_BANDWIDTH_CONFIG: BandwidthConfig = {\n  fastHalfLife: 2, // 2 seconds\n  slowHalfLife: 5, // 5 seconds\n  minTotalBytes: 128_000, // 128 KB\n  minBytes: 16_000, // 16 KB\n  minDuration: 5, // 5 ms\n};\n\n/**\n * Add a bandwidth sample from a segment download.\n *\n * Samples are filtered based on: - Minimum bytes (filters TTFB-dominated small segments) - Minimum duration (filters\n * cached responses)\n *\n * Valid samples update both fast and slow EWMA estimates.\n *\n * @example\n *   let state = { fastEstimate: 0, fastTotalWeight: 0, ... };\n *   // Sample: 1MB in 1 second\n *   state = sampleBandwidth(state, 1000, 1_000_000);\n *\n * @param state - Current estimator state\n * @param durationMs - Download duration in milliseconds\n * @param numBytes - Number of bytes downloaded\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns New estimator state with sample incorporated (or unchanged if filtered)\n */\nexport function sampleBandwidth(\n  state: BandwidthState,\n  durationMs: number,\n  numBytes: number,\n  config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG\n): BandwidthState {\n  // Always track bytes for startup phase calculation\n  const updatedBytesSampled = state.bytesSampled + numBytes;\n\n  // Filter: Ignore samples below minimum bytes (TTFB-dominated)\n  // Small segments' download time is mostly connection setup latency,\n  // which would artificially lower our bandwidth estimate\n  if (numBytes < config.minBytes) {\n    return { ...state, bytesSampled: updatedBytesSampled };\n  }\n\n  // Filter: Ignore samples faster than minimum duration (cached responses)\n  // Cached responses load nearly instantly and would artificially inflate\n  // our bandwidth estimate\n  if (durationMs < config.minDuration) {\n    return { ...state, bytesSampled: updatedBytesSampled };\n  }\n\n  // Calculate bandwidth in bits per second\n  // Formula: (bytes * 8 bits/byte * 1000 ms/s) / ms = bits/s\n  const bandwidth = (8000 * numBytes) / durationMs;\n\n  // Weight by duration in seconds\n  // Longer downloads are more reliable indicators of true bandwidth\n  const weight = durationMs / 1000;\n\n  return {\n    fastEstimate: calculateEwma(state.fastEstimate, bandwidth, weight, config.fastHalfLife),\n    fastTotalWeight: state.fastTotalWeight + weight,\n    slowEstimate: calculateEwma(state.slowEstimate, bandwidth, weight, config.slowHalfLife),\n    slowTotalWeight: state.slowTotalWeight + weight,\n    bytesSampled: updatedBytesSampled,\n  };\n}\n\n/**\n * Get the current bandwidth estimate.\n *\n * Returns the **minimum** of the fast and slow EWMA estimates. This provides the key asymmetric behavior:\n *\n * - When bandwidth drops, fast EWMA reacts first and dominates (quick adaptation)\n * - When bandwidth rises, slow EWMA lags behind and dominates (slow adaptation)\n *\n * Uses default estimate until enough data has been sampled — and when no estimator state exists at all (`state ===\n * undefined`).\n *\n * @example\n *   const estimate = getBandwidthEstimate(state, 5_000_000); // 5 Mbps default\n *\n * @param state - Current estimator state, or `undefined` before any samples have been collected\n * @param defaultEstimate - Fallback estimate before sufficient samples (bps)\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns Bandwidth estimate in bits per second\n */\nexport function getBandwidthEstimate(\n  state: BandwidthState | undefined,\n  defaultEstimate: number,\n  config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG\n): number {\n  // Use default until we have enough samples to trust our estimate\n  if (!state || state.bytesSampled < config.minTotalBytes) {\n    return defaultEstimate;\n  }\n\n  // Apply zero-factor correction to both estimates\n  const fastEstimate = applyZeroFactor(state.fastEstimate, state.fastTotalWeight, config.fastHalfLife);\n\n  const slowEstimate = applyZeroFactor(state.slowEstimate, state.slowTotalWeight, config.slowHalfLife);\n\n  // Take the minimum - this is the key insight from Shaka Player\n  // It naturally provides \"down quickly, up slowly\" behavior\n  return Math.min(fastEstimate, slowEstimate);\n}\n\n/**\n * Check if the estimator has enough data to provide a reliable estimate.\n *\n * Requires both: - Enough total bytes sampled (minTotalBytes threshold) - At least one valid EWMA sample (totalWeight >\n * 0)\n *\n * @example\n *   if (hasGoodEstimate(state)) {\n *     const estimate = getBandwidthEstimate(state, 5_000_000);\n *   }\n *\n * @param state - Current estimator state\n * @param config - Optional estimator configuration (uses defaults if not provided)\n * @returns True if we've sampled enough bytes to trust the estimate\n */\nexport function hasGoodEstimate(state: BandwidthState, config: BandwidthConfig = DEFAULT_BANDWIDTH_CONFIG): boolean {\n  // Need enough total bytes AND at least one valid EWMA sample\n  return state.bytesSampled >= config.minTotalBytes && state.fastTotalWeight > 0 && state.slowTotalWeight > 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsDA,MAAa,2BAA4C;CACvD,cAAc;CACd,cAAc;CACd,eAAe;CACf,UAAU;CACV,aAAa;AACf;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,gBACd,OACA,YACA,UACA,SAA0B,0BACV;CAEhB,MAAM,sBAAsB,MAAM,eAAe;CAKjD,IAAI,WAAW,OAAO,UACpB,OAAO;EAAE,GAAG;EAAO,cAAc;CAAoB;CAMvD,IAAI,aAAa,OAAO,aACtB,OAAO;EAAE,GAAG;EAAO,cAAc;CAAoB;CAKvD,MAAM,YAAa,MAAO,WAAY;CAItC,MAAM,SAAS,aAAa;CAE5B,OAAO;EACL,cAAc,cAAc,MAAM,cAAc,WAAW,QAAQ,OAAO,YAAY;EACtF,iBAAiB,MAAM,kBAAkB;EACzC,cAAc,cAAc,MAAM,cAAc,WAAW,QAAQ,OAAO,YAAY;EACtF,iBAAiB,MAAM,kBAAkB;EACzC,cAAc;CAChB;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qBACd,OACA,iBACA,SAA0B,0BAClB;CAER,IAAI,CAAC,SAAS,MAAM,eAAe,OAAO,eACxC,OAAO;CAIT,MAAM,eAAe,gBAAgB,MAAM,cAAc,MAAM,iBAAiB,OAAO,YAAY;CAEnG,MAAM,eAAe,gBAAgB,MAAM,cAAc,MAAM,iBAAiB,OAAO,YAAY;CAInG,OAAO,KAAK,IAAI,cAAc,YAAY;AAC5C"}

package/dist/dev/network/chunked-stream-iterable.js

@@ -1,13 +1,11 @@
 //#region src/network/chunked-stream-iterable.ts
 const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17;
 /**
-* Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an
-* `AsyncIterable<Uint8Array>` that yields chunks no smaller than
-* `minChunkSize` bytes. Smaller network chunks are accumulated and yielded
-* together once the threshold is met. Any remainder is flushed on stream end.
+* Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an `AsyncIterable<Uint8Array>` that yields chunks
+* no smaller than `minChunkSize` bytes. Smaller network chunks are accumulated and yielded together once the threshold
+* is met. Any remainder is flushed on stream end.
 *
-* Errors from the underlying stream propagate naturally — the reader lock is
-* always released via `finally`.
+* Errors from the underlying stream propagate naturally — the reader lock is always released via `finally`.
 */
 var ChunkedStreamIterable = class {
 	minChunkSize;

package/dist/dev/network/chunked-stream-iterable.js.map

@@ -1 +1 @@
-{"version":3,"file":"chunked-stream-iterable.js","names":["#readableStream"],"sources":["../../../src/network/chunked-stream-iterable.ts"],"sourcesContent":["const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17; // 128 KB\n\nexport interface ChunkedStreamIterableOptions {\n  minChunkSize?: number;\n}\n\n/**\n * Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an\n * `AsyncIterable<Uint8Array>` that yields chunks no smaller than\n * `minChunkSize` bytes. Smaller network chunks are accumulated and yielded\n * together once the threshold is met. Any remainder is flushed on stream end.\n *\n * Errors from the underlying stream propagate naturally — the reader lock is\n * always released via `finally`.\n */\nexport class ChunkedStreamIterable implements AsyncIterable<Uint8Array> {\n  readonly minChunkSize: number;\n  #readableStream: ReadableStream<Uint8Array>;\n\n  constructor(\n    readableStream: ReadableStream<Uint8Array>,\n    { minChunkSize = DEFAULT_MIN_CHUNK_SIZE }: ChunkedStreamIterableOptions = {}\n  ) {\n    this.#readableStream = readableStream;\n    this.minChunkSize = minChunkSize;\n  }\n\n  async *[Symbol.asyncIterator](): AsyncGenerator<Uint8Array> {\n    let pending: Uint8Array | undefined;\n    const reader = this.#readableStream.getReader();\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) {\n          if (pending) yield pending;\n          break;\n        }\n\n        pending = pending ? concat(pending, value) : value;\n\n        if (pending.length >= this.minChunkSize) {\n          yield pending;\n          pending = undefined;\n        }\n      }\n    } finally {\n      reader.releaseLock();\n    }\n  }\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array): Uint8Array {\n  const result = new Uint8Array(a.length + b.length);\n  result.set(a);\n  result.set(b, a.length);\n  return result;\n}\n"],"mappings":";AAAA,MAAM,yBAAyB,KAAK;;;;;;;;;;AAepC,IAAa,wBAAb,MAAwE;CACtE;CACA;CAEA,YACE,gBACA,EAAE,eAAe,2BAAyD,CAAC,GAC3E;EACA,KAAKA,kBAAkB;EACvB,KAAK,eAAe;CACtB;CAEA,QAAQ,OAAO,iBAA6C;EAC1D,IAAI;EACJ,MAAM,SAAS,KAAKA,gBAAgB,UAAU;EAC9C,IAAI;GACF,OAAO,MAAM;IACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;IAC1C,IAAI,MAAM;KACR,IAAI,SAAS,MAAM;KACnB;IACF;IAEA,UAAU,UAAU,OAAO,SAAS,KAAK,IAAI;IAE7C,IAAI,QAAQ,UAAU,KAAK,cAAc;KACvC,MAAM;KACN,UAAU,KAAA;IACZ;GACF;EACF,UAAU;GACR,OAAO,YAAY;EACrB;CACF;AACF;AAEA,SAAS,OAAO,GAAe,GAA2B;CACxD,MAAM,SAAS,IAAI,WAAW,EAAE,SAAS,EAAE,MAAM;CACjD,OAAO,IAAI,CAAC;CACZ,OAAO,IAAI,GAAG,EAAE,MAAM;CACtB,OAAO;AACT"}
+{"version":3,"file":"chunked-stream-iterable.js","names":["#readableStream"],"sources":["../../../src/network/chunked-stream-iterable.ts"],"sourcesContent":["const DEFAULT_MIN_CHUNK_SIZE = 2 ** 17; // 128 KB\n\nexport interface ChunkedStreamIterableOptions {\n  minChunkSize?: number;\n}\n\n/**\n * Adapts a `ReadableStream<Uint8Array>` (e.g. `response.body`) into an `AsyncIterable<Uint8Array>` that yields chunks\n * no smaller than `minChunkSize` bytes. Smaller network chunks are accumulated and yielded together once the threshold\n * is met. Any remainder is flushed on stream end.\n *\n * Errors from the underlying stream propagate naturally — the reader lock is always released via `finally`.\n */\nexport class ChunkedStreamIterable implements AsyncIterable<Uint8Array> {\n  readonly minChunkSize: number;\n  #readableStream: ReadableStream<Uint8Array>;\n\n  constructor(\n    readableStream: ReadableStream<Uint8Array>,\n    { minChunkSize = DEFAULT_MIN_CHUNK_SIZE }: ChunkedStreamIterableOptions = {}\n  ) {\n    this.#readableStream = readableStream;\n    this.minChunkSize = minChunkSize;\n  }\n\n  async *[Symbol.asyncIterator](): AsyncGenerator<Uint8Array> {\n    let pending: Uint8Array | undefined;\n    const reader = this.#readableStream.getReader();\n\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n\n        if (done) {\n          if (pending) yield pending;\n\n          break;\n        }\n\n        pending = pending ? concat(pending, value) : value;\n\n        if (pending.length >= this.minChunkSize) {\n          yield pending;\n          pending = undefined;\n        }\n      }\n    } finally {\n      reader.releaseLock();\n    }\n  }\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array): Uint8Array {\n  const result = new Uint8Array(a.length + b.length);\n\n  result.set(a);\n  result.set(b, a.length);\n  return result;\n}\n"],"mappings":";AAAA,MAAM,yBAAyB,KAAK;;;;;;;;AAapC,IAAa,wBAAb,MAAwE;CACtE;CACA;CAEA,YACE,gBACA,EAAE,eAAe,2BAAyD,CAAC,GAC3E;EACA,KAAKA,kBAAkB;EACvB,KAAK,eAAe;CACtB;CAEA,QAAQ,OAAO,iBAA6C;EAC1D,IAAI;EACJ,MAAM,SAAS,KAAKA,gBAAgB,UAAU;EAE9C,IAAI;GACF,OAAO,MAAM;IACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;IAE1C,IAAI,MAAM;KACR,IAAI,SAAS,MAAM;KAEnB;IACF;IAEA,UAAU,UAAU,OAAO,SAAS,KAAK,IAAI;IAE7C,IAAI,QAAQ,UAAU,KAAK,cAAc;KACvC,MAAM;KACN,UAAU,KAAA;IACZ;GACF;EACF,UAAU;GACR,OAAO,YAAY;EACrB;CACF;AACF;AAEA,SAAS,OAAO,GAAe,GAA2B;CACxD,MAAM,SAAS,IAAI,WAAW,EAAE,SAAS,EAAE,MAAM;CAEjD,OAAO,IAAI,CAAC;CACZ,OAAO,IAAI,GAAG,EAAE,MAAM;CACtB,OAAO;AACT"}

package/dist/dev/network/ewma.js

@@ -2,22 +2,19 @@
 /**
 * Exponentially Weighted Moving Average (EWMA)
 *
-* Pure functional implementation of EWMA calculations.
-* Based on Shaka Player's EWMA algorithm.
+* Pure functional implementation of EWMA calculations. Based on Shaka Player's EWMA algorithm.
 */
 /**
 * Calculate alpha (decay factor) from half-life.
 *
-* Alpha determines how quickly old data "expires":
-* - alpha close to 1 = slow decay (long memory)
-* - alpha close to 0 = fast decay (short memory)
-*
-* @param halfLife - The quantity of prior samples (by weight) that make up
-*   half of the new estimate. Must be positive.
-* @returns Alpha value between 0 and 1
+* Alpha determines how quickly old data "expires": - alpha close to 1 = slow decay (long memory) - alpha close to 0 =
+* fast decay (short memory)
 *
 * @example
-* const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life
+*   const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life
+*
+* @param halfLife - The quantity of prior samples (by weight) that make up half of the new estimate. Must be positive.
+* @returns Alpha value between 0 and 1
 */
 function calculateAlpha(halfLife) {
 	return Math.exp(Math.log(.5) / halfLife);
@@ -25,19 +22,19 @@ function calculateAlpha(halfLife) {
 /**
 * Calculate exponentially weighted moving average.
 *
-* Updates an estimate by blending a new value with the previous estimate,
-* weighted by the sample duration. Longer samples have more influence.
+* Updates an estimate by blending a new value with the previous estimate, weighted by the sample duration. Longer
+* samples have more influence.
+*
+* @example
+*   let estimate = 0;
+*   estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample
+*   estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample
 *
 * @param prevEstimate - Previous EWMA estimate
 * @param value - New sample value to incorporate
 * @param weight - Sample weight (typically duration in seconds)
 * @param halfLife - Half-life for decay (typically 2-5 seconds)
 * @returns Updated EWMA estimate
-*
-* @example
-* let estimate = 0;
-* estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample
-* estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample
 */
 function calculateEwma(prevEstimate, value, weight, halfLife) {
 	const adjAlpha = calculateAlpha(halfLife) ** weight;
@@ -46,20 +43,20 @@ function calculateEwma(prevEstimate, value, weight, halfLife) {
 /**
 * Apply zero-factor correction to EWMA estimate.
 *
-* The zero-factor correction compensates for bias when starting from zero.
-* Without this correction, early estimates would be artificially low.
+* The zero-factor correction compensates for bias when starting from zero. Without this correction, early estimates
+* would be artificially low.
+*
+* As totalWeight increases, the correction factor approaches 1, meaning the estimate becomes more reliable and needs
+* less correction.
 *
-* As totalWeight increases, the correction factor approaches 1, meaning
-* the estimate becomes more reliable and needs less correction.
+* @example
+*   const raw = calculateEwma(0, 1_000_000, 1, 2);
+*   const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000
 *
 * @param estimate - Raw EWMA estimate (uncorrected)
 * @param totalWeight - Accumulated weight from all samples
 * @param halfLife - Half-life used in EWMA calculation
 * @returns Corrected estimate, or 0 if totalWeight is 0
-*
-* @example
-* const raw = calculateEwma(0, 1_000_000, 1, 2);
-* const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000
 */
 function applyZeroFactor(estimate, totalWeight, halfLife) {
 	if (totalWeight === 0) return 0;

package/dist/dev/network/ewma.js.map

@@ -1 +1 @@
-{"version":3,"file":"ewma.js","names":[],"sources":["../../../src/network/ewma.ts"],"sourcesContent":["/**\n * Exponentially Weighted Moving Average (EWMA)\n *\n * Pure functional implementation of EWMA calculations.\n * Based on Shaka Player's EWMA algorithm.\n */\n\n/**\n * Calculate alpha (decay factor) from half-life.\n *\n * Alpha determines how quickly old data \"expires\":\n * - alpha close to 1 = slow decay (long memory)\n * - alpha close to 0 = fast decay (short memory)\n *\n * @param halfLife - The quantity of prior samples (by weight) that make up\n *   half of the new estimate. Must be positive.\n * @returns Alpha value between 0 and 1\n *\n * @example\n * const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life\n */\nexport function calculateAlpha(halfLife: number): number {\n  return Math.exp(Math.log(0.5) / halfLife);\n}\n\n/**\n * Calculate exponentially weighted moving average.\n *\n * Updates an estimate by blending a new value with the previous estimate,\n * weighted by the sample duration. Longer samples have more influence.\n *\n * @param prevEstimate - Previous EWMA estimate\n * @param value - New sample value to incorporate\n * @param weight - Sample weight (typically duration in seconds)\n * @param halfLife - Half-life for decay (typically 2-5 seconds)\n * @returns Updated EWMA estimate\n *\n * @example\n * let estimate = 0;\n * estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample\n * estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample\n */\nexport function calculateEwma(prevEstimate: number, value: number, weight: number, halfLife: number): number {\n  const alpha = calculateAlpha(halfLife);\n  const adjAlpha = alpha ** weight;\n  return value * (1 - adjAlpha) + adjAlpha * prevEstimate;\n}\n\n/**\n * Apply zero-factor correction to EWMA estimate.\n *\n * The zero-factor correction compensates for bias when starting from zero.\n * Without this correction, early estimates would be artificially low.\n *\n * As totalWeight increases, the correction factor approaches 1, meaning\n * the estimate becomes more reliable and needs less correction.\n *\n * @param estimate - Raw EWMA estimate (uncorrected)\n * @param totalWeight - Accumulated weight from all samples\n * @param halfLife - Half-life used in EWMA calculation\n * @returns Corrected estimate, or 0 if totalWeight is 0\n *\n * @example\n * const raw = calculateEwma(0, 1_000_000, 1, 2);\n * const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000\n */\nexport function applyZeroFactor(estimate: number, totalWeight: number, halfLife: number): number {\n  if (totalWeight === 0) {\n    return 0;\n  }\n\n  const alpha = calculateAlpha(halfLife);\n  const zeroFactor = 1 - alpha ** totalWeight;\n  return estimate / zeroFactor;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,eAAe,UAA0B;CACvD,OAAO,KAAK,IAAI,KAAK,IAAI,EAAG,IAAI,QAAQ;AAC1C;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,cAAc,cAAsB,OAAe,QAAgB,UAA0B;CAE3G,MAAM,WADQ,eAAe,QACR,KAAK;CAC1B,OAAO,SAAS,IAAI,YAAY,WAAW;AAC7C;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,gBAAgB,UAAkB,aAAqB,UAA0B;CAC/F,IAAI,gBAAgB,GAClB,OAAO;CAKT,OAAO,YADY,IADL,eAAe,QACF,KAAK;AAElC"}
+{"version":3,"file":"ewma.js","names":[],"sources":["../../../src/network/ewma.ts"],"sourcesContent":["/**\n * Exponentially Weighted Moving Average (EWMA)\n *\n * Pure functional implementation of EWMA calculations. Based on Shaka Player's EWMA algorithm.\n */\n\n/**\n * Calculate alpha (decay factor) from half-life.\n *\n * Alpha determines how quickly old data \"expires\": - alpha close to 1 = slow decay (long memory) - alpha close to 0 =\n * fast decay (short memory)\n *\n * @example\n *   const alpha = calculateAlpha(2); // ≈ 0.7071 for 2-second half-life\n *\n * @param halfLife - The quantity of prior samples (by weight) that make up half of the new estimate. Must be positive.\n * @returns Alpha value between 0 and 1\n */\nexport function calculateAlpha(halfLife: number): number {\n  return Math.exp(Math.log(0.5) / halfLife);\n}\n\n/**\n * Calculate exponentially weighted moving average.\n *\n * Updates an estimate by blending a new value with the previous estimate, weighted by the sample duration. Longer\n * samples have more influence.\n *\n * @example\n *   let estimate = 0;\n *   estimate = calculateEwma(estimate, 1_000_000, 1, 2); // First sample\n *   estimate = calculateEwma(estimate, 2_000_000, 1, 2); // Second sample\n *\n * @param prevEstimate - Previous EWMA estimate\n * @param value - New sample value to incorporate\n * @param weight - Sample weight (typically duration in seconds)\n * @param halfLife - Half-life for decay (typically 2-5 seconds)\n * @returns Updated EWMA estimate\n */\nexport function calculateEwma(prevEstimate: number, value: number, weight: number, halfLife: number): number {\n  const alpha = calculateAlpha(halfLife);\n  const adjAlpha = alpha ** weight;\n\n  return value * (1 - adjAlpha) + adjAlpha * prevEstimate;\n}\n\n/**\n * Apply zero-factor correction to EWMA estimate.\n *\n * The zero-factor correction compensates for bias when starting from zero. Without this correction, early estimates\n * would be artificially low.\n *\n * As totalWeight increases, the correction factor approaches 1, meaning the estimate becomes more reliable and needs\n * less correction.\n *\n * @example\n *   const raw = calculateEwma(0, 1_000_000, 1, 2);\n *   const corrected = applyZeroFactor(raw, 1, 2); // ≈ 1_000_000\n *\n * @param estimate - Raw EWMA estimate (uncorrected)\n * @param totalWeight - Accumulated weight from all samples\n * @param halfLife - Half-life used in EWMA calculation\n * @returns Corrected estimate, or 0 if totalWeight is 0\n */\nexport function applyZeroFactor(estimate: number, totalWeight: number, halfLife: number): number {\n  if (totalWeight === 0) {\n    return 0;\n  }\n\n  const alpha = calculateAlpha(halfLife);\n  const zeroFactor = 1 - alpha ** totalWeight;\n\n  return estimate / zeroFactor;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,eAAe,UAA0B;CACvD,OAAO,KAAK,IAAI,KAAK,IAAI,EAAG,IAAI,QAAQ;AAC1C;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,cAAc,cAAsB,OAAe,QAAgB,UAA0B;CAE3G,MAAM,WADQ,eAAe,QACR,KAAK;CAE1B,OAAO,SAAS,IAAI,YAAY,WAAW;AAC7C;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,gBAAgB,UAAkB,aAAqB,UAA0B;CAC/F,IAAI,gBAAgB,GAClB,OAAO;CAMT,OAAO,YAFY,IADL,eAAe,QACF,KAAK;AAGlC"}

package/dist/dev/network/fetch.js

@@ -4,35 +4,32 @@ import { ChunkedStreamIterable } from "./chunked-stream-iterable.js";
 /**
 * HTTP Fetch Wrapper
 *
-* Composable building blocks:
-* - fetchResolvable() — fetch a Resource (handles byte ranges); returns Response
-* - getResponseText() — extract text from Response
-* - fetchResolvableStream() — single-stage async generator over body chunks
-* - fetchStream() — two-stage: await connection establishment, then lazily
-*   iterate body chunks. Use when timing the connection start independently
-*   of body consumption matters (e.g., observable fetch timing for ABR).
-* - createTrackedFetch() — factory for a fetchStream-shape function that
-*   samples bandwidth (via EWMA) per chunk and notifies via callback.
+* Composable building blocks: - fetchResolvable() — fetch a Resource (handles byte ranges); returns Response -
+* getResponseText() — extract text from Response - fetchResolvableStream() — single-stage async generator over body
+* chunks - fetchStream() — two-stage: await connection establishment, then lazily iterate body chunks. Use when timing
+* the connection start independently of body consumption matters (e.g., observable fetch timing for ABR). -
+* createTrackedFetch() — factory for a fetchStream-shape function that samples bandwidth (via EWMA) per chunk and
+* notifies via callback.
 */
 /**
 * Fetch resolvable from a Resource.
 *
-* Handles byte range requests if byteRange is present.
-* Returns native fetch Response for composability (can extract text, stream, etc.).
-*
-* @param addressable - Resource to fetch (url + optional byteRange)
-* @returns Promise resolving to Response
+* Handles byte range requests if byteRange is present. Returns native fetch Response for composability (can extract
+* text, stream, etc.).
 *
 * @example
-* const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });
-* const text = await getResponseText(response);
+*   const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });
+*   const text = await getResponseText(response);
 *
 * @example
-* // With byte range
-* const response = await fetchResolvable({
-*   url: 'https://example.com/file.mp4',
-*   byteRange: { start: 1000, end: 1999 }
-* });
+*   // With byte range
+*   const response = await fetchResolvable({
+*     url: 'https://example.com/file.mp4',
+*     byteRange: { start: 1000, end: 1999 },
+*   });
+*
+* @param addressable - Resource to fetch (url + optional byteRange)
+* @returns Promise resolving to Response
 */
 async function fetchResolvable(addressable, options) {
 	const headers = new Headers(options?.headers);
@@ -50,15 +47,14 @@ async function fetchResolvable(addressable, options) {
 /**
 * Extract text from Response.
 *
-* Accepts minimal Response-like object (just needs text() method).
-* Returns promise from response.text().
+* Accepts minimal Response-like object (just needs text() method). Returns promise from response.text().
+*
+* @example
+*   const response = await fetchResolvable(addressable);
+*   const text = await getResponseText(response);
 *
 * @param response - Response-like object with text() method
 * @returns Promise resolving to text content
-*
-* @example
-* const response = await fetchResolvable(addressable);
-* const text = await getResponseText(response);
 */
 function getResponseText(response) {
 	return response.text();
@@ -76,18 +72,15 @@ async function fetchStream(addressable, options) {
 	return new ChunkedStreamIterable(response.body, ...minChunkSize !== void 0 ? [{ minChunkSize }] : []);
 }
 /**
-* Returns a {@link FetchBytes} function that samples bandwidth via EWMA
-* per body chunk. The factory captures the running bandwidth state
-* internally; per chunk it computes the next state and notifies the
-* supplied `onSample` callback.
+* Returns a {@link FetchBytes} function that samples bandwidth via EWMA per body chunk. The factory captures the
+* running bandwidth state internally; per chunk it computes the next state and notifies the supplied `onSample`
+* callback.
 *
-* The factory's internal accumulator is seeded from `initial` and updated
-* on every chunk; callers don't need to thread it back in. `onSample`
-* receives the *new* state after each chunk — typical use is to bridge
-* samples back into engine state for ABR consumers.
+* The factory's internal accumulator is seeded from `initial` and updated on every chunk; callers don't need to thread
+* it back in. `onSample` receives the _new_ state after each chunk — typical use is to bridge samples back into engine
+* state for ABR consumers.
 *
-* @param initial - Starting `BandwidthState` (commonly zeros or the
-*   engine's current accumulator).
+* @param initial - Starting `BandwidthState` (commonly zeros or the engine's current accumulator).
 * @param onSample - Called with the new `BandwidthState` after each chunk.
 */
 function createTrackedFetch(initial, onSample) {

package/dist/dev/network/fetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.js","names":[],"sources":["../../../src/network/fetch.ts"],"sourcesContent":["/**\n * HTTP Fetch Wrapper\n *\n * Composable building blocks:\n * - fetchResolvable() — fetch a Resource (handles byte ranges); returns Response\n * - getResponseText() — extract text from Response\n * - fetchResolvableStream() — single-stage async generator over body chunks\n * - fetchStream() — two-stage: await connection establishment, then lazily\n *   iterate body chunks. Use when timing the connection start independently\n *   of body consumption matters (e.g., observable fetch timing for ABR).\n * - createTrackedFetch() — factory for a fetchStream-shape function that\n *   samples bandwidth (via EWMA) per chunk and notifies via callback.\n */\n\nimport { type BandwidthState, sampleBandwidth } from './bandwidth-estimator';\nimport { ChunkedStreamIterable, type ChunkedStreamIterableOptions } from './chunked-stream-iterable';\n\n/**\n * Minimal Response-like interface for text extraction.\n * Allows testing without full Response object.\n */\nexport interface ResponseLike {\n  text(): Promise<string>;\n}\n\n/**\n * An HTTP-addressable resource — URL plus optional byte range.\n * Media's `AddressableObject` (and anything else with the same shape)\n * is structurally compatible; kept local so this module stays\n * domain-agnostic.\n */\nexport interface Resource {\n  url: string;\n  byteRange?: {\n    start: number;\n    end: number;\n  };\n}\n\n/**\n * Fetch resolvable from a Resource.\n *\n * Handles byte range requests if byteRange is present.\n * Returns native fetch Response for composability (can extract text, stream, etc.).\n *\n * @param addressable - Resource to fetch (url + optional byteRange)\n * @returns Promise resolving to Response\n *\n * @example\n * const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });\n * const text = await getResponseText(response);\n *\n * @example\n * // With byte range\n * const response = await fetchResolvable({\n *   url: 'https://example.com/file.mp4',\n *   byteRange: { start: 1000, end: 1999 }\n * });\n */\nexport async function fetchResolvable(addressable: Resource, options?: RequestInit): Promise<Response> {\n  const headers = new Headers(options?.headers);\n\n  // Add Range header for byte range requests\n  if (addressable.byteRange) {\n    const { start, end } = addressable.byteRange;\n    headers.set('Range', `bytes=${start}-${end}`);\n  }\n\n  const request = new Request(addressable.url, {\n    method: 'GET',\n    headers,\n    ...options,\n  });\n\n  return fetch(request);\n}\n\n/**\n * Fetch resolvable as bytes.\n *\n * Convenience wrapper around fetchResolvable that resolves the body as an\n * ArrayBuffer. Use this when you need the raw bytes (e.g. segment appends).\n * For text or streaming consumption, use fetchResolvable directly.\n */\nexport async function fetchResolvableBytes(addressable: Resource, options?: RequestInit): Promise<ArrayBuffer> {\n  const response = await fetchResolvable(addressable, options);\n  return response.arrayBuffer();\n}\n\n/**\n * Fetch resolvable as a stream of Uint8Array chunks.\n *\n * Convenience wrapper around fetchResolvable that yields the body as chunks\n * via ChunkedStreamIterable. Headers are awaited before the first chunk is\n * yielded (TTFB is accounted for before iteration begins).\n *\n * Throws if the response body is null (e.g. non-body HTTP status).\n * Errors from the underlying stream propagate naturally as thrown errors.\n */\nexport async function* fetchResolvableStream(\n  addressable: Resource,\n  options?: RequestInit & ChunkedStreamIterableOptions\n): AsyncGenerator<Uint8Array> {\n  const { minChunkSize, ...fetchOptions } = options ?? {};\n  const response = await fetchResolvable(addressable, fetchOptions);\n  if (!response.body) throw new Error('Response has no body');\n  yield* new ChunkedStreamIterable(response.body, ...(minChunkSize !== undefined ? [{ minChunkSize }] : []));\n}\n\n/**\n * Extract text from Response.\n *\n * Accepts minimal Response-like object (just needs text() method).\n * Returns promise from response.text().\n *\n * @param response - Response-like object with text() method\n * @returns Promise resolving to text content\n *\n * @example\n * const response = await fetchResolvable(addressable);\n * const text = await getResponseText(response);\n */\nexport function getResponseText(response: ResponseLike): Promise<string> {\n  return response.text();\n}\n\n/**\n * Fetch a resource and resolve its text body — the text analog of\n * {@link FetchBytes}. A non-OK status rejects, so HTTP failures surface as\n * rejections that callers (and decorators like the failover tracker) handle\n * uniformly with network errors.\n */\nexport type FetchText = (addressable: Resource, options?: RequestInit) => Promise<string>;\n\n/** Default {@link FetchText}: fetch the resource, reject on non-OK, return text. */\nexport const fetchResolvableText: FetchText = async (addressable, options) => {\n  const response = await fetchResolvable(addressable, options);\n  if (!response.ok) {\n    throw new Error(`fetchResolvableText: ${response.status} ${response.statusText} for ${addressable.url}`);\n  }\n  return getResponseText(response);\n};\n\n/**\n * Two-stage fetch helper: eagerly starts the HTTP request (TTFB is awaited),\n * then returns a lazy iterable over the response body. Separating connection\n * start from body iteration makes fetch timing predictable and observable\n * regardless of when downstream consumers begin pulling chunks.\n *\n * Sibling to {@link fetchResolvableStream}, which is single-stage (calls\n * `fetch` only when iteration starts). Pick `fetchStream` when \"when did the\n * fetch start\" needs to be observable separately from \"when did the body\n * begin arriving.\"\n */\nexport type FetchOptions = RequestInit & ChunkedStreamIterableOptions;\n\nexport type FetchBytes = (addressable: Resource, options?: FetchOptions) => Promise<AsyncIterable<Uint8Array>>;\n\nexport async function fetchStream(addressable: Resource, options?: FetchOptions): Promise<AsyncIterable<Uint8Array>> {\n  const { minChunkSize, ...fetchOptions } = options ?? {};\n  const response = await fetchResolvable(addressable, fetchOptions);\n  if (!response.body) throw new Error('Response has no body');\n  return new ChunkedStreamIterable(response.body, ...(minChunkSize !== undefined ? [{ minChunkSize }] : []));\n}\n\n/**\n * Returns a {@link FetchBytes} function that samples bandwidth via EWMA\n * per body chunk. The factory captures the running bandwidth state\n * internally; per chunk it computes the next state and notifies the\n * supplied `onSample` callback.\n *\n * The factory's internal accumulator is seeded from `initial` and updated\n * on every chunk; callers don't need to thread it back in. `onSample`\n * receives the *new* state after each chunk — typical use is to bridge\n * samples back into engine state for ABR consumers.\n *\n * @param initial - Starting `BandwidthState` (commonly zeros or the\n *   engine's current accumulator).\n * @param onSample - Called with the new `BandwidthState` after each chunk.\n */\nexport function createTrackedFetch(initial: BandwidthState, onSample: (next: BandwidthState) => void): FetchBytes {\n  let state = initial;\n  return async (addressable, options) => {\n    const { minChunkSize, ...fetchOptions } = options ?? {};\n    const response = await fetchResolvable(addressable, fetchOptions);\n    if (!response.body) throw new Error('Response has no body');\n    const body = response.body;\n    return {\n      [Symbol.asyncIterator]: async function* () {\n        let chunkStart = performance.now();\n        for await (const chunk of new ChunkedStreamIterable(\n          body,\n          ...(minChunkSize !== undefined ? [{ minChunkSize }] : [])\n        )) {\n          const elapsed = performance.now() - chunkStart;\n          state = sampleBandwidth(state, elapsed, chunk.byteLength);\n          onSample(state);\n          yield chunk;\n          chunkStart = performance.now();\n        }\n      },\n    };\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,eAAsB,gBAAgB,aAAuB,SAA0C;CACrG,MAAM,UAAU,IAAI,QAAQ,SAAS,OAAO;CAG5C,IAAI,YAAY,WAAW;EACzB,MAAM,EAAE,OAAO,QAAQ,YAAY;EACnC,QAAQ,IAAI,SAAS,SAAS,MAAM,GAAG,KAAK;CAC9C;CAEA,MAAM,UAAU,IAAI,QAAQ,YAAY,KAAK;EAC3C,QAAQ;EACR;EACA,GAAG;CACL,CAAC;CAED,OAAO,MAAM,OAAO;AACtB;;;;;;;;;;;;;;AA+CA,SAAgB,gBAAgB,UAAyC;CACvE,OAAO,SAAS,KAAK;AACvB;;AAWA,MAAa,sBAAiC,OAAO,aAAa,YAAY;CAC5E,MAAM,WAAW,MAAM,gBAAgB,aAAa,OAAO;CAC3D,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,wBAAwB,SAAS,OAAO,GAAG,SAAS,WAAW,OAAO,YAAY,KAAK;CAEzG,OAAO,gBAAgB,QAAQ;AACjC;AAiBA,eAAsB,YAAY,aAAuB,SAA4D;CACnH,MAAM,EAAE,cAAc,GAAG,iBAAiB,WAAW,CAAC;CACtD,MAAM,WAAW,MAAM,gBAAgB,aAAa,YAAY;CAChE,IAAI,CAAC,SAAS,MAAM,MAAM,IAAI,MAAM,sBAAsB;CAC1D,OAAO,IAAI,sBAAsB,SAAS,MAAM,GAAI,iBAAiB,KAAA,IAAY,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAE;AAC3G;;;;;;;;;;;;;;;;AAiBA,SAAgB,mBAAmB,SAAyB,UAAsD;CAChH,IAAI,QAAQ;CACZ,OAAO,OAAO,aAAa,YAAY;EACrC,MAAM,EAAE,cAAc,GAAG,iBAAiB,WAAW,CAAC;EACtD,MAAM,WAAW,MAAM,gBAAgB,aAAa,YAAY;EAChE,IAAI,CAAC,SAAS,MAAM,MAAM,IAAI,MAAM,sBAAsB;EAC1D,MAAM,OAAO,SAAS;EACtB,OAAO,EACL,CAAC,OAAO,gBAAgB,mBAAmB;GACzC,IAAI,aAAa,YAAY,IAAI;GACjC,WAAW,MAAM,SAAS,IAAI,sBAC5B,MACA,GAAI,iBAAiB,KAAA,IAAY,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CACzD,GAAG;IACD,MAAM,UAAU,YAAY,IAAI,IAAI;IACpC,QAAQ,gBAAgB,OAAO,SAAS,MAAM,UAAU;IACxD,SAAS,KAAK;IACd,MAAM;IACN,aAAa,YAAY,IAAI;GAC/B;EACF,EACF;CACF;AACF"}
+{"version":3,"file":"fetch.js","names":[],"sources":["../../../src/network/fetch.ts"],"sourcesContent":["/**\n * HTTP Fetch Wrapper\n *\n * Composable building blocks: - fetchResolvable() — fetch a Resource (handles byte ranges); returns Response -\n * getResponseText() — extract text from Response - fetchResolvableStream() — single-stage async generator over body\n * chunks - fetchStream() — two-stage: await connection establishment, then lazily iterate body chunks. Use when timing\n * the connection start independently of body consumption matters (e.g., observable fetch timing for ABR). -\n * createTrackedFetch() — factory for a fetchStream-shape function that samples bandwidth (via EWMA) per chunk and\n * notifies via callback.\n */\n\nimport { type BandwidthState, sampleBandwidth } from './bandwidth-estimator';\nimport { ChunkedStreamIterable, type ChunkedStreamIterableOptions } from './chunked-stream-iterable';\n\n/** Minimal Response-like interface for text extraction. Allows testing without full Response object. */\nexport interface ResponseLike {\n  text(): Promise<string>;\n}\n\n/**\n * An HTTP-addressable resource — URL plus optional byte range. Media's `AddressableObject` (and anything else with the\n * same shape) is structurally compatible; kept local so this module stays domain-agnostic.\n */\nexport interface Resource {\n  url: string;\n  byteRange?: {\n    start: number;\n    end: number;\n  };\n}\n\n/**\n * Fetch resolvable from a Resource.\n *\n * Handles byte range requests if byteRange is present. Returns native fetch Response for composability (can extract\n * text, stream, etc.).\n *\n * @example\n *   const response = await fetchResolvable({ url: 'https://example.com/segment.m4s' });\n *   const text = await getResponseText(response);\n *\n * @example\n *   // With byte range\n *   const response = await fetchResolvable({\n *     url: 'https://example.com/file.mp4',\n *     byteRange: { start: 1000, end: 1999 },\n *   });\n *\n * @param addressable - Resource to fetch (url + optional byteRange)\n * @returns Promise resolving to Response\n */\nexport async function fetchResolvable(addressable: Resource, options?: RequestInit): Promise<Response> {\n  const headers = new Headers(options?.headers);\n\n  // Add Range header for byte range requests\n  if (addressable.byteRange) {\n    const { start, end } = addressable.byteRange;\n\n    headers.set('Range', `bytes=${start}-${end}`);\n  }\n\n  const request = new Request(addressable.url, {\n    method: 'GET',\n    headers,\n    ...options,\n  });\n\n  return fetch(request);\n}\n\n/**\n * Fetch resolvable as bytes.\n *\n * Convenience wrapper around fetchResolvable that resolves the body as an ArrayBuffer. Use this when you need the raw\n * bytes (e.g. segment appends). For text or streaming consumption, use fetchResolvable directly.\n */\nexport async function fetchResolvableBytes(addressable: Resource, options?: RequestInit): Promise<ArrayBuffer> {\n  const response = await fetchResolvable(addressable, options);\n\n  return response.arrayBuffer();\n}\n\n/**\n * Fetch resolvable as a stream of Uint8Array chunks.\n *\n * Convenience wrapper around fetchResolvable that yields the body as chunks via ChunkedStreamIterable. Headers are\n * awaited before the first chunk is yielded (TTFB is accounted for before iteration begins).\n *\n * Throws if the response body is null (e.g. non-body HTTP status). Errors from the underlying stream propagate\n * naturally as thrown errors.\n */\nexport async function* fetchResolvableStream(\n  addressable: Resource,\n  options?: RequestInit & ChunkedStreamIterableOptions\n): AsyncGenerator<Uint8Array> {\n  const { minChunkSize, ...fetchOptions } = options ?? {};\n  const response = await fetchResolvable(addressable, fetchOptions);\n  if (!response.body) throw new Error('Response has no body');\n\n  yield* new ChunkedStreamIterable(response.body, ...(minChunkSize !== undefined ? [{ minChunkSize }] : []));\n}\n\n/**\n * Extract text from Response.\n *\n * Accepts minimal Response-like object (just needs text() method). Returns promise from response.text().\n *\n * @example\n *   const response = await fetchResolvable(addressable);\n *   const text = await getResponseText(response);\n *\n * @param response - Response-like object with text() method\n * @returns Promise resolving to text content\n */\nexport function getResponseText(response: ResponseLike): Promise<string> {\n  return response.text();\n}\n\n/**\n * Fetch a resource and resolve its text body — the text analog of {@link FetchBytes}. A non-OK status rejects, so HTTP\n * failures surface as rejections that callers (and decorators like the failover tracker) handle uniformly with network\n * errors.\n */\nexport type FetchText = (addressable: Resource, options?: RequestInit) => Promise<string>;\n\n/** Default {@link FetchText}: fetch the resource, reject on non-OK, return text. */\nexport const fetchResolvableText: FetchText = async (addressable, options) => {\n  const response = await fetchResolvable(addressable, options);\n\n  if (!response.ok) {\n    throw new Error(`fetchResolvableText: ${response.status} ${response.statusText} for ${addressable.url}`);\n  }\n\n  return getResponseText(response);\n};\n\n/**\n * Two-stage fetch helper: eagerly starts the HTTP request (TTFB is awaited), then returns a lazy iterable over the\n * response body. Separating connection start from body iteration makes fetch timing predictable and observable\n * regardless of when downstream consumers begin pulling chunks.\n *\n * Sibling to {@link fetchResolvableStream}, which is single-stage (calls `fetch` only when iteration starts). Pick\n * `fetchStream` when \"when did the fetch start\" needs to be observable separately from \"when did the body begin\n * arriving.\"\n */\nexport type FetchOptions = RequestInit & ChunkedStreamIterableOptions;\n\nexport type FetchBytes = (addressable: Resource, options?: FetchOptions) => Promise<AsyncIterable<Uint8Array>>;\n\nexport async function fetchStream(addressable: Resource, options?: FetchOptions): Promise<AsyncIterable<Uint8Array>> {\n  const { minChunkSize, ...fetchOptions } = options ?? {};\n  const response = await fetchResolvable(addressable, fetchOptions);\n  if (!response.body) throw new Error('Response has no body');\n\n  return new ChunkedStreamIterable(response.body, ...(minChunkSize !== undefined ? [{ minChunkSize }] : []));\n}\n\n/**\n * Returns a {@link FetchBytes} function that samples bandwidth via EWMA per body chunk. The factory captures the\n * running bandwidth state internally; per chunk it computes the next state and notifies the supplied `onSample`\n * callback.\n *\n * The factory's internal accumulator is seeded from `initial` and updated on every chunk; callers don't need to thread\n * it back in. `onSample` receives the _new_ state after each chunk — typical use is to bridge samples back into engine\n * state for ABR consumers.\n *\n * @param initial - Starting `BandwidthState` (commonly zeros or the engine's current accumulator).\n * @param onSample - Called with the new `BandwidthState` after each chunk.\n */\nexport function createTrackedFetch(initial: BandwidthState, onSample: (next: BandwidthState) => void): FetchBytes {\n  let state = initial;\n\n  return async (addressable, options) => {\n    const { minChunkSize, ...fetchOptions } = options ?? {};\n    const response = await fetchResolvable(addressable, fetchOptions);\n    if (!response.body) throw new Error('Response has no body');\n\n    const body = response.body;\n\n    return {\n      [Symbol.asyncIterator]: async function* () {\n        let chunkStart = performance.now();\n\n        for await (const chunk of new ChunkedStreamIterable(\n          body,\n          ...(minChunkSize !== undefined ? [{ minChunkSize }] : [])\n        )) {\n          const elapsed = performance.now() - chunkStart;\n\n          state = sampleBandwidth(state, elapsed, chunk.byteLength);\n          onSample(state);\n          yield chunk;\n          chunkStart = performance.now();\n        }\n      },\n    };\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,eAAsB,gBAAgB,aAAuB,SAA0C;CACrG,MAAM,UAAU,IAAI,QAAQ,SAAS,OAAO;CAG5C,IAAI,YAAY,WAAW;EACzB,MAAM,EAAE,OAAO,QAAQ,YAAY;EAEnC,QAAQ,IAAI,SAAS,SAAS,MAAM,GAAG,KAAK;CAC9C;CAEA,MAAM,UAAU,IAAI,QAAQ,YAAY,KAAK;EAC3C,QAAQ;EACR;EACA,GAAG;CACL,CAAC;CAED,OAAO,MAAM,OAAO;AACtB;;;;;;;;;;;;;AA8CA,SAAgB,gBAAgB,UAAyC;CACvE,OAAO,SAAS,KAAK;AACvB;;AAUA,MAAa,sBAAiC,OAAO,aAAa,YAAY;CAC5E,MAAM,WAAW,MAAM,gBAAgB,aAAa,OAAO;CAE3D,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,wBAAwB,SAAS,OAAO,GAAG,SAAS,WAAW,OAAO,YAAY,KAAK;CAGzG,OAAO,gBAAgB,QAAQ;AACjC;AAeA,eAAsB,YAAY,aAAuB,SAA4D;CACnH,MAAM,EAAE,cAAc,GAAG,iBAAiB,WAAW,CAAC;CACtD,MAAM,WAAW,MAAM,gBAAgB,aAAa,YAAY;CAChE,IAAI,CAAC,SAAS,MAAM,MAAM,IAAI,MAAM,sBAAsB;CAE1D,OAAO,IAAI,sBAAsB,SAAS,MAAM,GAAI,iBAAiB,KAAA,IAAY,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAE;AAC3G;;;;;;;;;;;;;AAcA,SAAgB,mBAAmB,SAAyB,UAAsD;CAChH,IAAI,QAAQ;CAEZ,OAAO,OAAO,aAAa,YAAY;EACrC,MAAM,EAAE,cAAc,GAAG,iBAAiB,WAAW,CAAC;EACtD,MAAM,WAAW,MAAM,gBAAgB,aAAa,YAAY;EAChE,IAAI,CAAC,SAAS,MAAM,MAAM,IAAI,MAAM,sBAAsB;EAE1D,MAAM,OAAO,SAAS;EAEtB,OAAO,EACL,CAAC,OAAO,gBAAgB,mBAAmB;GACzC,IAAI,aAAa,YAAY,IAAI;GAEjC,WAAW,MAAM,SAAS,IAAI,sBAC5B,MACA,GAAI,iBAAiB,KAAA,IAAY,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CACzD,GAAG;IACD,MAAM,UAAU,YAAY,IAAI,IAAI;IAEpC,QAAQ,gBAAgB,OAAO,SAAS,MAAM,UAAU;IACxD,SAAS,KAAK;IACd,MAAM;IACN,aAAa,YAAY,IAAI;GAC/B;EACF,EACF;CACF;AACF"}

package/dist/dev/playback/actors/dom/segment-loader.d.ts

@@ -8,12 +8,10 @@ type SegmentLoaderTrack = VideoTrack | AudioTrack;
 /**
  * Message sent to a SegmentLoaderActor.
  *
- * `range` is optional to distinguish loading modes:
- * - No range: load init segment only (metadata preload mode)
- * - With range: load init + all segments overlapping [start, end]
+ * `range` is optional to distinguish loading modes: - No range: load init segment only (metadata preload mode) - With
+ * range: load init + all segments overlapping [start, end]
  *
- * `start` and `end` are raw time values — no segment snapping.
- * The actor maps them onto segment boundaries internally.
+ * `start` and `end` are raw time values — no segment snapping. The actor maps them onto segment boundaries internally.
  */
 type SegmentLoaderMessage = {
   type: 'load';
@@ -30,12 +28,10 @@ interface SegmentLoaderActorContext {
   /** Track ID of the init segment currently being fetched/appended, or null. */
   inFlightInitTrackId: string | null;
   /**
-   * Identity of the segment currently being fetched/appended, or null. Tracks
-   * the `trackId` alongside the positional `id` because renditions number
-   * segments independently (`segment-N`): an in-flight LOW `segment-0` must not
-   * be mistaken for a needed HIGH `segment-0` on a switch (see the loading
-   * handler's continue/preempt decision). Mirrors the text-track loader, which
-   * already matches its in-flight segment on `(inFlightTrackId, inFlightSegmentId)`.
+   * Identity of the segment currently being fetched/appended, or null. Tracks the `trackId` alongside the positional
+   * `id` because renditions number segments independently (`segment-N`): an in-flight LOW `segment-0` must not be
+   * mistaken for a needed HIGH `segment-0` on a switch (see the loading handler's continue/preempt decision). Mirrors
+   * the text-track loader, which already matches its in-flight segment on `(inFlightTrackId, inFlightSegmentId)`.
    */
   inFlightSegment: {
     id: string;

package/dist/dev/playback/actors/dom/segment-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment-loader.d.ts","names":[],"sources":["../../../../../src/playback/actors/dom/segment-loader.ts"],"mappings":";;;;;;KAwDY,qBAAqB,aAAa;;;;;;;;;;;KAYlC;EACV;EACA,OAAO;EACP;IAAU;IAAe;;;;KAQf;;UAGK;;EAEf;;;;;;;;;EASA;IAAmB;IAAY;;;KAGrB,qBAAqB,aAAa,yBAAyB,2BAA2B"}
+{"version":3,"file":"segment-loader.d.ts","names":[],"sources":["../../../../../src/playback/actors/dom/segment-loader.ts"],"mappings":";;;;;;KAmDY,qBAAqB,aAAa;;;;;;;;;KAUlC;EACV;EACA,OAAO;EACP;IAAU;IAAe;;;;KAQf;;UAGK;;EAEf;;;;;;;EAOA;IAAmB;IAAY;;;KAGrB,qBAAqB,aAAa,yBAAyB,2BAA2B"}

package/dist/dev/playback/actors/dom/segment-loader.js

@@ -7,11 +7,9 @@ import { DEFAULT_BACK_BUFFER_CONFIG, calculateBackBufferFlushPoint } from "../..
 import { DEFAULT_MESSAGE_PIPELINES } from "../../primitives/segment-load-pipeline.js";
 //#region src/playback/actors/dom/segment-loader.ts
 /**
-* Wraps a LoadTask descriptor into a Task that runs the op's message pipeline
-* (fetch/discover/stamp/dispatch, per the composition's `messagePipelines`).
-* Updates in-flight context around the async region so the loading handler can
-* make accurate continue/preempt decisions at any point, and checks the abort
-* signal before each step.
+* Wraps a LoadTask descriptor into a Task that runs the op's message pipeline (fetch/discover/stamp/dispatch, per the
+* composition's `messagePipelines`). Updates in-flight context around the async region so the loading handler can make
+* accurate continue/preempt decisions at any point, and checks the abort signal before each step.
 */
 function makeLoadTask(op, { getContext, setContext, pipelines, deps }) {
 	return new Task(async (taskSignal) => {
@@ -51,25 +49,20 @@ function makeLoadTask(op, { getContext, setContext, pipelines, deps }) {
 /**
 * Creates a SegmentLoaderActor for one track type (video or audio).
 *
-* Receives load assignments via `send()` and owns all execution: planning,
-* removes, fetches, and appends. Coordinates with the SourceBufferActor for
-* all physical SourceBuffer operations.
+* Receives load assignments via `send()` and owns all execution: planning, removes, fetches, and appends. Coordinates
+* with the SourceBufferActor for all physical SourceBuffer operations.
 *
-* Planning (Cases 1–3) happens in the `load` handler on every incoming
-* message, producing an ordered LoadTask list. The runner drains that list
-* sequentially via SerialRunner. When a new message arrives mid-run, the
-* handler replans and either continues the in-flight operation (abortPending
-* + schedule new remainder) or preempts it (abortAll + cancel SourceBuffer
-* if needed + schedule new plan).
+* Planning (Cases 1–3) happens in the `load` handler on every incoming message, producing an ordered LoadTask list. The
+* runner drains that list sequentially via SerialRunner. When a new message arrives mid-run, the handler replans and
+* either continues the in-flight operation (abortPending + schedule new remainder) or preempts it (abortAll + cancel
+* SourceBuffer if needed + schedule new plan).
 *
 * @param sourceBufferActor - Shared SourceBufferActor reference (not owned)
-* @param fetchBytes - Tracked fetch closure (owns throughput sampling for segments).
-*   Accepts an optional `minChunkSize` in options; init segments pass `Infinity`
-*   so the entire body accumulates as one chunk before appending.
-* @param compositionDeps - The composition's `state`/`context`/`config`, threaded
-*   opaquely into each step's {@link StepDeps} (the loader never reads them). Lets
-*   injected steps (relocation) read composition signals at call time. Defaults to
-*   empty for standalone / base-pipeline use.
+* @param fetchBytes - Tracked fetch closure (owns throughput sampling for segments). Accepts an optional `minChunkSize`
+*   in options; init segments pass `Infinity` so the entire body accumulates as one chunk before appending.
+* @param compositionDeps - The composition's `state`/`context`/`config`, threaded opaquely into each step's
+*   {@link StepDeps} (the loader never reads them). Lets injected steps (relocation) read composition signals at call
+*   time. Defaults to empty for standalone / base-pipeline use.
 */
 function createSegmentLoaderActor(sourceBufferActor, fetchBytes, config = {}, compositionDeps = {
 	state: {},
@@ -95,36 +88,27 @@ function createSegmentLoaderActor(sourceBufferActor, fetchBytes, config = {}, co
 	};
 	const pipelines = (config.messagePipelines ?? DEFAULT_MESSAGE_PIPELINES)();
 	const getBufferedSegments = (allSegments) => {
-		const merged = mergeTimeRanges(peek(sourceBufferActor.snapshot).context.segments.filter((s) => !s.partial).map((s) => ({
+		const appended = peek(sourceBufferActor.snapshot).context.segments.filter((s) => !s.partial);
+		const merged = mergeTimeRanges(appended.map((s) => ({
 			start: s.startTime,
 			end: s.startTime + s.duration
 		})));
 		return allSegments.filter((s) => isTimeRangeCovered(s.startTime, s.startTime + s.duration, merged));
 	};
 	/**
-	* Translate a load message into an ordered LoadTask list based on committed
-	* actor state. In-flight awareness is handled separately in the load handler.
+	* Translate a load message into an ordered LoadTask list based on committed actor state. In-flight awareness is
+	* handled separately in the load handler.
 	*
-	* @todo Rename alongside LoadTask (e.g. planOps).
-	*
-	* Case 1 — Removes: forward and back buffer flush points, segment-aligned.
-	*   ABR-style track switches (same content, different bitrate) do not flush:
-	*   appending new content overwrites existing buffer ranges, and the actor's
-	*   time-aligned deduplication keeps the segment model accurate as new
-	*   segments arrive.
-	*
-	*   Cross-rendition track switches (audio language change, text language
-	*   change) do flush: the buffered content is semantically incompatible with
-	*   the newly-selected track, so overwrite-on-append would leave stale
-	*   content playing until each replacement segment lands. Today's predicate:
-	*   `actorCtx.initTrackLanguage !== track.language` — fires for language
-	*   changes, no-ops for video / same-language audio bitrate switches.
-	*   Future stage: pluggable predicate / strategy at actor construction time
-	*   for codec-change (5.1 surround) and other cross-rendition shapes.
-	*
-	* Case 2 — Init: schedule if not yet committed for this track.
-	*
-	* Case 3 — Segments: all segments in the load window not yet committed.
+	* @todo Rename alongside LoadTask (e.g. planOps). Case 1 — Removes: forward and back buffer flush points,
+	*   segment-aligned. ABR-style track switches (same content, different bitrate) do not flush: appending new content
+	*   overwrites existing buffer ranges, and the actor's time-aligned deduplication keeps the segment model accurate as
+	*   new segments arrive. Cross-rendition track switches (audio language change, text language change) do flush: the
+	*   buffered content is semantically incompatible with the newly-selected track, so overwrite-on-append would leave
+	*   stale content playing until each replacement segment lands. Today's predicate: `actorCtx.initTrackLanguage !==
+	*   track.language` — fires for language changes, no-ops for video / same-language audio bitrate switches. Future
+	*   stage: pluggable predicate / strategy at actor construction time for codec-change (5.1 surround) and other
+	*   cross-rendition shapes. Case 2 — Init: schedule if not yet committed for this track. Case 3 — Segments: all
+	*   segments in the load window not yet committed.
 	*/
 	const planTasks = (message) => {
 		const { track, range } = message;