hls.js 1.5.12-0.canary.10366 → 1.5.12-0.canary.10367

package/src/controller/error-controller.ts

@@ -13,7 +13,7 @@ import type Hls from '../hls';
 import type { RetryConfig } from '../config';
 import type { NetworkComponentAPI } from '../types/component-api';
 import type { ErrorData } from '../types/events';
-import type { Fragment } from '../loader/fragment';
+import type { Fragment, MediaFragment } from '../loader/fragment';
 import type { LevelDetails } from '../loader/level-details';
 
 export const enum NetworkErrorAction {
@@ -127,10 +127,7 @@ export default class ErrorController
       case ErrorDetails.FRAG_PARSING_ERROR:
         // ignore empty segment errors marked as gap
         if (data.frag?.gap) {
-          data.errorAction = {
-            action: NetworkErrorAction.DoNothing,
-            flags: ErrorActionFlags.None,
-          };
+          data.errorAction = createDoNothingErrorAction();
           return;
         }
       // falls through
@@ -218,10 +215,13 @@ export default class ErrorController
       case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
       case ErrorDetails.REMUX_ALLOC_ERROR:
       case ErrorDetails.BUFFER_APPEND_ERROR:
-        data.errorAction = this.getLevelSwitchAction(
-          data,
-          data.level ?? hls.loadLevel,
-        );
+        // Buffer-controller can set errorAction when append errors can be ignored or resolved locally
+        if (!data.errorAction) {
+          data.errorAction = this.getLevelSwitchAction(
+            data,
+            data.level ?? hls.loadLevel,
+          );
+        }
         return;
       case ErrorDetails.INTERNAL_EXCEPTION:
       case ErrorDetails.BUFFER_APPENDING_ERROR:
@@ -230,10 +230,7 @@ export default class ErrorController
       case ErrorDetails.BUFFER_STALLED_ERROR:
       case ErrorDetails.BUFFER_SEEK_OVER_HOLE:
       case ErrorDetails.BUFFER_NUDGE_ON_STALL:
-        data.errorAction = {
-          action: NetworkErrorAction.DoNothing,
-          flags: ErrorActionFlags.None,
-        };
+        data.errorAction = createDoNothingErrorAction();
         return;
     }
 
@@ -387,7 +384,7 @@ export default class ErrorController
             const levelDetails = levels[candidate].details;
             if (levelDetails) {
               const fragCandidate = findFragmentByPTS(
-                data.frag,
+                data.frag as MediaFragment,
                 levelDetails.fragments,
                 data.frag.start,
               );
@@ -511,3 +508,14 @@ export default class ErrorController
     }
   }
 }
+
+export function createDoNothingErrorAction(resolved?: boolean): IErrorAction {
+  const errorAction: IErrorAction = {
+    action: NetworkErrorAction.DoNothing,
+    flags: ErrorActionFlags.None,
+  };
+  if (resolved) {
+    errorAction.resolved = true;
+  }
+  return errorAction;
+}

package/src/controller/fragment-finders.ts

@@ -1,5 +1,6 @@
 import BinarySearch from '../utils/binary-search';
 import type { Fragment, MediaFragment } from '../loader/fragment';
+import type { LevelDetails } from '../loader/level-details';
 
 /**
  * Returns first fragment whose endPdt value exceeds the given PDT, or null.
@@ -54,7 +55,7 @@ export function findFragmentByPDT(
  * @returns a matching fragment or null
  */
 export function findFragmentByPTS(
-  fragPrevious: Fragment | null,
+  fragPrevious: MediaFragment | null,
   fragments: MediaFragment[],
   bufferEnd: number = 0,
   maxFragLookUpTolerance: number = 0,
@@ -62,13 +63,19 @@ export function findFragmentByPTS(
 ): MediaFragment | null {
   let fragNext: MediaFragment | null = null;
   if (fragPrevious) {
-    fragNext =
-      fragments[(fragPrevious.sn as number) - fragments[0].sn + 1] || null;
+    fragNext = fragments[1 + fragPrevious.sn - fragments[0].sn] || null;
     // check for buffer-end rounding error
     const bufferEdgeError = (fragPrevious.endDTS as number) - bufferEnd;
     if (bufferEdgeError > 0 && bufferEdgeError < 0.0000015) {
       bufferEnd += 0.0000015;
     }
+    if (
+      fragNext &&
+      fragPrevious.level !== fragNext.level &&
+      fragNext.end <= fragPrevious.end
+    ) {
+      fragNext = fragments[2 + fragPrevious.sn - fragments[0].sn] || null;
+    }
   } else if (bufferEnd === 0 && fragments[0].start === 0) {
     fragNext = fragments[0];
   }
@@ -214,3 +221,26 @@ export function findFragWithCC(
     }
   });
 }
+
+export function findNearestWithCC(
+  details: LevelDetails | undefined,
+  cc: number,
+  fragment: MediaFragment,
+): MediaFragment | null {
+  if (details) {
+    if (details.startCC <= cc && details.endCC >= cc) {
+      const start = fragment.start;
+      const end = fragment.end;
+      return BinarySearch.search(details.fragments, (candidate) => {
+        if (candidate.cc < cc || candidate.end <= start) {
+          return 1;
+        } else if (candidate.cc > cc || candidate.start >= end) {
+          return -1;
+        } else {
+          return 0;
+        }
+      });
+    }
+  }
+  return null;
+}

package/src/controller/fragment-tracker.ts

@@ -47,6 +47,7 @@ export class FragmentTracker implements ComponentAPI {
 
   private _registerListeners() {
     const { hls } = this;
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
@@ -54,6 +55,7 @@ export class FragmentTracker implements ComponentAPI {
 
   private _unregisterListeners() {
     const { hls } = this;
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
@@ -143,6 +145,7 @@ export class FragmentTracker implements ComponentAPI {
     timeRange: TimeRanges,
     playlistType: PlaylistLevelType,
     appendedPart?: Part | null,
+    removeAppending?: boolean,
   ) {
     if (this.timeRanges) {
       this.timeRanges[elementaryStream] = timeRange;
@@ -158,7 +161,10 @@ export class FragmentTracker implements ComponentAPI {
       if (appendedPartSn >= fragmentEntity.body.sn) {
         return;
       }
-      if (!fragmentEntity.buffered && !fragmentEntity.loaded) {
+      if (
+        !fragmentEntity.buffered &&
+        (!fragmentEntity.loaded || removeAppending)
+      ) {
         if (fragmentEntity.body.type === playlistType) {
           this.removeFragment(fragmentEntity.body);
         }
@@ -168,6 +174,10 @@ export class FragmentTracker implements ComponentAPI {
       if (!esData) {
         return;
       }
+      if (esData.time.length === 0) {
+        this.removeFragment(fragmentEntity.body);
+        return;
+      }
       esData.time.some((time: FragmentTimeRange) => {
         const isNotBuffered = !this.isTimeBuffered(
           time.startPTS,
@@ -387,6 +397,10 @@ export class FragmentTracker implements ComponentAPI {
     return false;
   }
 
+  private onManifestLoading() {
+    this.removeAllFragments();
+  }
+
   private onFragLoaded(event: Events.FRAG_LOADED, data: FragLoadedData) {
     // don't track initsegment (for which sn is not a number)
     // don't track frags used for bitrateTest, they're irrelevant.
@@ -439,6 +453,21 @@ export class FragmentTracker implements ComponentAPI {
     return !!this.fragments[fragKey];
   }
 
+  public hasFragments(type?: PlaylistLevelType): boolean {
+    const { fragments } = this;
+    const keys = Object.keys(fragments);
+    if (!type) {
+      return keys.length > 0;
+    }
+    for (let i = keys.length; i--; ) {
+      const fragmentEntity = fragments[keys[i]];
+      if (fragmentEntity?.body.type === type) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   public hasParts(type: PlaylistLevelType): boolean {
     return !!this.activePartLists[type]?.length;
   }

package/src/controller/stream-controller.ts

@@ -2,6 +2,7 @@ import BaseStreamController, { State } from './base-stream-controller';
 import { changeTypeSupported } from '../is-supported';
 import { Events } from '../events';
 import { BufferHelper, BufferInfo } from '../utils/buffer-helper';
+import { findFragmentByPTS } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
 import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
 import {
@@ -16,15 +17,15 @@ import { ErrorDetails } from '../errors';
 import type { NetworkComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 import type { Level } from '../types/level';
-import type { LevelDetails } from '../loader/level-details';
 import type { FragmentTracker } from './fragment-tracker';
 import type KeyLoader from '../loader/key-loader';
 import type { TransmuxerResult } from '../types/transmuxer';
-import type { TrackSet } from '../types/track';
+import type { Track, TrackSet } from '../types/track';
 import type { SourceBufferName } from '../types/buffer';
 import type {
   AudioTrackSwitchedData,
   AudioTrackSwitchingData,
+  BufferCodecsData,
   BufferCreatedData,
   BufferEOSData,
   BufferFlushedData,
@@ -364,7 +365,6 @@ export default class StreamController
   ) {
     // Check if fragment is not loaded
     const fragState = this.fragmentTracker.getState(frag);
-    this.fragCurrent = frag;
     if (
       fragState === FragmentState.NOT_LOADED ||
       fragState === FragmentState.PARTIAL
@@ -377,7 +377,6 @@ export default class StreamController
         );
         this._loadBitrateTestFrag(frag, level);
       } else {
-        this.startFragRequested = true;
         super.loadFragment(frag, level, targetBufferTime);
       }
     } else {
@@ -570,18 +569,14 @@ export default class StreamController
   };
 
   protected onManifestLoading() {
+    super.onManifestLoading();
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
     this.hls.trigger(Events.BUFFER_RESET, undefined);
-    this.fragmentTracker.removeAllFragments();
     this.couldBacktrack = false;
-    this.startPosition = this.lastCurrentTime = this.fragLastKbps = 0;
-    this.levels =
-      this.fragPlaying =
-      this.backtrackFragment =
-      this.levelLastLoaded =
-        null;
-    this.altAudio = this.audioOnly = this.startFragRequested = false;
+    this.fragLastKbps = 0;
+    this.fragPlaying = this.backtrackFragment = null;
+    this.altAudio = this.audioOnly = false;
   }
 
   private onManifestParsed(
@@ -705,7 +700,7 @@ export default class StreamController
       return;
     }
     const currentLevel = levels[frag.level];
-    const details = currentLevel.details as LevelDetails;
+    const details = currentLevel.details;
     if (!details) {
       this.warn(
         `Dropping fragment ${frag.sn} of level ${frag.level} after level details were reset`,
@@ -878,7 +873,7 @@ export default class StreamController
       (8 * stats.total) / (stats.buffering.end - stats.loading.first),
     );
     if (frag.sn !== 'initSegment') {
-      this.fragPrevious = frag;
+      this.fragPrevious = frag as MediaFragment;
     }
     this.fragBufferedComplete(frag, part);
   }
@@ -956,7 +951,7 @@ export default class StreamController
     // in that case, reset startFragRequested flag
     if (!this.loadedmetadata) {
       this.startFragRequested = false;
-      this.nextLoadPosition = this.startPosition;
+      this.nextLoadPosition = this.lastCurrentTime;
     }
     this.tickImmediate();
   }
@@ -1068,7 +1063,7 @@ export default class StreamController
   }
 
   private _handleTransmuxComplete(transmuxResult: TransmuxerResult) {
-    const id = 'main';
+    const id = this.playlistType;
     const { hls } = this;
     const { remuxResult, chunkMeta } = transmuxResult;
 
@@ -1308,6 +1303,7 @@ export default class StreamController
           currentLevel.audioCodec || ''
         }/${audio.codec}]`,
       );
+      delete tracks.audiovideo;
     }
     if (video) {
       video.levelCodec = currentLevel.videoCodec;
@@ -1319,28 +1315,34 @@ export default class StreamController
           video.codec
         }]`,
       );
+      delete tracks.audiovideo;
     }
     if (audiovideo) {
       this.log(
         `Init audiovideo buffer, container:${audiovideo.container}, codecs[level/parsed]=[${currentLevel.codecs}/${audiovideo.codec}]`,
       );
+      delete tracks.video;
+      delete tracks.audio;
+    }
+    const trackTypes = Object.keys(tracks);
+    if (trackTypes.length) {
+      this.hls.trigger(Events.BUFFER_CODECS, tracks as BufferCodecsData);
+      // loop through tracks that are going to be provided to bufferController
+      trackTypes.forEach((trackName) => {
+        const track = tracks[trackName] as Track;
+        const initSegment = track.initSegment;
+        if (initSegment?.byteLength) {
+          this.hls.trigger(Events.BUFFER_APPENDING, {
+            type: trackName as SourceBufferName,
+            data: initSegment,
+            frag,
+            part: null,
+            chunkMeta,
+            parent: frag.type,
+          });
+        }
+      });
     }
-    this.hls.trigger(Events.BUFFER_CODECS, tracks);
-    // loop through tracks that are going to be provided to bufferController
-    Object.keys(tracks).forEach((trackName) => {
-      const track = tracks[trackName];
-      const initSegment = track.initSegment;
-      if (initSegment?.byteLength) {
-        this.hls.trigger(Events.BUFFER_APPENDING, {
-          type: trackName as SourceBufferName,
-          data: initSegment,
-          frag,
-          part: null,
-          chunkMeta,
-          parent: frag.type,
-        });
-      }
-    });
     // trigger handler right now
     this.tickImmediate();
   }
@@ -1425,26 +1427,31 @@ export default class StreamController
   }
 
   get currentFrag(): Fragment | null {
-    const media = this.media;
-    if (media) {
-      return this.fragPlaying || this.getAppendedFrag(media.currentTime);
+    if (this.fragPlaying) {
+      return this.fragPlaying;
+    }
+    const currentTime = this.media?.currentTime || this.lastCurrentTime;
+    if (Number.isFinite(currentTime)) {
+      return this.getAppendedFrag(currentTime);
     }
     return null;
   }
 
   get currentProgramDateTime(): Date | null {
-    const media = this.media;
-    if (media) {
-      const currentTime = media.currentTime;
-      const frag = this.currentFrag;
-      if (
-        frag &&
-        Number.isFinite(currentTime) &&
-        Number.isFinite(frag.programDateTime)
-      ) {
-        const epocMs =
-          (frag.programDateTime as number) + (currentTime - frag.start) * 1000;
-        return new Date(epocMs);
+    const currentTime = this.media?.currentTime || this.lastCurrentTime;
+    if (Number.isFinite(currentTime)) {
+      const details = this.getLevelDetails();
+      const frag =
+        this.currentFrag ||
+        (details
+          ? findFragmentByPTS(null, details.fragments, currentTime)
+          : null);
+      if (frag) {
+        const programDateTime = frag.programDateTime;
+        if (programDateTime !== null) {
+          const epocMs = programDateTime + (currentTime - frag.start) * 1000;
+          return new Date(epocMs);
+        }
       }
     }
     return null;

package/src/controller/subtitle-stream-controller.ts

@@ -106,8 +106,8 @@ export class SubtitleStreamController
   }
 
   protected onManifestLoading() {
+    super.onManifestLoading();
     this.mainDetails = null;
-    this.fragmentTracker.removeAllFragments();
   }
 
   protected onMediaDetaching(): void {
@@ -124,7 +124,9 @@ export class SubtitleStreamController
     data: SubtitleFragProcessed,
   ) {
     const { frag, success } = data;
-    this.fragPrevious = frag;
+    if (frag.sn !== 'initSegment') {
+      this.fragPrevious = frag as MediaFragment;
+    }
     this.state = State.IDLE;
     if (!success) {
       return;
@@ -491,11 +493,9 @@ export class SubtitleStreamController
     level: Level,
     targetBufferTime: number,
   ) {
-    this.fragCurrent = frag;
     if (frag.sn === 'initSegment') {
       this._loadInitSegment(frag, level);
     } else {
-      this.startFragRequested = true;
       super.loadFragment(frag, level, targetBufferTime);
     }
   }

package/src/controller/timeline-controller.ts

@@ -192,7 +192,7 @@ export class TimelineController implements ComponentAPI {
     { frag, id, initPTS, timescale }: InitPTSFoundData,
   ) {
     const { unparsedVttFrags } = this;
-    if (id === 'main') {
+    if (id === PlaylistLevelType.MAIN) {
       this.initPTS[frag.cc] = { baseTime: initPTS, timescale };
     }
 

package/src/hls.ts

@@ -232,7 +232,7 @@ export default class Hls implements HlsEventEmitter {
         new AudioStreamControllerClass(this, fragmentTracker, keyLoader),
       );
     }
-    // subtitleTrackController must be defined before subtitleStreamController because the order of event handling is important
+    // Instantiate subtitleTrackController before SubtitleStreamController to receive level events first
     this.subtitleTrackController = this.createController(
       config.subtitleTrackController,
       networkControllers,

package/src/loader/fragment-loader.ts

@@ -1,18 +1,17 @@
 import { ErrorTypes, ErrorDetails } from '../errors';
-import { Fragment } from './fragment';
-import type {
-  Loader,
-  LoaderConfiguration,
-  FragmentLoaderContext,
-} from '../types/loader';
 import { getLoaderConfigWithoutReties } from '../utils/error-helper';
 import type { HlsConfig } from '../config';
-import type { BaseSegment, Part } from './fragment';
+import type { BaseSegment, Fragment, Part } from './fragment';
 import type {
   ErrorData,
   FragLoadedData,
   PartsLoadedData,
 } from '../types/events';
+import type {
+  Loader,
+  LoaderConfiguration,
+  FragmentLoaderContext,
+} from '../types/loader';
 
 const MIN_CHUNK_SIZE = Math.pow(2, 17); // 128kb
 
@@ -77,13 +76,11 @@ export default class FragmentLoader {
           frag.gap = false;
         }
       }
-      const loader =
-        (this.loader =
-        frag.loader =
-          FragmentILoader
-            ? new FragmentILoader(config)
-            : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
+      const loader = (this.loader = FragmentILoader
+        ? new FragmentILoader(config)
+        : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
       const loaderContext = createLoaderContext(frag);
+      frag.loader = loader;
       const loadPolicy = getLoaderConfigWithoutReties(
         config.fragLoadPolicy.default,
       );
@@ -188,13 +185,11 @@ export default class FragmentLoader {
         reject(createGapLoadError(frag, part));
         return;
       }
-      const loader =
-        (this.loader =
-        frag.loader =
-          FragmentILoader
-            ? new FragmentILoader(config)
-            : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
+      const loader = (this.loader = FragmentILoader
+        ? new FragmentILoader(config)
+        : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
       const loaderContext = createLoaderContext(frag, part);
+      frag.loader = loader;
       // Should we define another load policy for parts?
       const loadPolicy = getLoaderConfigWithoutReties(
         config.fragLoadPolicy.default,

package/src/loader/fragment.ts

@@ -127,9 +127,9 @@ export class Fragment extends BaseSegment {
   // The ending Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
   public endPTS?: number;
   // The starting Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
-  public startDTS!: number;
+  public startDTS?: number;
   // The ending Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
-  public endDTS!: number;
+  public endDTS?: number;
   // The start time of the fragment, as listed in the manifest. Updated after transmux complete.
   public start: number = 0;
   // Set by `updateFragPTSDTS` in level-helper

package/src/loader/level-details.ts

@@ -1,6 +1,5 @@
-import type { Part } from './fragment';
+import type { Fragment, MediaFragment, Part } from './fragment';
 import type { DateRange } from './date-range';
-import type { Fragment, MediaFragment } from './fragment';
 import type { AttrList } from '../utils/attr-list';
 import type { VariableMap } from '../types/level';
 

package/src/loader/playlist-loader.ts

@@ -452,7 +452,6 @@ class PlaylistLoader implements NetworkComponentAPI {
     const { id, level, type } = context;
 
     const url = getResponseUrl(response, context);
-    const levelUrlId = 0;
     const levelId = Number.isFinite(level as number)
       ? (level as number)
       : Number.isFinite(id as number)
@@ -464,7 +463,7 @@ class PlaylistLoader implements NetworkComponentAPI {
       url,
       levelId,
       levelType,
-      levelUrlId,
+      0,
       this.variableList,
     );
 

package/src/remux/mp4-remuxer.ts

@@ -160,15 +160,18 @@ export default class MP4Remuxer implements Remuxer {
       if (this.ISGenerated) {
         const config = this.videoTrackConfig;
         if (
-          config &&
-          (videoTrack.width !== config.width ||
-            videoTrack.height !== config.height ||
-            videoTrack.pixelRatio?.[0] !== config.pixelRatio?.[0] ||
-            videoTrack.pixelRatio?.[1] !== config.pixelRatio?.[1])
+          (config &&
+            (videoTrack.width !== config.width ||
+              videoTrack.height !== config.height ||
+              videoTrack.pixelRatio?.[0] !== config.pixelRatio?.[0] ||
+              videoTrack.pixelRatio?.[1] !== config.pixelRatio?.[1])) ||
+          (!config && enoughVideoSamples) ||
+          (this.nextAudioPts === null && enoughAudioSamples)
         ) {
           this.resetInitSegment();
         }
-      } else {
+      }
+      if (!this.ISGenerated) {
         initSegment = this.generateIS(
           audioTrack,
           videoTrack,
@@ -1085,8 +1088,9 @@ export default class MP4Remuxer implements Remuxer {
     const startDTS: number =
       (nextAudioPts !== null
         ? nextAudioPts
-        : videoData.startDTS * inputTimeScale) + init90kHz;
-    const endDTS: number = videoData.endDTS * inputTimeScale + init90kHz;
+        : (videoData.startDTS as number) * inputTimeScale) + init90kHz;
+    const endDTS: number =
+      (videoData.endDTS as number) * inputTimeScale + init90kHz;
     // one sample's duration value
     const frameDuration: number = scaleFactor * AAC_SAMPLES_PER_FRAME;
     // samples count of this segment's duration

package/src/remux/passthrough-remuxer.ts

@@ -178,7 +178,7 @@ class PassThroughRemuxer implements Remuxer {
       initSegment.initPTS = decodeTime - timeOffset;
       if (initPTS && initPTS.timescale === 1) {
         logger.warn(
-          `Adjusting initPTS by ${initSegment.initPTS - initPTS.baseTime}`,
+          `Adjusting initPTS @${timeOffset} from ${initPTS.baseTime / initPTS.timescale} to ${initSegment.initPTS}`,
         );
       }
       this.initPTS = initPTS = {

package/src/types/events.ts

@@ -192,6 +192,18 @@ export interface LevelUpdatedData {
   level: number;
 }
 
+export interface AudioTrackUpdatedData {
+  details: LevelDetails;
+  id: number;
+  groupId: string;
+}
+
+export interface SubtitleTrackUpdatedData {
+  details: LevelDetails;
+  id: number;
+  groupId: string;
+}
+
 export interface LevelPTSUpdatedData {
   details: LevelDetails;
   level: Level;
@@ -317,7 +329,7 @@ export interface NonNativeTextTracksData {
 }
 
 export interface InitPTSFoundData {
-  id: string;
+  id: PlaylistLevelType;
   frag: MediaFragment;
   initPTS: number;
   timescale: number;

package/src/utils/level-helper.ts

@@ -461,11 +461,10 @@ export function computeReloadInterval(
 }
 
 export function getFragmentWithSN(
-  level: Level,
+  details: LevelDetails | undefined,
   sn: number,
   fragCurrent: Fragment | null,
 ): MediaFragment | null {
-  const details = level?.details;
   if (!details) {
     return null;
   }
@@ -485,14 +484,14 @@ export function getFragmentWithSN(
 }
 
 export function getPartWith(
-  level: Level,
+  details: LevelDetails | undefined,
   sn: number,
   partIndex: number,
 ): Part | null {
-  if (!level?.details) {
+  if (!details) {
     return null;
   }
-  return findPart(level.details?.partList, sn, partIndex);
+  return findPart(details.partList, sn, partIndex);
 }
 
 export function findPart(