diff --git a/demo/scripts/controllers/ContentList.tsx b/demo/scripts/controllers/ContentList.tsx
index 1b91b72517..9ece7b4724 100644
--- a/demo/scripts/controllers/ContentList.tsx
+++ b/demo/scripts/controllers/ContentList.tsx
@@ -260,10 +260,12 @@ function getKeySystemsOption(
 
 function ContentList({
   loadVideo,
+  preloadVideo,
   showOptions,
   onOptionToggle,
 }: {
   loadVideo: (opts: ILoadVideoOptions) => void;
+  preloadVideo: (opts: ILoadVideoOptions) => void;
   showOptions: boolean;
   onOptionToggle: () => void;
 }): React.JSX.Element {
@@ -327,6 +329,43 @@ function ContentList({
     [loadVideo],
   );
 
+  /**
+   * Load the given displayed content through the player.
+   * @param {Object|null} content
+   */
+  const preloadContent = React.useCallback(
+    (content: IDisplayedContent) => {
+      const {
+        url,
+        transport,
+        fallbackKeyError,
+        fallbackLicenseRequest,
+        isLowLatency,
+        drmInfos,
+      } = content;
+
+      getKeySystemsOption(drmInfos ?? [], {
+        fallbackKeyError: !!fallbackKeyError,
+        fallbackLicenseRequest: !!fallbackLicenseRequest,
+      }).then(
+        (keySystems) => {
+          preloadVideo({
+            url: url ?? "",
+            transport: transport ?? "",
+            textTrackMode: "html",
+            lowLatencyMode: isLowLatency,
+            keySystems,
+          });
+        },
+        () => {
+          /* eslint-disable-next-line no-console */
+          console.error("Could not construct key systems option");
+        },
+      );
+    },
+    [loadVideo],
+  );
+
   /**
    * Load a custom content entered in a custom link.
    * @param {string} url
@@ -362,6 +401,41 @@ function ContentList({
     ],
   );
 
+  /**
+   * Load a custom content entered in a custom link.
+   * @param {string} url
+   * @param {Array.<Object>} drmInfos
+   */
+  const preloadUrl = React.useCallback(
+    (url: string, drmInfos: IDrmInfo[]) => {
+      getKeySystemsOption(drmInfos, {
+        fallbackKeyError: !!shouldFallbackOnKeyError,
+        fallbackLicenseRequest: !!shouldFallbackOnLicenseReqError,
+      }).then(
+        (keySystems) => {
+          preloadVideo({
+            url: url,
+            transport: transportType.toLowerCase(),
+            textTrackMode: "html",
+            lowLatencyMode: isLowLatencyChecked,
+            keySystems,
+          });
+        },
+        () => {
+          /* eslint-disable-next-line no-console */
+          console.error("Could not construct key systems option");
+        },
+      );
+    },
+    [
+      loadVideo,
+      shouldFallbackOnKeyError,
+      shouldFallbackOnLicenseReqError,
+      transportType,
+      isLowLatencyChecked,
+    ],
+  );
+
   /**
    * Change the content chosen in the list.
    * @param {number} index - index in the lsit
@@ -530,6 +604,22 @@ function ContentList({
     }
   };
 
+  const onClickPreload = () => {
+    if (contentChoiceIndex === 0) {
+      const drmInfos = [
+        {
+          licenseServerUrl,
+          serverCertificateUrl,
+          drm: chosenDRMType,
+          customKeySystem,
+        },
+      ];
+      preloadUrl(currentManifestURL, drmInfos);
+    } else {
+      preloadContent(contentsToSelect[contentChoiceIndex]);
+    }
+  };
+
   const saveCurrentContent = () => {
     const contentToSave: IContentInfo = {
       name: contentNameField,
@@ -766,6 +856,13 @@ function ContentList({
             value={String.fromCharCode(0xf144)}
             disabled={false}
           />
+          <Button
+            className="choice-input-button load-button"
+            ariaLabel="Preload the selected content now"
+            onClick={onClickPreload}
+            value={String.fromCharCode(0x2b07)}
+            disabled={false}
+          />
         </div>
       </div>
       {isCustomContent || (isLocalContent && isSavingOrUpdating) ? (
diff --git a/demo/scripts/controllers/Player.tsx b/demo/scripts/controllers/Player.tsx
index 83b76aaf12..4f8220a2b1 100644
--- a/demo/scripts/controllers/Player.tsx
+++ b/demo/scripts/controllers/Player.tsx
@@ -213,7 +213,33 @@ function Player(): React.JSX.Element {
     }
   }, [playerModule]);
 
-  const startContent = useCallback(
+  const preloadContentCallback = useCallback(
+    (contentInfo: ILoadVideoOptions) => {
+      let playerMod = playerModule;
+
+      // TODO this risks stopping the previous content if instance options
+      // have been updated
+      if (playerMod === null || hasUpdatedPlayerOptions) {
+        setHasUpdatedPlayerOptions(false);
+        const created = createNewPlayerModule();
+        if (created === undefined) {
+          return;
+        }
+        created.actions.updateWorkerMode(relyOnWorker);
+        playerMod = created;
+      }
+      preloadContent(playerMod, contentInfo, loadVideoOpts);
+    },
+    [
+      playerModule,
+      relyOnWorker,
+      hasUpdatedPlayerOptions,
+      createNewPlayerModule,
+      loadVideoOpts,
+    ],
+  );
+
+  const startContentCallback = useCallback(
     (contentInfo: ILoadVideoOptions) => {
       let playerMod = playerModule;
       if (playerMod === null || hasUpdatedPlayerOptions) {
@@ -287,7 +313,8 @@ function Player(): React.JSX.Element {
     <section className="video-player-section">
       <div className="video-player-content">
         <ContentList
-          loadVideo={startContent}
+          loadVideo={startContentCallback}
+          preloadVideo={preloadContentCallback}
           showOptions={showOptions}
           onOptionToggle={onOptionToggle}
         />
@@ -380,4 +407,12 @@ function loadContent(
   playerModule.actions.load(Object.assign({}, contentInfo, loadVideoOpts));
 }
 
+function preloadContent(
+  playerModule: IPlayerModule,
+  contentInfo: ILoadVideoOptions,
+  loadVideoOpts: ILoadVideoSettings,
+) {
+  playerModule.actions.preload(Object.assign({}, contentInfo, loadVideoOpts));
+}
+
 export default Player;
diff --git a/demo/scripts/modules/player/index.ts b/demo/scripts/modules/player/index.ts
index db5d0f0880..1b4724a958 100644
--- a/demo/scripts/modules/player/index.ts
+++ b/demo/scripts/modules/player/index.ts
@@ -144,6 +144,10 @@ export interface IPlayerModuleState {
   onAudioTracksNotPlayable: "continue" | "error";
   onVideoTracksNotPlayable: "continue" | "error";
   playbackRate: number;
+  preloads: Array<{
+    url: string | undefined;
+    id: string;
+  }>;
   /** Try to play contents in "multithread" mode when possible. */
   relyOnWorker: boolean;
   /** Currently playing a content in "multithread" mode. */
@@ -204,6 +208,7 @@ const PlayerModule = declareModule(
     onAudioTracksNotPlayable: "error",
     onVideoTracksNotPlayable: "error",
     playbackRate: 1,
+    preloads: [],
     relyOnWorker: false,
     useWorker: false,
     subtitle: undefined,
@@ -297,6 +302,35 @@ const PlayerModule = declareModule(
         state.update("relyOnWorker", enabled);
       },
 
+      preload(arg: ILoadVideoOptions) {
+        const contentInfo = player.preloadVideo(
+          Object.assign(
+            {
+              mode: state.get("relyOnWorker") ? "auto" : "main",
+              textTrackElement,
+              transportOptions: { checkMediaSegmentIntegrity: true },
+            },
+            arg,
+          ) as ILoadVideoOptions,
+        );
+        const preloads = state.get("preloads");
+        preloads.push({
+          id: contentInfo.id,
+          url: arg.url,
+        });
+        state.update("preloads", preloads);
+      },
+
+      loadPreload(preloadId: string) {
+        player.startPreload(preloadId);
+        const preloads = state.get("preloads");
+        const index = preloads.findIndex((p) => p.id === preloadId);
+        if (index >= 0) {
+          preloads.splice(index, 1);
+        }
+        state.update("preloads", preloads);
+      },
+
       load(arg: ILoadVideoOptions) {
         dettachVideoThumbnailLoader();
         player.loadVideo(
diff --git a/src/ARCHITECTURE_DOC-PRELOADING.md b/src/ARCHITECTURE_DOC-PRELOADING.md
new file mode 100644
index 0000000000..67ae75711f
--- /dev/null
+++ b/src/ARCHITECTURE_DOC-PRELOADING.md
@@ -0,0 +1,264 @@
+# Preloading Architecture
+
+_Date of last update: 2025-02-10_
+
+This is a document describing the architecture choosen to allow "content preloading",
+which is an advanced feature in some MSE players where a future content is loaded before
+being actually played to lower the time it will take once the user want to play that
+content.
+
+It can be used as a mechanism to improve loading performance when we're very confident
+that the user will play a content yet we don't want to play it on the media element yet.
+It may also be used to accelerate the transition between contents that will be played
+sequentially on the same media element (advertisement cuts, switching between episodes of
+a TV serie etc.).
+
+As a supplementary goal, it may both be used explicitely by an application through an
+RxPlayer `API` or implicitely through an adaptive streaming technology mechanism that
+could profit from it (e.g. "interstitial" systems, MPD chaining etc.).
+
+## Preloading high level behavior
+
+After playing with multiple strategies, we for now chose to implement "preloading" by
+loading that content's media segments directly in JS memory (instead of pushing them to
+the lower-level browser's buffers). When/if the application then wants to actually load
+the content, we will push all of that stored data on the actual browser's buffers linked
+to the `HTMLMediaElement` (which is itself linked to the current RxPlayer instance).
+
+_An alternative solution that was studied was to preload and load all contents on the same
+`HTMLMediaElement`, only at an offseted time for each preload. Though it could lead to
+better performance (i.e. a simple seek to switch content is generally much faster than
+initializing all MSE API and then feeding it data), we decided to abandon that solution
+for now because of fears of compatibility issues._
+
+We also postpone some API calls, such as encryption-related ones, for when the content is
+actually played to increase device compatibility. This even though those
+encryption-related exchanges may themselves take time and even though they also can lead
+to multiple licence requests at once when the content is finally played.
+
+## RxPlayer API for preloading
+
+### Starting/Stopping a preload
+
+An application can ask for a content to be preloaded through a `preloadVideo` API, which
+will return a `contentId` identifier.
+
+That API can be called multiple times for various contents, to preload all them
+simultaneously, though it should be noted that there may be memory, performance, and
+bandwidth-related issues if pre-loading too much contents at once. This last point is for
+now considered as a problem left for the application, though we may provide improvements
+to help them with those points in the future as those are not subjects they're usually
+exposed to.
+
+An application can then actually load a preloaded content at any time by calling the
+`startPreload` API, which will stop the previous loaded content if one, but none of the
+potential other preloads.
+
+To stop preloading content, a `stopPreload` API was added. Also a `clearPreload` API was
+added to allow an application to stop all preloads it has started.
+
+### Track and quality selection
+
+All track-related API (`setAudioTrack`, `getAvailableVideoTracks` etc.) and
+representations-related API (`lockVideoRepresentation` etc.) now also accept an optional
+`contentId` in which case they apply to the preload concerned.
+
+### Preload events
+
+When preloading a content, an application might also want to subscribe to some of the same
+events than it does when loading a content. For example `newAvailablePeriods` to set the
+initial choosen tracks or `error` to be notified if the preload fails.
+
+Because of this, I duplicated those concerned events with a `preload-` prefix (reusing the
+same one would have either conflicted with those or broke the API):
+
+- `"preload-newAvailablePeriods"`
+- `"preload-brokenRepresentationsLock"`
+- `"preload-trackUpdate"`
+- `"preload-representationListUpdate"`
+- `"preload-error"`
+- `"preload-warning"`
+
+## Internal changes done for that new behavior
+
+One of the key design strategy I followed for content preloading was that that rarely-used
+feature should not greatly decrease the readability of the RxPlayer's architecture.
+
+With that in mind from the perspective of the RxPlayer's inner code, the main differences
+between a content that is pre-loading and a content that is actually loading is that:
+
+1. the pre-loaded content doesn't have an `HTMLMediaElement` (e.g. the `<video>` tag) yet,
+   though it will have one if we ever play it.
+2. its `MediaSource` (the main object in the MSE group of API, which allows to feed media
+   data programatically to an `HTMLMediaElement`) is not yet "ready" to play contents,
+3. and as such `SourceBuffer`s (MSE media buffers) cannot yet be added.
+
+### Working around not having the `HTMLMediaElement` when pre-loading
+
+As the `HTMLMediaElement` is only playing the content when actually loading, not
+pre-loading, I decided the following modifications:
+
+1. For a few modules, they now can function with **AND** without an `HTMLMediaElement`
+   yet. In the cases where an `HTMLMediaElement` hasn't been provided to it , they behave
+   in a not-yet-ready state as if an `HTMLMediaElement` will be provided to it in the
+   future coincidentally with actual playback.
+
+   For example, `ITextDisplayer` implementations will store subtitles but not display them
+   on screen synchronized with the media element until... a media element has actually
+   been provided through its `attachMediaElement` method (which may be called when/if the
+   application finally decide to actually load that preload).
+
+   Likewise, a `MediaElementPlaybackObserver` will just advertise about the default
+   initial position until an actual `HTMLMediaElement` has been provided here also though
+   an `attachMediaElement` method.
+
+2. For most other cases, I removed direct usage of the `HTMLMediaElement` to prefer
+   relying on the `MediaElementPlaybackObserver` instead, which is already intrinsically
+   linked to the `HTMLMediaElement`.
+
+   I then added to the `MediaElementPlaybackObserver` a method called
+   `onMediaElementAttachment` which allows to register a callback that will be called once
+   the `HTMLMediaElement` has been attached to it (or called immediately and synchronously
+   if it is already the case). This is what those other modules can rely on to declare
+   logic relying on the media element.
+
+### Working around not having `SourceBuffer` objects
+
+`SourceBuffer` are very important here because preloading is all about loading in advance
+media segments and because under the RxPlayer's "normal" (i.e. "loading", not
+"preloading") behavior, media segments were immediately pushed to their `SourceBuffer`
+after loading them (with the RxPlayer preferably not keeping an in-memory reference to
+that huge chunk of data).
+
+To be more exact, the RxPlayer most often do not use `SourceBuffer` objects directly, it
+uses multiple abstractions to reach them :
+
+1. the `SourceBufferInterface` abstraction which provides a more sensible API
+   (promise-based methods instead of the older-school event-based API `SourceBuffer`
+   objects have, queue system abstracted instead of exposed to the application) yet which
+   stays roughly at the same functional level than a `SourceBuffer`: it serves the same
+   purpose - adding and removing media data from lower-levels buffers - and do no more.
+
+2. At a higher level, `SourceBufferInterface` are then used by the `AudioVideoSegmentSink`
+   abstraction.
+
+   They implement multiple features to facilitate the usage of those buffers: an
+   `inventory` of the currently-pushed segments' metadata, it has an history system of
+   recent operations, pending operations that have not yet finished can be inspected and
+   other higher-level niceties.
+
+   It is then `AudioVideoSegmentSink` instances that are used by most of the RxPlayer's
+   modules.
+
+#### Making the `AudioVideoSegmentSink` work without a `SourceBufferInterface`
+
+The solution I proposed here is to make the `AudioVideoSegmentSink` temporarily work
+without a `SourceBufferInterface` and in that scenario to instead store all asked
+operations (segment pushing, data remove etc.) in-memory.
+
+From outside code, the corresponding operation's Promises will just be left opened,
+indicating that those operations have not yet been performed succesfully yet.
+
+When it is finally possible to obtain a `SourceBuffer` / `SourceBufferInterface`, the
+`AudioVideoSegmentSink`'s `linkToMediaSource` method is called, which has the effect to
+directly communicate all operations pending in memory to that `SourceBufferInterface`. It
+is at that point that those operations' Promises are bound to the actual `SourceBuffer`
+operation.
+
+All that happens completely transparently so that other modules continue to interact with
+the `AudioVideoSegmentSink` without even knowing that it is currently in the process of
+"transferring" data from memory to a `SourceBuffer`.
+
+### Working around not having a ready `MediaSource`
+
+Under normal ("loading") conditions, we create a `MediaSource` object almost immediately
+after the `loadVideo` API is called, attach it to the `HTMLMediaElement` and then wait for
+that `MediaSource`'s `readyState` property to switch to `"open"` and for the `MediaKeys`
+to be linked to the `HTMLMediaElement`. All this so we can then load segments on the
+`SourceBuffer` and start playing.
+
+We do not want to link a `MediaSource` nor a `MediaKeys` to the `HTMLMediaElement` when
+preloading though.
+
+To work-around this, the `Core` part of the RxPlayer now separates the concept of being
+"ready" to fetch+push segments and the concept of having the media element actually
+available for playback: the `Core` will start by creating a `SegmentSinksStore` without a
+`MediaSource`.
+
+Note that for code simplification purposes, this for now happen for all contents - not
+just the preloaded ones. We thus **always** begin by creating `AudioVideoSegmentSink`
+storing segments in memory before actually switching to the real deal when ready.
+
+Generally when actually "loading" (and not "preloading"), segment fetching should take
+longer than the `MediaSource` and `MediaKeys` attachment logic in which case there
+shouldn't really be an observable in-JS storing of segments, not that this would be a
+problem anyway. It might even end up improving performance on devices where either
+`MediaSource`, `MediaKeys` attachment or both took a long time.
+
+This is implemented through a supplementary message from `main_thread` to `core`:
+`MediaElementReady`.
+
+## Memory concerns
+
+Considering we already have memory-related concerns on many devices (especially some smart
+TV and set-top boxes), enabling a preload feature on them seems for now a little
+ambitious: instead of loading a single content and having trouble doing so, we may here
+not only load a content but also pre-load the future one at the same time.
+
+This is something I had in mind when doing the implementation, and the end goal is to
+allow the preloading feature to be enabled even on those devices. The key factor we may
+want to consider here is how easy it will be to integrate that notion with the current
+preloading implementation. I saw multiple possible compatible ways (e.g. synchronizing
+options like `maxVideoBufferSize` so it also consider preloads could seem logical) but did
+not do anything in that sense yet to keep the initial implementation """"simple"""".
+
+## Can this work be reused for a content downloading feature
+
+As I know there is some long term need for this, both at Canal+ and from outsiders, and as
+it may seem similar to a downloading concept (as when preloading, contents are also loaded
+for later), I thought that I had to add this chapter to this documentation.
+
+The answer is: I don't think so.
+
+For downloads, the solution found by other implementations we've seen have many key
+differences:
+
+- they favor the highest compatible media quality without network bandwidth
+  considerations, where content preloading starts from the idea that playback will soon
+  start and thus act like our regular playback logic on that point
+
+- for downloaded contents, playback will most often start much later, in a different
+  browsing session and thus in a different RxPlayer instance. In contrast with
+  "preloading" where preloading and actually playing are usually close in time to each
+  other and are always on the same RxPlayer instance.
+
+  The current preloading solution proposed is basically about handling a "not-yet-playing"
+  mode, where the media element can then be "hot-swapped" (well, "hot-inserted") to enable
+  actual playback on the current RxPlayer instance.
+
+  This also means that all modules handling playback-related issues are in-place (and
+  there's a LOT of them) because they might be imminently-needed. This is just added
+  complexity in a context where the content will not be actually played in that same
+  session.
+
+Because of those, I actually think that having a separate code path/architecture for
+content downloading than for content loading and preloading would be easier to follow and
+maintain (though we know some people do not believe us on this :p!). Most advanced
+features worked-around here (`SegmentSink` inventories, `HTMLMediaElement` usage,
+`PlaybackObserver` etc.) are not needed at all for content downloading because they are
+linked to content playback.
+
+The main logic of content downloading seem actually easier to implement than what we're
+doing here, the complexities we had at the time of our first attempts (at implementing
+content downloading) were mostly linked to device compatibility with some advanced
+features (e.g. available long-term storage API on some devices, persistent licence
+implementation) and all the necessary code around the inevitable downloading-specific
+issues (no space left on storage, async suppression of downloaded contents that may be
+interrupted by the user closing the page etc.).
+
+Adding those orthogonal complexities linked to content downloading on top of the
+preloading API would complexify the "regular" code for in my opinion no real gain.
+Re-using in a separate location loading-related modules (`segmentFetcher`,
+`manifestFetcher`), selecting Representations through an util and a well-defined API, and
+then loading and storing all of their segments sequentially (code which would be written
+in that downloading-specific directory) seems much easier to implement.
diff --git a/src/core/entry/content_preparer.ts b/src/core/entry/content_preparer.ts
index dc8fd21052..75299a4681 100644
--- a/src/core/entry/content_preparer.ts
+++ b/src/core/entry/content_preparer.ts
@@ -91,8 +91,15 @@ export default class ContentPreparer {
    * are all ready and you can thus begin to load the content.
    *
    * Reject if it failed to do so.
+   * NOTE: The `MediaSource` which will allow to actually play the content on
+   * screen is not yet created here, media stored by the linked
+   * `SegmentSinksStore` will first begin to be stored in-memory until the
+   * `attachMediaSource` method is called.
+   *
+   * @param {Function} sendMessage
    * @param {Object} context - Information on the content that should be
    * initialized.
+   * @param {Object} throttlers
    * @param {Object} corePlugins - Callbacks that may have been registered by
    * the application if it loaded the core independently as a worker.
    * @returns {Promise.<Object>}
@@ -122,8 +129,6 @@ export default class ContentPreparer {
         enableRepresentationAvoidance,
         transport,
       } = context;
-      let manifest: IManifest | null = null;
-
       const transportFn = features.transports[transport];
       if (typeof transportFn !== "function") {
         rej(
@@ -179,24 +184,22 @@ export default class ContentPreparer {
 
       const trackChoiceSetter = new TrackChoiceSetter();
 
-      const [mediaSource, segmentSinksStore, coreTextSender] =
-        createMediaSourceInterfaceAndSegmentSinksStore(
-          sendMessage,
-          contentId,
-          {
-            mseInWorker: playbackSupport.mseInWorker,
-            videoTrack: playbackSupport.videoTrack,
-            textTrack: playbackSupport.textTrack,
-          },
-          currentMediaSourceCanceller.signal,
-        );
+      const [segmentSinksStore, coreTextSender] = createSegmentSinksStore(
+        sendMessage,
+        contentId,
+        {
+          videoTrack: playbackSupport.videoTrack,
+          textTrack: playbackSupport.textTrack,
+        },
+        currentMediaSourceCanceller.signal,
+      );
       const freezeResolver = new FreezeResolver(segmentSinksStore);
-      this._currentContent = {
+      const currentContent: IPreparedContentData = {
         cmcdDataBuilder,
         contentId,
         enableRepresentationAvoidance,
         freezeResolver,
-        mediaSource,
+        mediaSource: null,
         manifest: null,
         manifestFetcher,
         representationEstimator,
@@ -209,13 +212,7 @@ export default class ContentPreparer {
         videoTrack: playbackSupport.videoTrack,
         textTrack: playbackSupport.textTrack,
       };
-      mediaSource.addEventListener(
-        "mediaSourceOpen",
-        function () {
-          checkIfReadyAndValidate();
-        },
-        currentMediaSourceCanceller.signal,
-      );
+      this._currentContent = currentContent;
 
       contentCanceller.signal.register((err) => {
         manifestFetcher.dispose(err.reason);
@@ -233,18 +230,8 @@ export default class ContentPreparer {
       );
       manifestFetcher.addEventListener(
         "manifestReady",
-        (man: IManifest) => {
-          if (manifest !== null) {
-            log.warn("Core", "Multiple `manifestReady` events, ignoring");
-            return;
-          }
-          manifest = man;
-          if (this._currentContent !== null) {
-            this._currentContent.manifest = manifest;
-          }
-          checkIfReadyAndValidate();
-        },
-        currentMediaSourceCanceller.signal,
+        resolveWithManifest,
+        contentCanceller.signal,
       );
       manifestFetcher.addEventListener(
         "error",
@@ -255,14 +242,11 @@ export default class ContentPreparer {
       );
       manifestFetcher.start();
 
-      function checkIfReadyAndValidate() {
-        if (
-          manifest === null ||
-          mediaSource.readyState === "closed" ||
-          currentMediaSourceCanceller.isUsed()
-        ) {
+      function resolveWithManifest(manifest: IManifest) {
+        if (contentCanceller.isUsed()) {
           return;
         }
+        currentContent.manifest = manifest;
         updateCodecSupportInWorkerMode(manifest);
         manifest.addEventListener(
           "manifestUpdate",
@@ -295,6 +279,69 @@ export default class ContentPreparer {
     return this._currentContent;
   }
 
+  /**
+   * Actually `attach` a `MediaSource` for the content currently prepared through
+   * the `initializeNewContent` method (it didn't have to resolve yet).
+   *
+   * This allows to actually push media data to the media element on the page
+   * instead of in-memory.
+   *
+   * Note that calling `attachMediaSource` despite already having a `MediaSource`
+   * attached will lead to Promise rejection, as well as calling
+   * `attachMediaSource` despite having no current content prepared.
+   * @param {Function} sendMessage
+   * @returns {Promise}
+   */
+  public attachMediaSource(
+    sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
+  ): Promise<unknown> {
+    const currentContent = this._currentContent;
+    if (currentContent === null) {
+      log.error("Core", "Attaching MediaSource despite having no content. Aborting...");
+      return Promise.reject(new Error("Cannot Attach MediaSource: No content pending"));
+    }
+    if (currentContent.mediaSource !== null) {
+      log.error("Core", "Attaching MediaSource despite already having one. Aborting...");
+      return Promise.reject(new Error("Cannot Attach MediaSource: Already have one"));
+    }
+    const currentMediaSourceCanceller = this._currentMediaSourceCanceller;
+    const mediaSourceInterface = createMediaSourceInterface(
+      sendMessage,
+      currentContent.contentId,
+      currentContent.mseInWorker,
+      this._currentMediaSourceCanceller.signal,
+    );
+    currentContent.mediaSource = mediaSourceInterface;
+
+    return new Promise((res, rej) => {
+      currentMediaSourceCanceller.signal.register(onCancellation);
+      const onMediaSourceOpen = () => {
+        mediaSourceInterface.removeEventListener("mediaSourceOpen", onMediaSourceOpen);
+        currentMediaSourceCanceller.signal.deregister(onCancellation);
+        if (currentMediaSourceCanceller.signal.isCancelled()) {
+          return;
+        }
+        currentContent.segmentSinksStore
+          .attachOpenedMediaSource(mediaSourceInterface)
+          .then(res, rej);
+      };
+
+      if (mediaSourceInterface.readyState === "open") {
+        onMediaSourceOpen();
+      } else {
+        mediaSourceInterface.addEventListener(
+          "mediaSourceOpen",
+          onMediaSourceOpen,
+          currentMediaSourceCanceller.signal,
+        );
+      }
+      function onCancellation(err: CancellationError) {
+        mediaSourceInterface.removeEventListener("mediaSourceOpen", onMediaSourceOpen);
+        rej(err);
+      }
+    });
+  }
+
   /**
    * Schedule an update for the Manifest file,
    *
@@ -317,50 +364,72 @@ export default class ContentPreparer {
    */
   public reloadMediaSource(
     sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
-  ): Promise<void> {
-    this._currentMediaSourceCanceller.cancel("ContentPreparer MediaSource reload");
-    if (this._currentContent === null) {
+  ): Promise<unknown> {
+    const currentContent = this._currentContent;
+    if (currentContent === null) {
       return Promise.reject(new Error("CP: No content anymore"));
     }
-    this._currentContent.trackChoiceSetter.reset();
-    this._currentContent.coreTextSender?.stop("ContentPreparer MediaSource reload");
-    this._currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
-    this._currentMediaSourceCanceller.linkToSignal(this._contentCanceller.signal);
+    if (currentContent.mediaSource === null) {
+      // No media source: Just empty initialized SegmentSinks
+      const proms: Array<Promise<unknown>> = [];
+      currentContent.segmentSinksStore.getBufferTypes().forEach((bufferType) => {
+        const sinkStatus = currentContent.segmentSinksStore.getStatus(bufferType);
+        if (sinkStatus.type === "initialized") {
+          proms.push(sinkStatus.value.removeBuffer(0, Infinity));
+        }
+      });
+      return Promise.all(proms);
+    } else {
+      // With a `MediaSource`: Re-create the `MediaSource` and associated
+      // `SegmentSinksStore`
+      this._currentMediaSourceCanceller.cancel("Reloading MediaSource");
+      currentContent.trackChoiceSetter.reset();
+      currentContent.coreTextSender?.stop("ContentPreparer MediaSource reload");
+      this._currentMediaSourceCanceller = new TaskCanceller(
+        "ContentPreparer MediaSource",
+      );
+      this._currentMediaSourceCanceller.linkToSignal(this._contentCanceller.signal);
 
-    const [mediaSourceInterface, segmentSinksStore, coreTextSender] =
-      createMediaSourceInterfaceAndSegmentSinksStore(
+      const [segmentSinksStore, coreTextSender] = createSegmentSinksStore(
         sendMessage,
-        this._currentContent.contentId,
+        currentContent.contentId,
         {
-          mseInWorker: this._currentContent.mseInWorker,
-          videoTrack: this._currentContent.videoTrack,
-          textTrack: this._currentContent.textTrack,
-        },
-        this._currentMediaSourceCanceller.signal,
-      );
-    this._currentContent.mediaSource = mediaSourceInterface;
-    this._currentContent.segmentSinksStore = segmentSinksStore;
-    this._currentContent.freezeResolver = new FreezeResolver(segmentSinksStore);
-    this._currentContent.coreTextSender = coreTextSender;
-    return new Promise((res, rej) => {
-      mediaSourceInterface.addEventListener(
-        "mediaSourceOpen",
-        function () {
-          res();
+          videoTrack: currentContent.videoTrack,
+          textTrack: currentContent.textTrack,
         },
         this._currentMediaSourceCanceller.signal,
       );
-      mediaSourceInterface.addEventListener(
-        "mediaSourceClose",
-        function () {
-          rej(new Error("MediaSource ReadyState changed to close during init."));
-        },
+
+      const mediaSourceInterface = createMediaSourceInterface(
+        sendMessage,
+        currentContent.contentId,
+        currentContent.mseInWorker,
         this._currentMediaSourceCanceller.signal,
       );
-      this._currentMediaSourceCanceller.signal.register((error) => {
-        rej(error);
+      currentContent.mediaSource = mediaSourceInterface;
+      currentContent.segmentSinksStore = segmentSinksStore;
+      currentContent.freezeResolver = new FreezeResolver(segmentSinksStore);
+      currentContent.coreTextSender = coreTextSender;
+      return new Promise((res, rej) => {
+        mediaSourceInterface.addEventListener(
+          "mediaSourceOpen",
+          function () {
+            res(undefined);
+          },
+          this._currentMediaSourceCanceller.signal,
+        );
+        mediaSourceInterface.addEventListener(
+          "mediaSourceClose",
+          function () {
+            rej(new Error("MediaSource ReadyState changed to close during init."));
+          },
+          this._currentMediaSourceCanceller.signal,
+        );
+        this._currentMediaSourceCanceller.signal.register((error) => {
+          rej(error);
+        });
       });
-    });
+    }
   }
 
   /**
@@ -402,7 +471,7 @@ export interface IPreparedContentData {
    * Interface to the MediaSource implementation, allowing to buffer audio
    * and video media segments.
    */
-  mediaSource: IMediaSourceInterface;
+  mediaSource: IMediaSourceInterface | null;
   /** Class abstracting Manifest fetching and refreshing. */
   manifestFetcher: ManifestFetcher;
   /**
@@ -460,25 +529,18 @@ export interface IPreparedContentData {
 /**
  * @param {Function} sendMessage
  * @param {string} contentId
- * @param {Object} playbackSupport
- * @param {boolean} playbackSupport.mseInWorker
- * @param {boolean} playbackSupport.videoTrack
- * @param {boolean} playbackSupport.textTrack
+ * @param {boolean} mseInWorker
  * @param {Object} cancelSignal
- * @returns {Array.<Object>}
+ * @returns {Object}
  */
-function createMediaSourceInterfaceAndSegmentSinksStore(
+function createMediaSourceInterface(
   sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   contentId: string,
-  playbackSupport: {
-    mseInWorker: boolean;
-    videoTrack: boolean;
-    textTrack: boolean;
-  },
+  mseInWorker: boolean,
   cancelSignal: CancellationSignal,
-): [IMediaSourceInterface, SegmentSinksStore, CoreTextDisplayerInterface | null] {
+): IMediaSourceInterface {
   let mediaSourceInterface: IMediaSourceInterface;
-  if (playbackSupport.mseInWorker) {
+  if (mseInWorker) {
     if (BROWSER_GLOBALS.MediaSource_ === undefined) {
       throw new Error("ContentPreparer: Cannot use MSE-in-Worker: no MSE");
     }
@@ -517,21 +579,38 @@ function createMediaSourceInterfaceAndSegmentSinksStore(
       sendMessage,
     );
   }
+  cancelSignal.register((err) => {
+    mediaSourceInterface.dispose(err.reason);
+  });
+  return mediaSourceInterface;
+}
 
+/**
+ * @param {string} contentId
+ * @param {Object} playbackSupport
+ * @param {boolean} playbackSupport.videoTrack
+ * @param {boolean} playbackSupport.textTrack
+ * @param {Object} cancelSignal
+ * @returns {Array.<Object>}
+ */
+function createSegmentSinksStore(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
+  contentId: string,
+  playbackSupport: {
+    videoTrack: boolean;
+    textTrack: boolean;
+  },
+  cancelSignal: CancellationSignal,
+): [SegmentSinksStore, CoreTextDisplayerInterface | null] {
   const textSender = playbackSupport.textTrack
     ? new CoreTextDisplayerInterface(contentId, sendMessage)
     : null;
   const { videoTrack } = playbackSupport;
-  const segmentSinksStore = new SegmentSinksStore(
-    mediaSourceInterface,
-    videoTrack,
-    textSender,
-  );
+  const segmentSinksStore = new SegmentSinksStore(null, videoTrack, textSender);
   cancelSignal.register((err) => {
     segmentSinksStore.disposeAll(err.reason);
     textSender?.stop(err.reason);
-    mediaSourceInterface.dispose(err.reason);
   });
 
-  return [mediaSourceInterface, segmentSinksStore, textSender];
+  return [segmentSinksStore, textSender];
 }
diff --git a/src/core/entry/core_entry.ts b/src/core/entry/core_entry.ts
index f8a18012fb..4eb9abb121 100644
--- a/src/core/entry/core_entry.ts
+++ b/src/core/entry/core_entry.ts
@@ -230,7 +230,7 @@ export default function initializeCoreEntry(
       case MainThreadMessageType.MediaSourceReload:
         {
           const preparedContent = contentPreparer.getCurrentContent();
-          if (msg.mediaSourceId !== preparedContent?.mediaSource.id) {
+          if (msg.mediaSourceId !== preparedContent?.mediaSource?.id) {
             return;
           }
           currentContentHandle?.signalMediaSourceReload();
@@ -239,7 +239,7 @@ export default function initializeCoreEntry(
 
       case MainThreadMessageType.SourceBufferSuccess: {
         const preparedContent = contentPreparer.getCurrentContent();
-        if (msg.mediaSourceId !== preparedContent?.mediaSource.id) {
+        if (msg.mediaSourceId !== preparedContent?.mediaSource?.id) {
           return;
         }
         const { sourceBuffers } = preparedContent.mediaSource;
@@ -267,7 +267,7 @@ export default function initializeCoreEntry(
 
       case MainThreadMessageType.SourceBufferError: {
         const preparedContent = contentPreparer.getCurrentContent();
-        if (msg.mediaSourceId !== preparedContent?.mediaSource.id) {
+        if (msg.mediaSourceId !== preparedContent?.mediaSource?.id) {
           return;
         }
         const { sourceBuffers } = preparedContent.mediaSource;
@@ -297,7 +297,7 @@ export default function initializeCoreEntry(
 
       case MainThreadMessageType.MediaSourceReadyStateChange: {
         const preparedContent = contentPreparer.getCurrentContent();
-        if (msg.mediaSourceId !== preparedContent?.mediaSource.id) {
+        if (msg.mediaSourceId !== preparedContent?.mediaSource?.id) {
           return;
         }
         if (preparedContent.mediaSource.onMediaSourceReadyStateChanged === undefined) {
@@ -462,6 +462,21 @@ export default function initializeCoreEntry(
         break;
       }
 
+      case MainThreadMessageType.MediaElementReady: {
+        const preparedContent = contentPreparer.getCurrentContent();
+        if (msg.contentId !== preparedContent?.contentId) {
+          return;
+        }
+        contentPreparer.attachMediaSource(sendMessage).catch((err) => {
+          sendMessage({
+            type: CoreMessageType.Error,
+            contentId: preparedContent.contentId,
+            value: formatErrorForSender(err),
+          });
+        });
+        break;
+      }
+
       case MainThreadMessageType.AppDefined: {
         break;
       }
@@ -633,7 +648,6 @@ function loadPreparedContent(
       cmcdDataBuilder,
       enableRepresentationAvoidance,
       manifest,
-      mediaSource,
       representationEstimator,
       segmentSinksStore,
       segmentQueueCreator,
@@ -685,7 +699,6 @@ function loadPreparedContent(
 
     const contentTimeBoundariesObserver = createContentTimeBoundariesObserver(
       manifest,
-      mediaSource,
       playbackObserver,
       segmentSinksStore,
       {
@@ -1000,7 +1013,7 @@ function loadPreparedContent(
       currentLoadCanceller.cancel("WorkerMain MediaSource reload");
       currentLoadCanceller = null;
     }
-    const mediaSourceId = contentPreparer.getCurrentContent()?.mediaSource.id;
+    const mediaSourceId = contentPreparer.getCurrentContent()?.mediaSource?.id;
     if (mediaSourceId === undefined) {
       log.warn("Core", "Cannot reload MediaSource: no MediaSource currently.");
       return;
diff --git a/src/core/entry/create_content_time_boundaries_observer.ts b/src/core/entry/create_content_time_boundaries_observer.ts
index 140abc1423..e2e08b136a 100644
--- a/src/core/entry/create_content_time_boundaries_observer.ts
+++ b/src/core/entry/create_content_time_boundaries_observer.ts
@@ -7,8 +7,10 @@ import type { IManifest, IPeriod } from "../../manifest/index.ts";
 import type { IMediaSourceInterface } from "../../mse/index.ts";
 import type { IReadOnlyPlaybackObserver } from "../../playback_observer/index.ts";
 import type { IPlayerError } from "../../public_types.ts";
+import noop from "../../utils/noop.ts";
 import type { CancellationSignal } from "../../utils/task_canceller.ts";
 import ContentTimeBoundariesObserver from "./content_time_boundaries_observer.ts";
+import type { IEndingPositionInformation } from "./content_time_boundaries_observer.ts";
 
 export interface IContentTimeBoundariesObserverCallbacks {
   onWarning: (evt: IPlayerError) => void;
@@ -24,7 +26,6 @@ export interface IContentTimeBoundariesObserverCallbacks {
  * Various methods from that class need then to be called at various events
  * (see `ContentTimeBoundariesObserver`).
  * @param {Object} manifest
- * @param {Object} mediaSource
  * @param {Object} streamObserver
  * @param {Object} segmentSinksStore
  * @param {Object} cancelSignal
@@ -32,20 +33,39 @@ export interface IContentTimeBoundariesObserverCallbacks {
  */
 export default function createContentTimeBoundariesObserver(
   manifest: IManifest,
-  mediaSource: IMediaSourceInterface,
   streamObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>,
   segmentSinksStore: ISegmentSinksStore,
   callbacks: IContentTimeBoundariesObserverCallbacks,
   cancelSignal: CancellationSignal,
 ): ContentTimeBoundariesObserver {
-  cancelSignal.register((err) => {
-    mediaSource.interruptDurationSetting(err.reason);
-  });
   const contentTimeBoundariesObserver = new ContentTimeBoundariesObserver(
     manifest,
     streamObserver,
     segmentSinksStore.getBufferTypes(),
   );
+  let mediaSource: IMediaSourceInterface | null = null;
+  let lastEndingPositionInformation: IEndingPositionInformation =
+    contentTimeBoundariesObserver.getCurrentEndingTime();
+  let isEndOfStream = false;
+  segmentSinksStore
+    .getMediaSourceInterface(cancelSignal)
+    .then((msi) => {
+      mediaSource = msi;
+      if (isEndOfStream) {
+        log.debug("Init", "end-of-stream order received.");
+        mediaSource.maintainEndOfStream();
+      }
+      mediaSource.setDuration(
+        lastEndingPositionInformation.endingPosition,
+        lastEndingPositionInformation.isEnd,
+      );
+    })
+    .catch(noop);
+  cancelSignal.register((err) => {
+    if (mediaSource !== null) {
+      mediaSource.interruptDurationSetting(err.reason);
+    }
+  });
   cancelSignal.register((err) => {
     contentTimeBoundariesObserver.dispose(err.reason);
   });
@@ -56,16 +76,23 @@ export default function createContentTimeBoundariesObserver(
     callbacks.onPeriodChanged(period),
   );
   contentTimeBoundariesObserver.addEventListener("endingPositionChange", (evt) => {
-    mediaSource.setDuration(evt.endingPosition, evt.isEnd);
+    lastEndingPositionInformation = evt;
+    if (mediaSource !== null) {
+      mediaSource.setDuration(evt.endingPosition, evt.isEnd);
+    }
   });
   contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
-    log.debug("mse", "Start applying end-of-stream order.");
-    mediaSource.maintainEndOfStream();
+    isEndOfStream = true;
+    if (mediaSource !== null) {
+      log.debug("mse", "Start applying end-of-stream order.");
+      mediaSource.maintainEndOfStream();
+    }
   });
   contentTimeBoundariesObserver.addEventListener("resumeStream", () => {
-    mediaSource.stopEndOfStream();
+    isEndOfStream = false;
+    if (mediaSource !== null) {
+      mediaSource.stopEndOfStream();
+    }
   });
-  const obj = contentTimeBoundariesObserver.getCurrentEndingTime();
-  mediaSource.setDuration(obj.endingPosition, obj.isEnd);
   return contentTimeBoundariesObserver;
 }
diff --git a/src/core/segment_sinks/implementations/audio_video/audio_video_segment_sink.ts b/src/core/segment_sinks/implementations/audio_video/audio_video_segment_sink.ts
index a71df56ca4..051846ba65 100644
--- a/src/core/segment_sinks/implementations/audio_video/audio_video_segment_sink.ts
+++ b/src/core/segment_sinks/implementations/audio_video/audio_video_segment_sink.ts
@@ -21,13 +21,17 @@ import type {
   ISourceBufferInterface,
   SourceBufferType,
 } from "../../../../mse/index.ts";
+import assert from "../../../../utils/assert.ts";
 import getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp.ts";
 import type { IRange } from "../../../../utils/ranges.ts";
 import type {
   ICompleteSegmentInfo,
   IPushChunkInfos,
   IPushedChunkData,
+  IPushOperation,
+  IRemoveOperation,
   ISBOperation,
+  ISignalCompleteSegmentOperation,
 } from "../types.ts";
 import { SegmentSink, SegmentSinkOperation } from "../types.ts";
 
@@ -42,13 +46,46 @@ import { SegmentSink, SegmentSinkOperation } from "../types.ts";
  */
 export default class AudioVideoSegmentSink extends SegmentSink {
   /** "Type" of the buffer concerned. */
-  public readonly bufferType: "audio" | "video";
+  public readonly bufferType: SourceBufferType;
 
-  /** SourceBuffer implementation. */
-  private readonly _sourceBuffer: ISourceBufferInterface;
+  /**
+   * `SourceBuffer` implementation.
+   *
+   * `null` if the `SourceBuffer` is not yet linked to this SegmentSink, in
+   * which cases operations (push, remove etc.) are left pending and stored
+   * in `_inMemoryBuffer`.
+   */
+  private _sourceBuffer: ISourceBufferInterface | null;
 
   /**
-   * Queue of awaited buffer "operations".
+   * Queues of operations that have not yet been performed on a `SourceBuffer`
+   * because it was not available yet.
+   *
+   * Once `_sourceBuffer` is set, those operations should all be executed and
+   * this property shouldn't be relied on anymore.
+   */
+  private _inMemoryBuffer: {
+    freeInitSegments: string[];
+    operationQueue: Array<
+      | (IPushOperation<unknown> & {
+          resolve: (range: IRange[] | undefined) => void;
+          reject: (err: unknown) => void;
+        })
+      | (IRemoveOperation & {
+          resolve: (range: IRange[] | undefined) => void;
+          reject: (err: unknown) => void;
+        })
+      | (ISignalCompleteSegmentOperation & {
+          resolve: () => void;
+          reject: (err: unknown) => void;
+        })
+    >;
+  };
+
+  /**
+   * Queue of awaited buffer "operations" that have been called on the
+   * `SourceBuffer` but have not yet finished.
+   *
    * The first element in this array will be the first performed.
    */
   private _pendingOperations: Array<{
@@ -78,29 +115,80 @@ export default class AudioVideoSegmentSink extends SegmentSink {
    */
   private _initSegmentsMap: Map<string, BufferSource>;
 
+  /**
+   * Mimetype+codec combination the SegmentSink is currently working with.
+   * Depending on the implementation, segments with a different codecs could be
+   * incompatible.
+   *
+   * `undefined` if unknown and if this property does not matter for this
+   * SegmentSink implementation.
+   */
+  public codec: string;
+
   /**
    * @constructor
    * @param {string} bufferType
    * @param {string} codec
-   * @param {Object} mediaSource
    */
-  constructor(
-    bufferType: SourceBufferType,
-    codec: string,
-    mediaSource: IMediaSourceInterface,
-  ) {
+  constructor(bufferType: SourceBufferType, codec: string) {
     super();
     log.info("Stream", "calling `mediaSource.addSourceBuffer`", { codec });
-    const sourceBuffer = mediaSource.addSourceBuffer(bufferType, codec);
 
     this.bufferType = bufferType;
-    this._sourceBuffer = sourceBuffer;
+    this._sourceBuffer = null;
+    this._inMemoryBuffer = {
+      freeInitSegments: [],
+      operationQueue: [],
+    };
     this._lastInitSegmentUniqueId = null;
     this.codec = codec;
     this._initSegmentsMap = new Map();
     this._pendingOperations = [];
   }
 
+  public linkToMediaSource(
+    mediaSourceInterface: IMediaSourceInterface,
+  ): Promise<unknown> {
+    log.info("Stream", "Linking MediaSource to SegmentSink", {
+      bufferType: this.bufferType,
+    });
+    const sourceBuffer = mediaSourceInterface.addSourceBuffer(
+      this.bufferType,
+      this.codec,
+    );
+    this._sourceBuffer = sourceBuffer;
+    const proms: Array<Promise<unknown>> = [];
+    const { freeInitSegments, operationQueue } = this._inMemoryBuffer;
+    this._inMemoryBuffer = {
+      freeInitSegments: [],
+      operationQueue: [],
+    };
+    for (const item of operationQueue) {
+      switch (item.type) {
+        case SegmentSinkOperation.Push:
+          proms.push(this.pushChunk(item.value).then(item.resolve, item.reject));
+          break;
+        case SegmentSinkOperation.Remove:
+          proms.push(
+            this.removeBuffer(item.value.start, item.value.end).then(
+              item.resolve,
+              item.reject,
+            ),
+          );
+          break;
+        case SegmentSinkOperation.SignalSegmentComplete:
+          proms.push(
+            this.signalSegmentComplete(item.value).then(item.resolve, item.reject),
+          );
+          break;
+      }
+    }
+    for (const initSegId of freeInitSegments) {
+      this.freeInitSegment(initSegId);
+    }
+    return Promise.all(proms);
+  }
+
   /** @see SegmentSink */
   public declareInitSegment(uniqueId: string, initSegmentData: unknown): void {
     assertDataIsBufferSource(initSegmentData);
@@ -109,7 +197,11 @@ export default class AudioVideoSegmentSink extends SegmentSink {
 
   /** @see SegmentSink */
   public freeInitSegment(uniqueId: string): void {
-    this._initSegmentsMap.delete(uniqueId);
+    if (this._sourceBuffer === null) {
+      this._inMemoryBuffer.freeInitSegments.push(uniqueId);
+    } else {
+      this._initSegmentsMap.delete(uniqueId);
+    }
   }
 
   /**
@@ -137,9 +229,24 @@ export default class AudioVideoSegmentSink extends SegmentSink {
    * @param {Object} infos
    * @returns {Promise}
    */
-  public async pushChunk(infos: IPushChunkInfos<unknown>): Promise<IRange[]> {
+  public async pushChunk(infos: IPushChunkInfos<unknown>): Promise<IRange[] | undefined> {
     assertDataIsBufferSource(infos.data.chunk);
     log.debug("Stream", "queuing push order", getLoggableSegmentId(infos.inventoryInfos));
+
+    const sourceBuffer = this._sourceBuffer;
+    if (sourceBuffer === null) {
+      log.debug("Stream", "No SourceBuffer yet, pushing in-memory");
+      // XXX TODO: replace already buffered + range
+      return new Promise((resolve, reject) => {
+        this._inMemoryBuffer.operationQueue.push({
+          type: SegmentSinkOperation.Push,
+          value: infos,
+          resolve,
+          reject,
+        });
+      });
+    }
+
     const dataToPush = this._getActualDataToPush(
       infos.data as IPushedChunkData<BufferSource>,
     );
@@ -167,7 +274,7 @@ export default class AudioVideoSegmentSink extends SegmentSink {
       dataToPush.map((data) => {
         const { codec, timestampOffset, appendWindow } = infos.data;
         log.debug("Stream", "now pushing", getLoggableSegmentId(infos.inventoryInfos));
-        return this._sourceBuffer.appendBuffer(data, {
+        return sourceBuffer.appendBuffer(data, {
           codec,
           timestampOffset,
           appendWindow,
@@ -197,24 +304,42 @@ export default class AudioVideoSegmentSink extends SegmentSink {
       );
     }
     const ranges = res[res.length - 1];
-    this._segmentInventory.synchronizeBuffered(ranges);
+    if (ranges !== undefined) {
+      this._segmentInventory.synchronizeBuffered(ranges);
+    }
     return ranges;
   }
 
   /** @see SegmentSink */
-  public async removeBuffer(start: number, end: number): Promise<IRange[]> {
+  public async removeBuffer(start: number, end: number): Promise<IRange[] | undefined> {
     log.debug("Stream", "queuing remove order", {
       bufferType: this.bufferType,
       start,
       end,
     });
+
+    if (this._sourceBuffer === null) {
+      log.debug("Stream", "No SourceBuffer yet, removing in-memory");
+      // XXX TODO: evict+range?
+      return new Promise((resolve, reject) => {
+        this._inMemoryBuffer.operationQueue.push({
+          type: SegmentSinkOperation.Remove,
+          value: { start, end },
+          resolve,
+          reject,
+        });
+      });
+    }
+
     const promise = this._sourceBuffer.remove(start, end);
     this._addToOperationQueue(promise, {
       type: SegmentSinkOperation.Remove,
       value: { start, end },
     });
     const ranges = await promise;
-    this._segmentInventory.synchronizeBuffered(ranges);
+    if (ranges !== undefined) {
+      this._segmentInventory.synchronizeBuffered(ranges);
+    }
     return ranges;
   }
 
@@ -228,6 +353,17 @@ export default class AudioVideoSegmentSink extends SegmentSink {
    * @returns {Promise}
    */
   public async signalSegmentComplete(infos: ICompleteSegmentInfo): Promise<void> {
+    if (this._sourceBuffer === null) {
+      return new Promise((resolve, reject) => {
+        this._inMemoryBuffer.operationQueue.push({
+          type: SegmentSinkOperation.SignalSegmentComplete,
+          value: infos,
+          resolve,
+          reject,
+        });
+      });
+    }
+
     if (this._pendingOperations.length > 0) {
       // Only validate after preceding operation
       const { promise } = this._pendingOperations[this._pendingOperations.length - 1];
@@ -250,6 +386,14 @@ export default class AudioVideoSegmentSink extends SegmentSink {
    * @returns {Array.<Object>}
    */
   public getPendingOperations(): Array<ISBOperation<unknown>> {
+    if (this._inMemoryBuffer.operationQueue.length > 0) {
+      assert(this._pendingOperations.length === 0);
+      return this._inMemoryBuffer.operationQueue.map((p) => ({
+        ...p,
+        resolve: undefined,
+        reject: undefined,
+      }));
+    }
     return this._pendingOperations.map((p) => p.operation);
   }
 
@@ -257,7 +401,7 @@ export default class AudioVideoSegmentSink extends SegmentSink {
   public dispose(reason: string | undefined): void {
     try {
       log.debug("Stream", "Calling `dispose` on the SourceBufferInterface");
-      this._sourceBuffer.dispose(reason);
+      this._sourceBuffer?.dispose(reason);
     } catch (e) {
       log.debug(
         "Stream",
diff --git a/src/core/segment_sinks/implementations/types.ts b/src/core/segment_sinks/implementations/types.ts
index 5a4b814d64..201cea9176 100644
--- a/src/core/segment_sinks/implementations/types.ts
+++ b/src/core/segment_sinks/implementations/types.ts
@@ -119,7 +119,9 @@ export abstract class SegmentSink {
    * @param {Object} infos
    * @returns {Promise}
    */
-  public abstract pushChunk(infos: IPushChunkInfos<unknown>): Promise<IRange[]>;
+  public abstract pushChunk(
+    infos: IPushChunkInfos<unknown>,
+  ): Promise<IRange[] | undefined>;
 
   /**
    * Remove buffered data.
diff --git a/src/core/segment_sinks/segment_sinks_store.ts b/src/core/segment_sinks/segment_sinks_store.ts
index a76061bd88..c1d8fc64c4 100644
--- a/src/core/segment_sinks/segment_sinks_store.ts
+++ b/src/core/segment_sinks/segment_sinks_store.ts
@@ -96,7 +96,7 @@ export default class SegmentSinksStore {
   }
 
   /** MediaSource on which SourceBuffer objects will be attached. */
-  private readonly _mediaSource: IMediaSourceInterface;
+  private _mediaSource: IMediaSourceInterface | null;
 
   /**
    * List of initialized and explicitely disabled SegmentSinks.
@@ -117,6 +117,12 @@ export default class SegmentSinksStore {
    */
   private _onNativeBufferAddedOrDisabled: Array<() => void>;
 
+  /**
+   * Callbacks called after a `MediaSource` is attached to this
+   * `SegmentSinksStore`.
+   */
+  private _onMediaSourceAttached: Array<(msi: IMediaSourceInterface) => void>;
+
   private _textInterface: ITextDisplayerInterface | null;
 
   private _hasVideo: boolean;
@@ -126,7 +132,7 @@ export default class SegmentSinksStore {
    * @constructor
    */
   constructor(
-    mediaSource: IMediaSourceInterface,
+    mediaSource: IMediaSourceInterface | null,
     hasVideo: boolean,
     textDisplayerInterface: ITextDisplayerInterface | null,
   ) {
@@ -135,6 +141,30 @@ export default class SegmentSinksStore {
     this._hasVideo = hasVideo;
     this._initializedSegmentSinks = {};
     this._onNativeBufferAddedOrDisabled = [];
+    this._onMediaSourceAttached = [];
+  }
+
+  public attachOpenedMediaSource(mediaSource: IMediaSourceInterface): Promise<unknown> {
+    if (this._mediaSource !== null) {
+      return Promise.reject(
+        new Error("mediaSourceInterface already attached to SegmentSinksStore"),
+      );
+    }
+    log.info("Stream", "Attaching opened MediaSource");
+    this._mediaSource = mediaSource;
+
+    const proms: Array<Promise<unknown>> = [];
+    if (!isNullOrUndefined(this._initializedSegmentSinks.video)) {
+      proms.push(this._initializedSegmentSinks.video.linkToMediaSource(mediaSource));
+    }
+    if (!isNullOrUndefined(this._initializedSegmentSinks.audio)) {
+      proms.push(this._initializedSegmentSinks.audio.linkToMediaSource(mediaSource));
+    }
+    this._onMediaSourceAttached.forEach((cb) => {
+      cb(mediaSource);
+    });
+    this._onMediaSourceAttached.length = 0;
+    return Promise.all(proms);
   }
 
   /**
@@ -239,6 +269,34 @@ export default class SegmentSinksStore {
     });
   }
 
+  /**
+   * Get the `MediaSourceInterface` linked to that `SegmentSinksStore`.
+   *
+   * Note that, as a `SegmentSinksStore` might not be linked to a
+   * `MediaSourceInterface` yet, this method returns a Promise, which will
+   * resolve once the `MediaSourceInterface` is attached to this instance.
+   * @param {Object} cancelWaitSignal
+   * @return {Promise}
+   */
+  public getMediaSourceInterface(
+    cancelWaitSignal: CancellationSignal,
+  ): Promise<IMediaSourceInterface> {
+    if (this._mediaSource !== null) {
+      return Promise.resolve(this._mediaSource);
+    }
+
+    return createCancellablePromise(cancelWaitSignal, (res) => {
+      const removeCallback = () => {
+        const indexOf = this._onMediaSourceAttached.indexOf(res);
+        if (indexOf >= 0) {
+          this._onMediaSourceAttached.splice(indexOf, 1);
+        }
+      };
+      this._onMediaSourceAttached.push(res);
+      return removeCallback;
+    });
+  }
+
   /**
    * Explicitely disable the SegmentSink for a given buffer type.
    * A call to this function is needed at least for unused native buffer types
@@ -294,15 +352,20 @@ export default class SegmentSinksStore {
         }
         return memorizedSegmentSink;
       }
-      log.info("Stream", "Adding native SegmentSink with codec", codec);
+      log.info("Stream", "Adding native SegmentSink", { codec, bufferType });
       const sourceBufferType =
         bufferType === "audio" ? SourceBufferType.Audio : SourceBufferType.Video;
-      const nativeSegmentSink = new AudioVideoSegmentSink(
-        sourceBufferType,
-        codec,
-        this._mediaSource,
-      );
+      const nativeSegmentSink = new AudioVideoSegmentSink(sourceBufferType, codec);
       this._initializedSegmentSinks[bufferType] = nativeSegmentSink;
+      if (this._mediaSource !== null) {
+        nativeSegmentSink.linkToMediaSource(this._mediaSource).catch((err) => {
+          log.error(
+            "Stream",
+            "Failed to link AudioVideoSegmentSink to MediaSource",
+            err instanceof Error ? err : "Unknown Error",
+          );
+        });
+      }
       this._onNativeBufferAddedOrDisabled.slice().forEach((cb) => cb());
       assert(this._onNativeBufferAddedOrDisabled.length === 0);
       return nativeSegmentSink;
@@ -313,15 +376,15 @@ export default class SegmentSinksStore {
       return memorizedSegmentSink;
     }
 
-    let segmentSink: TextSegmentSink;
+    let textSegmentSink: TextSegmentSink;
     if (bufferType === "text") {
       log.info("Stream", "Creating a new text SegmentSink");
       if (this._textInterface === null) {
         throw new Error("HTML Text track feature not activated");
       }
-      segmentSink = new TextSegmentSink(this._textInterface);
-      this._initializedSegmentSinks.text = segmentSink;
-      return segmentSink;
+      textSegmentSink = new TextSegmentSink(this._textInterface);
+      this._initializedSegmentSinks.text = textSegmentSink;
+      return textSegmentSink;
     }
 
     log.error("Stream", "Unknown buffer type:", { bufferType });
diff --git a/src/core/stream/adaptation/adaptation_stream.ts b/src/core/stream/adaptation/adaptation_stream.ts
index d4a208d57e..1c3704ba8e 100644
--- a/src/core/stream/adaptation/adaptation_stream.ts
+++ b/src/core/stream/adaptation/adaptation_stream.ts
@@ -380,7 +380,12 @@ export default function AdaptationStream(
         callbacks.error(err);
       },
       addedSegment(segmentInfo) {
-        abrCallbacks.addedSegment(segmentInfo);
+        if (segmentInfo.buffered !== undefined) {
+          abrCallbacks.addedSegment({
+            buffered: segmentInfo.buffered,
+            content: segmentInfo.content,
+          });
+        }
       },
       terminating() {
         if (repStreamTerminatingCanceller.isUsed()) {
diff --git a/src/core/stream/representation/representation_stream.ts b/src/core/stream/representation/representation_stream.ts
index 67105e7520..c982db3781 100644
--- a/src/core/stream/representation/representation_stream.ts
+++ b/src/core/stream/representation/representation_stream.ts
@@ -443,7 +443,7 @@ export default function RepresentationStream<TSegmentDataType>(
       // We can thus ignore it, it is very unlikely to lead to true buffer issues.
       return;
     }
-    log.warn(
+    log.error(
       "Stream",
       "Received fatal buffer error",
       {
diff --git a/src/core/stream/representation/types.ts b/src/core/stream/representation/types.ts
index 15c9f1322f..ad5ad66629 100644
--- a/src/core/stream/representation/types.ts
+++ b/src/core/stream/representation/types.ts
@@ -139,7 +139,7 @@ export interface IStreamEventAddedSegmentPayload {
   /** The concerned Segment. */
   segment: ISegment;
   /** Ranges of the concerned SegmentSink after the segment was pushed. */
-  buffered: IRange[];
+  buffered: IRange[] | undefined;
 }
 
 /** Structure describing an "inband" event, as found in a media segment. */
diff --git a/src/core/stream/representation/utils/append_segment_to_buffer.ts b/src/core/stream/representation/utils/append_segment_to_buffer.ts
index 35654002fd..248d44e0e0 100644
--- a/src/core/stream/representation/utils/append_segment_to_buffer.ts
+++ b/src/core/stream/representation/utils/append_segment_to_buffer.ts
@@ -51,7 +51,7 @@ export default async function appendSegmentToBuffer<T>(
   dataInfos: IPushChunkInfos<T> & { inventoryInfos: IInsertedChunkInfos },
   bufferGoal: IReadOnlySharedReference<number>,
   cancellationSignal: CancellationSignal,
-): Promise<IRange[]> {
+): Promise<IRange[] | undefined> {
   try {
     return await segmentSink.pushChunk(dataInfos);
   } catch (appendError: unknown) {
diff --git a/src/main_thread/api/public_api.ts b/src/main_thread/api/public_api.ts
index 23fd021a9c..80e6f85955 100644
--- a/src/main_thread/api/public_api.ts
+++ b/src/main_thread/api/public_api.ts
@@ -68,7 +68,10 @@ import {
   toVideoRepresentation,
   toAudioRepresentation,
 } from "../../manifest/index.ts";
-import type { IPlaybackObservation } from "../../playback_observer/index.ts";
+import type {
+  IMediaElementPlaybackObserver,
+  IPlaybackObservation,
+} from "../../playback_observer/index.ts";
 import MediaElementPlaybackObserver from "../../playback_observer/media_element_playback_observer.ts";
 import type {
   IAudioRepresentation,
@@ -266,6 +269,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     lastBitrates: { audio?: number; video?: number; text?: number };
   };
 
+  /**
+   * XXX TODO: per-content + defaultWorker?
+   */
   private _priv_workerData: {
     worker: Worker;
     messageListeners: Map<string, Array<(payload: unknown) => void>>;
@@ -274,6 +280,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
   /**
    * Current fatal error which STOPPED the player.
    * `null` if no fatal error was received for the current or last content.
+   * XXX TODO: per-content?
    */
   private _priv_currentError: Error | null;
 
@@ -283,7 +290,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    */
   private _priv_contentInfos: IPublicApiContentInfos | null;
 
+  private _priv_currentPreloads: Map<string, IPublicApiContentInfos>;
+
   /** If `true` trickMode video tracks will be chosen if available. */
+  // XXX TODO: per-content?
   private _priv_preferTrickModeTracks: boolean;
 
   /** Refer to last picture in picture event received. */
@@ -295,20 +305,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
   /** Store wanted configuration for the `throttleVideoBitrateWhenHidden` option. */
   private readonly _priv_throttleVideoBitrateWhenHidden: boolean;
 
-  /**
-   * Store last state of various values sent as events, to avoid re-triggering
-   * them multiple times in a row.
-   *
-   * All those events are linked to the content being played and can be cleaned
-   * on stop.
-   */
-  private _priv_contentEventsMemory: {
-    [P in keyof IPublicAPIEvent]?: IPublicAPIEvent[P];
-  };
-
   /**
    * Information that can be relied on once `reload` is called.
    * It should refer to the last content being played.
+   * XXX TODO: per-content?
    */
   private _priv_reloadingMetadata: {
     /**
@@ -338,6 +338,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
   /**
    * Store last value of autoPlay, from the last load or reload.
+   * XXX TODO: per-content?
    */
   private _priv_lastAutoPlay: boolean;
 
@@ -491,8 +492,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     this._priv_currentError = null;
     this._priv_contentInfos = null;
-
-    this._priv_contentEventsMemory = {};
+    this._priv_currentPreloads = new Map();
 
     this._priv_reloadingMetadata = {};
 
@@ -798,6 +798,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    * /!\ The player cannot be "used" anymore after this method has been called.
    */
   dispose(): void {
+    this.clearPreloads();
+
     // free resources linked to the loaded content
     this.stop();
 
@@ -836,10 +838,20 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       transport: options.transport,
     });
     this._priv_reloadingMetadata = { options };
-    this._priv_initializeContentPlayback(options);
+    this._priv_initializeContentPlayback(options, false);
     this._priv_lastAutoPlay = options.autoPlay;
   }
 
+  preloadVideo(opts: ILoadVideoOptions): { id: string } {
+    const options = parseLoadVideoOptions(opts);
+    log.info("API", "Calling preloadvideo", {
+      url: options.url,
+      transport: options.transport,
+    });
+    const id = this._priv_initializeContentPlayback(options, true);
+    return { id };
+  }
+
   /**
    * Reload the last loaded content.
    * @param {Object} reloadOpts
@@ -895,7 +907,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     if (keySystems !== undefined) {
       newOptions.keySystems = keySystems;
     }
-    this._priv_initializeContentPlayback(newOptions);
+    this._priv_initializeContentPlayback(newOptions, false);
   }
 
   public createDebugElement(element: HTMLElement): {
@@ -997,8 +1009,12 @@ class Player extends EventEmitter<IPublicAPIEvent> {
   /**
    * From given options, initialize content playback.
    * @param {Object} options
+   * @param {string} isPreload
    */
-  private _priv_initializeContentPlayback(options: IParsedLoadVideoOptions): void {
+  private _priv_initializeContentPlayback(
+    options: IParsedLoadVideoOptions,
+    isPreload: boolean,
+  ): string {
     const {
       autoPlay,
       cmcd,
@@ -1038,6 +1054,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     /** Emit to stop the current content. */
     const currentContentCanceller = new TaskCanceller("API current content");
+    const contentId = generateContentId();
 
     const videoElement = this.videoElement;
 
@@ -1329,6 +1346,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         this.stop();
         this._priv_currentError = null;
         throw new Error("DirectFile feature not activated in your build.");
+      } else if (isPreload) {
+        throw new Error("DirectFile feature not authorized when pre-loading");
       } else if (isNullOrUndefined(url)) {
         throw new Error("No URL for a DirectFile content");
       }
@@ -1338,7 +1357,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         currentContentCanceller.signal,
       );
       if (currentContentCanceller.isUsed()) {
-        return;
+        return contentId;
       }
       initializer = new features.directfile.initDirectFile({
         autoPlay,
@@ -1367,7 +1386,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     /** Future `this._priv_contentInfos` related to this content. */
     const contentInfos: IPublicApiContentInfos = {
-      contentId: generateContentId(),
+      isPreload,
+      contentId,
       originalUrl: url,
       playbackObserver,
       currentContentCanceller,
@@ -1398,9 +1418,17 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     // Bind events
     initializer.addEventListener("error", (error) => {
+      if (contentInfos.isPreload) {
+        // XXX TODO: preloadError?
+        return;
+      }
       this._priv_onFatalError(error, contentInfos);
     });
     initializer.addEventListener("warning", (error) => {
+      if (contentInfos.isPreload) {
+        // XXX TODO: preloadWarning?
+        return;
+      }
       const formattedError = formatError(error, {
         defaultCode: "NONE",
         defaultReason: "An unknown error happened.",
@@ -1412,20 +1440,33 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       if (contentInfos.tracksStore !== null) {
         contentInfos.tracksStore.resetPeriodObjects();
       }
+      if (contentInfos.isPreload) {
+        return;
+      }
       if (this._priv_contentInfos !== null) {
         this._priv_contentInfos.segmentSinkMetricsCallback = null;
       }
       this._priv_lastAutoPlay = payload.autoPlay;
     });
-    initializer.addEventListener("inbandEvents", (inbandEvents) =>
-      this.trigger("inbandEvents", inbandEvents),
-    );
-    initializer.addEventListener("streamEvent", (streamEvent) =>
-      this.trigger("streamEvent", streamEvent),
-    );
-    initializer.addEventListener("streamEventSkip", (streamEventSkip) =>
-      this.trigger("streamEventSkip", streamEventSkip),
-    );
+    initializer.addEventListener("inbandEvents", (inbandEvents) => {
+      if (contentInfos.isPreload) {
+        return;
+      }
+      this.trigger("inbandEvents", inbandEvents);
+    });
+    initializer.addEventListener("streamEvent", (streamEvent) => {
+      if (contentInfos.isPreload) {
+        // XXX TODO: Store inbandEvents?
+        return;
+      }
+      this.trigger("streamEvent", streamEvent);
+    });
+    initializer.addEventListener("streamEventSkip", (streamEventSkip) => {
+      if (contentInfos.isPreload) {
+        return;
+      }
+      this.trigger("streamEventSkip", streamEventSkip);
+    });
     initializer.addEventListener("activePeriodChanged", (periodInfo) =>
       this._priv_onActivePeriodChanged(contentInfos, periodInfo),
     );
@@ -1467,16 +1508,18 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // Now, that most events are linked, prepare the next content.
     initializer.prepare();
 
-    // Now that the content is prepared, stop previous content and reset state
-    // This is done after content preparation as `stop` could technically have
-    // a long and synchronous blocking time.
-    // Note that this call is done **synchronously** after all events linking.
-    // This is **VERY** important so:
-    //   - the `STOPPED` state is switched to synchronously after loading a new
-    //     content.
-    //   - we can avoid involontarily catching events linked to the previous
-    //     content.
-    this.stop();
+    if (!isPreload) {
+      // Now that the content is prepared, stop previous content and reset state
+      // This is done after content preparation as `stop` could technically have
+      // a long and synchronous blocking time.
+      // Note that this call is done **synchronously** after all events linking.
+      // This is **VERY** important so:
+      //   - the `STOPPED` state is switched to synchronously after loading a new
+      //     content.
+      //   - we can avoid involontarily catching events linked to the previous
+      //     content.
+      this.stop();
+    }
 
     playbackObserver.attachMediaElement(videoElement);
 
@@ -1499,6 +1542,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
      * @param {string} state - The player state we're about to switch to.
      */
     const updateReloadingMetadata = (state: IPlayerState) => {
+      if (contentInfos.isPreload) {
+        return;
+      }
       switch (state) {
         case "STOPPED":
         case "RELOADING":
@@ -1539,7 +1585,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       }
       playerStateRef.onUpdate(
         (val, stopListeningToStateUpdates) => {
-          if (!isLoadedState(val)) {
+          if (!isLoadedState(val) || contentInfos.isPreload) {
             return; // content not loaded yet: no event
           }
           stopListeningToStateUpdates();
@@ -1576,7 +1622,11 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     });
 
     this._priv_currentError = null;
-    this._priv_contentInfos = contentInfos;
+    if (isPreload) {
+      this._priv_currentPreloads.set(contentId, contentInfos);
+    } else {
+      this._priv_contentInfos = contentInfos;
+    }
 
     /**
      * `TaskCanceller` allowing to stop emitting `"seeking"` and `"seeked"`
@@ -1588,6 +1638,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // React to player state change
     playerStateRef.onUpdate(
       (newState: IPlayerState) => {
+        if (contentInfos.isPreload) {
+          return;
+        }
         updateReloadingMetadata(newState);
         this._priv_setPlayerState(newState);
 
@@ -1618,7 +1671,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     playbackObserver.listen(
       (observation) => {
         updateReloadingMetadata(this.state);
-        this._priv_triggerPositionUpdate(contentInfos, observation);
+        if (!contentInfos.isPreload) {
+          this._priv_triggerPositionUpdate(contentInfos, observation);
+        }
       },
       { clearSignal: currentContentCanceller.signal },
     );
@@ -1634,11 +1689,48 @@ class Player extends EventEmitter<IPublicAPIEvent> {
           stopListeningToLock();
 
           // start playback!
-          initializer.start(videoElement, playbackObserver);
+          initializer.start(playbackObserver);
         }
       },
       { emitCurrentValue: true, clearSignal: currentContentCanceller.signal },
     );
+    return contentId;
+  }
+
+  startPreload(preloadId: string): void {
+    if (this.videoElement === null) {
+      throw new Error("Cannot start content: The RxPlayer is disposed.");
+    }
+    const preloadObject = this._priv_currentPreloads.get(preloadId);
+    if (preloadObject === undefined) {
+      throw new Error("No content preloaded with that id.");
+    }
+    this.stop();
+    preloadObject.isPreload = false;
+    this._priv_contentInfos = preloadObject;
+    this._priv_currentPreloads.delete(preloadId);
+    this._priv_setPlayerState(PLAYER_STATES.LOADING);
+    // XXX TODO also transform the RELOADING event into a loading one
+    preloadObject.playbackObserver.attachMediaElement(this.videoElement);
+  }
+
+  getCurrentPreloads(): Array<{
+    id: string;
+  }> {
+    return Array.from(this._priv_currentPreloads.keys()).map((id) => ({ id }));
+  }
+
+  stopPreloads(preloadId: string): boolean {
+    const preloadObject = this._priv_currentPreloads.get(preloadId);
+    if (preloadObject === undefined) {
+      return false;
+    }
+    preloadObject.currentContentCanceller.cancel("Stopped preload");
+    return this._priv_currentPreloads.delete(preloadId);
+  }
+
+  clearPreloads(): void {
+    this.getCurrentPreloads().forEach((preload) => this.stopPreloads(preload.id));
   }
 
   /**
@@ -2071,7 +2163,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    */
   seekTo(
     time:
-      number | { relative: number } | { position: number } | { wallClockTime: number },
+      | number
+      | { relative: number }
+      | { position: number }
+      | { wallClockTime: number },
   ): number {
     if (this.videoElement === null) {
       throw new Error("Disposed player");
@@ -2954,8 +3049,6 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     this._priv_contentInfos?.mediaElementTracksStore?.dispose();
     this._priv_contentInfos = null;
 
-    this._priv_contentEventsMemory = {};
-
     // DRM-related clean-up
     const freeUpContentLock = () => {
       if (this.videoElement !== null) {
@@ -2995,14 +3088,14 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     contentInfos: IPublicApiContentInfos,
     manifest: IManifest | IManifestMetadata,
   ): void {
-    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+    if (
+      !contentInfos.isPreload &&
+      contentInfos.contentId !== this._priv_contentInfos?.contentId
+    ) {
       return; // Event for another content
     }
-    contentInfos.manifest = manifest;
 
-    if (manifest.manifestFormat === ManifestMetadataFormat.Class) {
-      this._priv_reloadingMetadata.manifest = manifest as IManifest;
-    }
+    contentInfos.manifest = manifest;
 
     const tracksStore = new TracksStore({
       preferTrickModeTracks: this._priv_preferTrickModeTracks,
@@ -3015,29 +3108,70 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       },
     });
     contentInfos.tracksStore = tracksStore;
-    tracksStore.addEventListener("newAvailablePeriods", (p) => {
-      this.trigger("newAvailablePeriods", p);
-    });
-    tracksStore.addEventListener("brokenRepresentationsLock", (e) => {
-      this.trigger("brokenRepresentationsLock", e);
-    });
-    tracksStore.addEventListener("trackUpdate", (e) => {
-      this.trigger("trackUpdate", e);
 
-      const currentPeriod = this._priv_contentInfos?.currentPeriod ?? undefined;
-      if (
-        e.reason === "no-playable-representation" &&
-        e.period.id === currentPeriod?.id
-      ) {
-        this._priv_onAvailableTracksMayHaveChanged(e.trackType);
-      }
-    });
-    tracksStore.addEventListener("warning", (err) => {
-      this.trigger("warning", err);
-    });
-    tracksStore.addEventListener("error", (err) => {
-      this._priv_onFatalError(err, contentInfos);
-    });
+    if (
+      !contentInfos.isPreload &&
+      manifest.manifestFormat === ManifestMetadataFormat.Class
+    ) {
+      this._priv_reloadingMetadata.manifest = manifest as IManifest;
+    }
+    if (contentInfos.isPreload) {
+      tracksStore.addEventListener("newAvailablePeriods", (p) => {
+        this.trigger("preload-newAvailablePeriods", {
+          contentId: contentInfos.contentId,
+          payload: p,
+        });
+      });
+      tracksStore.addEventListener("brokenRepresentationsLock", (e) => {
+        this.trigger("preload-brokenRepresentationsLock", {
+          contentId: contentInfos.contentId,
+          payload: e,
+        });
+      });
+      tracksStore.addEventListener("trackUpdate", (e) => {
+        this.trigger("preload-trackUpdate", {
+          contentId: contentInfos.contentId,
+          payload: e,
+        });
+      });
+      tracksStore.addEventListener("warning", (err) => {
+        this.trigger("preload-warning", {
+          contentId: contentInfos.contentId,
+          payload: err,
+        });
+      });
+      tracksStore.addEventListener("error", (_err) => {
+        // XXX TODO: handle content stop
+        // this.trigger("preload-error", {
+        //   contentId: contentInfos.contentId,
+        //   payload: err,
+        // });
+      });
+    } else {
+      tracksStore.addEventListener("newAvailablePeriods", (p) => {
+        this.trigger("newAvailablePeriods", p);
+      });
+      tracksStore.addEventListener("brokenRepresentationsLock", (e) => {
+        this.trigger("brokenRepresentationsLock", e);
+      });
+      tracksStore.addEventListener("trackUpdate", (e) => {
+        this.trigger("trackUpdate", e);
+
+        const currentPeriod = this._priv_contentInfos?.currentPeriod ?? undefined;
+        if (
+          e.reason === "no-playable-representation" &&
+          e.period.id === currentPeriod?.id
+        ) {
+          this._priv_onAvailableTracksMayHaveChanged(e.trackType);
+        }
+      });
+      tracksStore.addEventListener("warning", (err) => {
+        this.trigger("warning", err);
+      });
+      tracksStore.addEventListener("error", (err) => {
+        this._priv_onFatalError(err, contentInfos);
+      });
+    }
 
     tracksStore.addEventListener("noPlayableTrack", (noPlayableTrackEvent) => {
       this.trigger("noPlayableTrack", noPlayableTrackEvent);
@@ -3067,25 +3201,28 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     if (!isNullOrUndefined(contentInfos?.tracksStore)) {
       contentInfos.tracksStore.onManifestUpdate(this._priv_contentInfos.manifest);
     }
-    const currentPeriod = this._priv_contentInfos?.currentPeriod ?? undefined;
-    const currTracksStore = this._priv_contentInfos?.tracksStore;
-    if (currentPeriod === undefined || isNullOrUndefined(currTracksStore)) {
-      return;
-    }
-    for (const update of updates.updatedPeriods) {
-      if (update.period.id === currentPeriod.id) {
-        if (
-          update.result.addedAdaptations.length > 0 ||
-          update.result.removedAdaptations.length > 0
-        ) {
-          // We might have new (or less) tracks, send events just to be sure
-          const periodRef = currTracksStore.getPeriodObjectFromPeriod(currentPeriod);
-          if (periodRef === undefined) {
-            return;
+
+    if (!contentInfos.isPreload) {
+      const currentPeriod = this._priv_contentInfos?.currentPeriod ?? undefined;
+      const currTracksStore = this._priv_contentInfos?.tracksStore;
+      if (currentPeriod === undefined || isNullOrUndefined(currTracksStore)) {
+        return;
+      }
+      for (const update of updates.updatedPeriods) {
+        if (update.period.id === currentPeriod.id) {
+          if (
+            update.result.addedAdaptations.length > 0 ||
+            update.result.removedAdaptations.length > 0
+          ) {
+            // We might have new (or less) tracks, send events just to be sure
+            const periodRef = currTracksStore.getPeriodObjectFromPeriod(currentPeriod);
+            if (periodRef === undefined) {
+              return;
+            }
+            this._priv_onAvailableTracksMayHaveChanged("audio");
+            this._priv_onAvailableTracksMayHaveChanged("text");
+            this._priv_onAvailableTracksMayHaveChanged("video");
           }
-          this._priv_onAvailableTracksMayHaveChanged("audio");
-          this._priv_onAvailableTracksMayHaveChanged("text");
-          this._priv_onAvailableTracksMayHaveChanged("video");
         }
       }
     }
@@ -3162,15 +3299,30 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       [],
     );
     for (const [period, trackType] of periodsAndTrackTypes) {
-      this._priv_triggerEventIfNotStopped(
-        "representationListUpdate",
-        {
-          period: { start: period.start, end: period.end, id: period.id },
-          trackType,
-          reason: "decipherability-update",
-        },
-        contentInfos.currentContentCanceller.signal,
-      );
+      if (contentInfos.isPreload) {
+        this._priv_triggerEventIfNotStopped(
+          "preload-representationListUpdate",
+          {
+            contentId: contentInfos.contentId,
+            payload: {
+              period: { start: period.start, end: period.end, id: period.id },
+              trackType,
+              reason: "decipherability-update",
+            },
+          },
+          contentInfos.currentContentCanceller.signal,
+        );
+      } else {
+        this._priv_triggerEventIfNotStopped(
+          "representationListUpdate",
+          {
+            period: { start: period.start, end: period.end, id: period.id },
+            trackType,
+            reason: "decipherability-update",
+          },
+          contentInfos.currentContentCanceller.signal,
+        );
+      }
     }
   }
 
@@ -3185,21 +3337,12 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     contentInfos: IPublicApiContentInfos,
     { period }: { period: IPeriodMetadata },
   ): void {
+    contentInfos.currentPeriod = period;
     if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
-      return; // Event for another content
+      return; // Event for another content (e.g. pre-loaded)
     }
-    contentInfos.currentPeriod = period;
 
     const cancelSignal = contentInfos.currentContentCanceller.signal;
-    if (this._priv_contentEventsMemory.periodChange !== period) {
-      this._priv_contentEventsMemory.periodChange = period;
-      this._priv_triggerEventIfNotStopped(
-        "periodChange",
-        { start: period.start, end: period.end, id: period.id },
-        cancelSignal,
-      );
-    }
-
     this._priv_triggerEventIfNotStopped(
       "availableAudioTracksChange",
       this.getAvailableAudioTracks(),
@@ -3267,7 +3410,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       adaptationRef: SharedReference<IAdaptationChoice | null | undefined>;
     },
   ): void {
-    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+    if (
+      !contentInfos.isPreload &&
+      contentInfos.contentId !== this._priv_contentInfos?.contentId
+    ) {
       return; // Event for another content
     }
     const { type, period, adaptationRef } = value;
@@ -3298,7 +3444,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     contentInfos: IPublicApiContentInfos,
     value: { type: IBufferType; periodId: string },
   ): void {
-    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+    if (
+      !contentInfos.isPreload &&
+      contentInfos.contentId !== this._priv_contentInfos?.contentId
+    ) {
       return; // Event for another content
     }
     const { type, periodId } = value;
@@ -3359,7 +3508,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       period: IPeriodMetadata;
     },
   ): void {
-    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+    if (
+      !contentInfos.isPreload &&
+      contentInfos.contentId !== this._priv_contentInfos?.contentId
+    ) {
       return; // Event for another content
     }
 
@@ -3376,6 +3528,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       activePeriodAdaptations[type] = adaptation;
     }
 
+    if (contentInfos.isPreload) {
+      return; // skip event-sending part
+    }
+
     const { tracksStore } = contentInfos;
     const cancelSignal = contentInfos.currentContentCanceller.signal;
     if (
@@ -3436,7 +3592,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       representation: IRepresentationMetadata | null;
     },
   ): void {
-    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+    if (
+      !contentInfos.isPreload &&
+      contentInfos.contentId !== this._priv_contentInfos?.contentId
+    ) {
       return; // Event for another content
     }
 
@@ -3454,28 +3613,30 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       activePeriodRepresentations[type] = representation;
     }
 
-    if (
-      !isNullOrUndefined(period) &&
-      currentPeriod !== null &&
-      currentPeriod.id === period.id
-    ) {
-      const cancelSignal = this._priv_contentInfos.currentContentCanceller.signal;
-      if (type === "video") {
-        this._priv_triggerEventIfNotStopped(
-          "videoRepresentationChange",
-          isNullOrUndefined(representation)
-            ? representation
-            : toVideoRepresentation(representation),
-          cancelSignal,
-        );
-      } else if (type === "audio") {
-        this._priv_triggerEventIfNotStopped(
-          "audioRepresentationChange",
-          isNullOrUndefined(representation)
-            ? representation
-            : toAudioRepresentation(representation),
-          cancelSignal,
-        );
+    if (!contentInfos.isPreload) {
+      if (
+        !isNullOrUndefined(period) &&
+        currentPeriod !== null &&
+        currentPeriod.id === period.id
+      ) {
+        const cancelSignal = contentInfos.currentContentCanceller.signal;
+        if (type === "video") {
+          this._priv_triggerEventIfNotStopped(
+            "videoRepresentationChange",
+            isNullOrUndefined(representation)
+              ? representation
+              : toVideoRepresentation(representation),
+            cancelSignal,
+          );
+        } else if (type === "audio") {
+          this._priv_triggerEventIfNotStopped(
+            "audioRepresentationChange",
+            isNullOrUndefined(representation)
+              ? representation
+              : toAudioRepresentation(representation),
+            cancelSignal,
+          );
+        }
       }
     }
   }
@@ -3515,6 +3676,17 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    */
   private _priv_setPlayerState(newState: IPlayerState): void {
     if (this.state !== newState) {
+      if (
+        (this.state === "LOADING" && newState === "RELOADING") ||
+        (this.state === "LOADED" && newState === "PAUSED")
+      ) {
+        // We don't do those transitions
+        log.info("API", "ignored playerStateChange event", {
+          newState,
+          prevState: this.state,
+        });
+        return;
+      }
       this.state = newState;
       log.info("API", "playerStateChange event", { newState });
       this.trigger("playerStateChange", newState);
@@ -3533,7 +3705,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     contentInfos: IPublicApiContentInfos,
     observation: IPlaybackObservation,
   ): void {
-    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+    if (
+      !contentInfos.isPreload &&
+      contentInfos.contentId !== this._priv_contentInfos?.contentId
+    ) {
       return; // Event for another content
     }
 
@@ -3785,18 +3960,20 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       defaultReason: "An unknown error stopped content playback.",
     });
     formattedError.fatal = true;
-    contentInfos.currentContentCanceller.cancel("fatal err");
-    this._priv_cleanUpCurrentContentState();
-    this._priv_currentError = formattedError;
-    log.error("API", "The player stopped because of an error", formattedError);
-    this._priv_setPlayerState(PLAYER_STATES.STOPPED);
+    contentInfos.currentContentCanceller.cancel("fatal error");
+    if (!contentInfos.isPreload) {
+      this._priv_cleanUpCurrentContentState();
+      this._priv_currentError = formattedError;
+      log.error("API", "The player stopped because of an error", formattedError);
+      this._priv_setPlayerState(PLAYER_STATES.STOPPED);
 
-    // TODO This condition is here because the eventual callback called when the
-    // player state is updated can launch a new content, thus the error will not
-    // be here anymore, in which case triggering the "error" event is unwanted.
-    // This is very ugly though, and we should probable have a better solution
-    if (this._priv_currentError === formattedError) {
-      this.trigger("error", formattedError);
+      // TODO This condition is here because the eventual callback called when the
+      // player state is updated can launch a new content, thus the error will not
+      // be here anymore, in which case triggering the "error" event is unwanted.
+      // This is very ugly though, and we should probable have a better solution
+      if (this._priv_currentError === formattedError) {
+        this.trigger("error", formattedError);
+      }
     }
   }
 
@@ -3897,10 +4074,45 @@ interface IPublicAPIEvent {
   streamEventSkip: IStreamEvent;
   inbandEvents: IInbandEvent[];
   noPlayableTrack: INoPlayableTrackEventPayload;
+
+  "preload-newAvailablePeriods": {
+    contentId: string;
+    payload: IPeriod[];
+  };
+  "preload-brokenRepresentationsLock": {
+    contentId: string;
+    payload: IBrokenRepresentationsLockContext;
+  };
+  "preload-trackUpdate": {
+    contentId: string;
+    payload: ITrackUpdateEventPayload;
+  };
+  "preload-representationListUpdate": {
+    contentId: string;
+    payload: IRepresentationListUpdateContext;
+  };
+  "preload-error": {
+    contentId: string;
+    payload: IPlayerError | Error;
+  };
+  "preload-warning": {
+    contentId: string;
+    payload: IPlayerError | Error;
+  };
 }
 
-/** State linked to a particular contents loaded by the public API. */
+/** State linked to a particular content loaded by the public API. */
 export interface IPublicApiContentInfos {
+  /**
+   * If `true`, this content is a "preload" which is pre-buffering before
+   * truly loading on a media element.
+   *
+   * Such contents' events and configuration also go through a different way in
+   * the API than a classical content, as the regular RxPlayer API and events
+   * apply to the currently loaded content, and a content may be currently
+   * loaded while several other are being preloaded.
+   */
+  isPreload: boolean;
   /**
    * Unique identifier for this `IPublicApiContentInfos` object.
    * Allows to identify and thus compare this `contentInfos` object with another
@@ -3909,10 +4121,10 @@ export interface IPublicApiContentInfos {
   contentId: string;
   /** Original URL set to load the content. */
   originalUrl: string | undefined;
+  /** Abstration allowing to interact with the `HTMLMediaElement`. */
+  playbackObserver: IMediaElementPlaybackObserver;
   /** `ContentInitializer` used to load the content. */
   initializer: ContentInitializer;
-  /** interface emitting regularly playback observations. */
-  playbackObserver: MediaElementPlaybackObserver;
   /** TaskCanceller triggered when it's time to stop the current content. */
   currentContentCanceller: TaskCanceller;
   /** The default behavior to adopt when switching the audio track. */
diff --git a/src/main_thread/init/directfile_content_initializer.ts b/src/main_thread/init/directfile_content_initializer.ts
index da2e7ecafe..e4b31a181f 100644
--- a/src/main_thread/init/directfile_content_initializer.ts
+++ b/src/main_thread/init/directfile_content_initializer.ts
@@ -81,15 +81,20 @@ export default class DirectFileContentInitializer extends ContentInitializer {
   /**
    * Start playback of the content linked to this `DirectFileContentInitializer`
    * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
-   * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
-   * content will be played.
    * @param {Object} playbackObserver - Object regularly emitting playback
    * information.
    */
-  public start(
-    mediaElement: IMediaElement,
-    playbackObserver: IMediaElementPlaybackObserver,
-  ): void {
+  public start(playbackObserver: IMediaElementPlaybackObserver): void {
+    const mediaElement = playbackObserver.getMediaElement();
+    if (mediaElement === null) {
+      throw new Error(
+        "A directfile content cannot play or preload without a media element",
+      );
+    }
+
+    if (this._initCanceller.isUsed()) {
+      return;
+    }
     const cancelSignal = this._initCanceller.signal;
     const { keySystems, speed, url } = this._settings;
 
@@ -179,6 +184,10 @@ export default class DirectFileContentInitializer extends ContentInitializer {
     );
   }
 
+  public attachMediaElement(_mediaElement: IMediaElement): void {
+    throw new Error("Content preloading not loaded in directfile mode");
+  }
+
   /**
    * Update URL this `ContentIntializer` depends on.
    * @param {Array.<string>|undefined} _urls
@@ -196,6 +205,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
    */
   public dispose(reason: string | undefined): void {
     this._initCanceller.cancel(reason ?? "Directfile Init dispose");
+    this._initCanceller = new TaskCanceller("Directfile Init new");
   }
 
   /**
@@ -227,7 +237,6 @@ export default class DirectFileContentInitializer extends ContentInitializer {
     };
     performInitialSeekAndPlay(
       {
-        mediaElement,
         playbackObserver,
         startTime: initialTime,
         mustAutoPlay: autoPlay,
diff --git a/src/main_thread/init/media_source_content_initializer.ts b/src/main_thread/init/media_source_content_initializer.ts
index 44d1f42aa2..016cf3f590 100644
--- a/src/main_thread/init/media_source_content_initializer.ts
+++ b/src/main_thread/init/media_source_content_initializer.ts
@@ -87,7 +87,7 @@ const generateContentId = idGenerator();
  * @class MediaSourceContentInitializer
  */
 export default class MediaSourceContentInitializer extends ContentInitializer {
-  /** Constructor settings associated to this `MediaSourceContentInitializer`. */
+  /** Constructor settings associated to this `MultiThreadContentInitializer`. */
   private _settings: IInitializeArguments;
 
   /**
@@ -150,6 +150,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     >;
   };
 
+  private _isPlaybackReady: boolean;
+
   /**
    * Create a new `MediaSourceContentInitializer`, associated to the given
    * settings.
@@ -168,6 +170,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       pendingThumbnailFetching: new Map(),
     };
     this._queuedCoreMessages = null;
+    this._isPlaybackReady = false;
   }
 
   /**
@@ -189,6 +192,27 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       this._settings.bufferOptions;
     const initialVideoBitrate = adaptiveOptions.initialBitrates.video;
     const initialAudioBitrate = adaptiveOptions.initialBitrates.audio;
+
+    let textDisplayer: ITextDisplayer | null = null;
+    if (
+      this._settings.textTrackOptions.textTrackMode === "html" &&
+      features.htmlTextDisplayer !== null
+    ) {
+      assert(canHandleTextTracks(this._settings.textTrackOptions));
+      textDisplayer = new features.htmlTextDisplayer(
+        null,
+        this._settings.textTrackOptions.textTrackElement,
+      );
+    } else if (features.nativeTextDisplayer !== null) {
+      assert(canHandleTextTracks(this._settings.textTrackOptions));
+      textDisplayer = new features.nativeTextDisplayer(null);
+    } else {
+      assert(!canHandleTextTracks(this._settings.textTrackOptions));
+    }
+    this._initCanceller.signal.register((err) => {
+      textDisplayer?.stop(err.reason);
+    });
+
     this._currentContentInfo = {
       contentId,
       contentDecryptor: null,
@@ -199,6 +223,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       autoPlay: undefined,
       initialPlayPerformed: null,
       useMseInWorker: playbackSupport.mseInWorker,
+      textDisplayer,
     };
     coreInterface.sendMessage({
       type: MainThreadMessageType.PrepareContent,
@@ -343,54 +368,17 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   /**
-   * @param {HTMLMediaElement} mediaElement
    * @param {Object} playbackObserver
    */
-  public start(
-    mediaElement: IMediaElement,
-    playbackObserver: IMediaElementPlaybackObserver,
-  ): void {
-    this.prepare(); // Load Manifest if not already done
+  public start(playbackObserver: IMediaElementPlaybackObserver): void {
     if (this._initCanceller.isUsed()) {
       return;
     }
-
-    let textDisplayer: ITextDisplayer | null = null;
-    try {
-      if (
-        this._settings.textTrackOptions.textTrackMode === "html" &&
-        features.htmlTextDisplayer !== null
-      ) {
-        assert(canHandleTextTracks(this._settings.textTrackOptions));
-        textDisplayer = new features.htmlTextDisplayer(
-          mediaElement,
-          this._settings.textTrackOptions.textTrackElement,
-        );
-      } else if (features.nativeTextDisplayer !== null) {
-        assert(canHandleTextTracks(this._settings.textTrackOptions));
-        textDisplayer = new features.nativeTextDisplayer(mediaElement);
-      } else {
-        assert(!canHandleTextTracks(this._settings.textTrackOptions));
-      }
-    } catch (err) {
-      log.error(
-        "Init",
-        "failed to initialize text displayer",
-        err instanceof Error ? err : "Unknown Error",
-      );
+    this.prepare(); // Load Manifest if not already done
+    if (this._initCanceller.isUsed()) {
+      return;
     }
 
-    this._initCanceller.signal.register((err) => {
-      textDisplayer?.stop(err.reason);
-    });
-
-    /** Translate errors coming from the media element into RxPlayer errors. */
-    listenToMediaError(
-      mediaElement,
-      (error: MediaError) => this._onFatalError(error),
-      this._initCanceller.signal,
-    );
-
     /**
      * Send content protection initialization data.
      * TODO remove and use ContentDecryptor directly when possible.
@@ -401,19 +389,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       MediaSourceInitializationStatus.Nothing,
     );
 
-    const { statusRef: drmInitializationStatus, contentDecryptor } =
-      this._initializeContentDecryption(
-        mediaElement,
-        lastContentProtection,
-        mediaSourceStatus,
-        () => notifyAndStartMediaSourceReload(0, undefined, undefined),
-        this._initCanceller.signal,
-      );
-    const contentInfo = this._currentContentInfo;
-    if (contentInfo !== null) {
-      contentInfo.contentDecryptor = contentDecryptor;
-    }
-
     const streamEventsEmitter = new StreamEventsEmitter(playbackObserver);
     streamEventsEmitter.addEventListener(
       "event",
@@ -433,32 +408,69 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       streamEventsEmitter.stop(err.reason);
     });
 
+    const drmInitializationStatus = new SharedReference<IDrmInitializationStatus>({
+      initializationState: {
+        type: "uninitialized",
+        value: null,
+      },
+      drmSystemId: undefined,
+    });
     const playbackStartParams = {
-      mediaElement,
-      textDisplayer,
+      textDisplayer: this._currentContentInfo?.textDisplayer ?? null,
       playbackObserver,
       drmInitializationStatus,
       mediaSourceStatus,
       streamEventsEmitter,
     };
-    mediaSourceStatus.onUpdate(
-      (msInitStatus, stopListeningMSStatus) => {
-        if (msInitStatus === MediaSourceInitializationStatus.Attached) {
-          stopListeningMSStatus();
-          this._startPlaybackIfReady(playbackStartParams);
-        }
-      },
-      { clearSignal: this._initCanceller.signal, emitCurrentValue: true },
-    );
-    drmInitializationStatus.onUpdate(
-      (initializationStatus, stopListeningDrm) => {
-        if (initializationStatus.initializationState.type === "initialized") {
-          stopListeningDrm();
-          this._startPlaybackIfReady(playbackStartParams);
-        }
-      },
-      { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
-    );
+
+    playbackObserver.onMediaElementAttachment((mediaElement: IMediaElement) => {
+      listenToMediaError(
+        mediaElement,
+        (error: MediaError) => this._onFatalError(error),
+        this._initCanceller.signal,
+      );
+
+      const contentDecryptor = this._initializeContentDecryption(
+        mediaElement,
+        lastContentProtection,
+        drmInitializationStatus,
+        mediaSourceStatus,
+        () => reloadMediaSource(0, undefined, undefined),
+        this._initCanceller.signal,
+      );
+      const contentInfo = this._currentContentInfo;
+      if (contentInfo === null) {
+        return;
+      }
+      contentInfo.contentDecryptor = contentDecryptor;
+
+      const textDisplayer = contentInfo.textDisplayer ?? null;
+      textDisplayer?.attachMediaElement(mediaElement);
+
+      mediaSourceStatus.onUpdate(
+        (msInitStatus, stopListeningMSStatus) => {
+          if (msInitStatus === MediaSourceInitializationStatus.Attached) {
+            stopListeningMSStatus();
+            this._startPlaybackIfReady(playbackStartParams);
+          }
+        },
+        { clearSignal: this._initCanceller.signal, emitCurrentValue: true },
+      );
+      drmInitializationStatus.onUpdate(
+        (initializationStatus, stopListeningDrm) => {
+          if (initializationStatus.initializationState.type === "initialized") {
+            stopListeningDrm();
+            this._startPlaybackIfReady(playbackStartParams);
+          }
+        },
+        { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
+      );
+      this._settings.coreInterface.sendMessage({
+        type: MainThreadMessageType.MediaElementReady,
+        contentId: contentInfo.contentId,
+        value: null,
+      });
+    }, this._initCanceller.signal);
 
     /**
      * Reset directly (synchronously) the current `MediaSource` and signal to
@@ -522,6 +534,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         log.warn("Init", "Asked to reload when no content is loaded.");
         return;
       }
+      // XXX TODO: Not sure if this is actually needed?
+      // const mediaElement = playbackObserver.getMediaElement();
+      // if (mediaElement === null) {
+      //   // TODO: We should ask to flush buffers here?
+      //   return;
+      // }
       const lastObservation = playbackObserver.getReference().getValue();
       const currentPosition = lastObservation.position.getWanted();
       const isPaused =
@@ -538,8 +556,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       }
 
       this._reload(
-        mediaElement,
-        textDisplayer,
         playbackObserver,
         mediaSourceStatus,
         streamEventsEmitter,
@@ -554,6 +570,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
+
           if (this._currentContentInfo !== null) {
             if (this._currentContentInfo.mediaSourceInfo?.type === "main") {
               this._currentContentInfo.mediaSourceInfo.mediaSource.dispose(
@@ -565,32 +582,34 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
               mediaSourceId: msgData.mediaSourceId,
             };
           }
-          const mediaSourceLink = msgData.value;
-          mediaSourceStatus.onUpdate(
-            (currStatus, stopListening) => {
-              if (currStatus === MediaSourceInitializationStatus.AttachNow) {
-                stopListening();
-                log.info("media", "Attaching MediaSource URL to the media element");
-                if (mediaSourceLink.type === "handle") {
-                  mediaElement.srcObject = mediaSourceLink.value;
-                  this._currentMediaSourceCanceller.signal.register(() => {
-                    mediaElement.srcObject = null;
-                  });
-                } else {
-                  mediaElement.src = mediaSourceLink.value;
-                  this._currentMediaSourceCanceller.signal.register(() => {
-                    resetMediaElement(mediaElement, mediaSourceLink.value);
-                  });
+          playbackObserver.onMediaElementAttachment((mediaElement: IMediaElement) => {
+            const mediaSourceLink = msgData.value;
+            mediaSourceStatus.onUpdate(
+              (currStatus, stopListening) => {
+                if (currStatus === MediaSourceInitializationStatus.AttachNow) {
+                  stopListening();
+                  log.info("media", "Attaching MediaSource URL to the media element");
+                  if (mediaSourceLink.type === "handle") {
+                    mediaElement.srcObject = mediaSourceLink.value;
+                    this._currentMediaSourceCanceller.signal.register(() => {
+                      mediaElement.srcObject = null;
+                    });
+                  } else {
+                    mediaElement.src = mediaSourceLink.value;
+                    this._currentMediaSourceCanceller.signal.register(() => {
+                      resetMediaElement(mediaElement, mediaSourceLink.value);
+                    });
+                  }
+                  disableRemotePlaybackOnManagedMediaSource(
+                    mediaElement,
+                    this._currentMediaSourceCanceller.signal,
+                  );
+                  mediaSourceStatus.setValue(MediaSourceInitializationStatus.Attached);
                 }
-                disableRemotePlaybackOnManagedMediaSource(
-                  mediaElement,
-                  this._currentMediaSourceCanceller.signal,
-                );
-                mediaSourceStatus.setValue(MediaSourceInitializationStatus.Attached);
-              }
-            },
-            { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
-          );
+              },
+              { emitCurrentValue: true, clearSignal: this._initCanceller.signal },
+            );
+          }, this._currentMediaSourceCanceller.signal);
           break;
         }
 
@@ -609,12 +628,16 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           break;
 
         case CoreMessageType.CreateMediaSource:
-          this._onCreateMediaSourceMessage(
-            msgData,
-            mediaElement,
-            mediaSourceStatus,
-            this._settings.coreInterface,
-          );
+          {
+            playbackObserver.onMediaElementAttachment((mediaElement: IMediaElement) => {
+              this._onCreateMediaSourceMessage(
+                msgData,
+                mediaElement,
+                mediaSourceStatus,
+                this._settings.coreInterface,
+              );
+            }, this._currentMediaSourceCanceller.signal);
+          }
           break;
 
         case CoreMessageType.AddSourceBuffer:
@@ -824,9 +847,16 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             return;
           }
           const lastObservation = playbackObserver.getReference().getValue();
-          const currentTime = lastObservation.position.isAwaitingFuturePosition()
-            ? lastObservation.position.getWanted()
-            : mediaElement.currentTime;
+          let currentTime;
+          if (lastObservation.position.isAwaitingFuturePosition()) {
+            currentTime = lastObservation.position.getWanted();
+          } else {
+            const mediaElement = playbackObserver.getMediaElement();
+            if (mediaElement === null) {
+              return; // Nothing to do
+            }
+            currentTime = mediaElement.currentTime;
+          }
           const relativeResumingPosition = msgData.value?.relativeResumingPosition ?? 0;
           const canBeApproximateSeek = Boolean(
             msgData.value?.relativePosHasBeenDefaulted,
@@ -1148,6 +1178,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
+          const textDisplayer = this._currentContentInfo?.textDisplayer ?? null;
           if (textDisplayer === null) {
             log.warn("text", "Received AddTextData message but no text displayer exists");
           } else {
@@ -1174,6 +1205,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
+          const textDisplayer = this._currentContentInfo?.textDisplayer ?? null;
           if (textDisplayer === null) {
             log.warn(
               "text",
@@ -1206,6 +1238,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
+          const textDisplayer = this._currentContentInfo?.textDisplayer ?? null;
           if (textDisplayer === null) {
             log.warn(
               "text",
@@ -1221,6 +1254,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
+          const textDisplayer = this._currentContentInfo?.textDisplayer ?? null;
           if (textDisplayer === null) {
             log.warn(
               "text",
@@ -1261,6 +1295,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             if (this._currentContentInfo?.contentId !== msgData.contentId) {
               return;
             }
+            const mediaElement = playbackObserver.getMediaElement();
+            if (mediaElement === null) {
+              return; // Nothing to do I guess
+            }
 
             const keySystem = getKeySystemConfiguration(mediaElement);
             if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem?.[0])) {
@@ -1348,7 +1386,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   public dispose(reason: string | undefined): void {
-    this._initCanceller.cancel("Init dispose");
+    this._initCanceller.cancel("Init dispose: " + String(reason));
+    this._initCanceller = new TaskCanceller("Init dispose: " + String(reason));
     if (this._currentContentInfo !== null) {
       if (this._currentContentInfo.mediaSourceInfo?.type === "main") {
         this._currentContentInfo.mediaSourceInfo.mediaSource.dispose(reason);
@@ -1368,13 +1407,11 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   private _initializeContentDecryption(
     mediaElement: IMediaElement,
     lastContentProtection: IReadOnlySharedReference<null | IContentProtection>,
+    drmInitializationStatus: SharedReference<IDrmInitializationStatus>,
     mediaSourceStatus: SharedReference<MediaSourceInitializationStatus>,
     reloadMediaSource: () => void,
     cancelSignal: CancellationSignal,
-  ): {
-    statusRef: IReadOnlySharedReference<IDrmInitializationStatus>;
-    contentDecryptor: IContentDecryptor | null;
-  } {
+  ): IContentDecryptor | null {
     const { keySystems } = this._settings;
 
     // TODO private?
@@ -1396,16 +1433,15 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         },
         { clearSignal: cancelSignal },
       );
-      const ref = new SharedReference({
+      drmInitializationStatus.setValue({
         initializationState: {
           type: "initialized" as const,
           value: null,
         },
-        contentDecryptor: null,
         drmSystemId: undefined,
       });
-      ref.finish(); // We know that no new value will be triggered
-      return { statusRef: ref, contentDecryptor: null };
+      drmInitializationStatus.finish(); // We know that no new value will be triggered
+      return null;
     };
 
     if (keySystems.length === 0) {
@@ -1423,14 +1459,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
     const ContentDecryptor = features.decrypt;
     const contentDecryptor = new ContentDecryptor(emeApi, mediaElement, keySystems);
-    const drmStatusRef = new SharedReference<IDrmInitializationStatus>(
-      {
-        initializationState: { type: "uninitialized", value: null },
-        drmSystemId: undefined,
-      },
-      cancelSignal,
-    );
-
     const updateCodecSupportOnStateChange = (state: ContentDecryptorState) => {
       if (state > ContentDecryptorState.Initializing) {
         const manifest = this._currentContentInfo?.manifest;
@@ -1518,7 +1546,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           { clearSignal: cancelSignal, emitCurrentValue: true },
         );
       } else if (state === ContentDecryptorState.ReadyForContent) {
-        drmStatusRef.setValue({
+        drmInitializationStatus.setValue({
           initializationState: { type: "initialized", value: null },
           drmSystemId: contentDecryptor.systemId,
         });
@@ -1548,7 +1576,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       contentDecryptor.dispose(err.reason);
     });
 
-    return { statusRef: drmStatusRef, contentDecryptor };
+    return contentDecryptor;
   }
   /**
    * Retrieves all unknown codecs from the current manifest, checks these unknown codecs
@@ -1579,8 +1607,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   private _reload(
-    mediaElement: IMediaElement,
-    textDisplayer: ITextDisplayer | null,
     playbackObserver: IMediaElementPlaybackObserver,
     mediaSourceStatus: SharedReference<MediaSourceInitializationStatus>,
     streamEventsEmitter: StreamEventsEmitter,
@@ -1604,8 +1630,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           {
             initialTime: position,
             autoPlay,
-            mediaElement,
-            textDisplayer,
             playbackObserver,
             streamEventsEmitter,
           },
@@ -1660,8 +1684,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     parameters: {
       initialTime: number;
       autoPlay: boolean;
-      mediaElement: IMediaElement;
-      textDisplayer: ITextDisplayer | null;
       playbackObserver: IMediaElementPlaybackObserver;
       streamEventsEmitter: StreamEventsEmitter;
     },
@@ -1681,21 +1703,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
     const { manifest, mediaSourceInfo } = this._currentContentInfo;
     const { speed } = this._settings;
-    const {
-      initialTime,
-      autoPlay,
-      mediaElement,
-      textDisplayer,
-      playbackObserver,
-      streamEventsEmitter,
-    } = parameters;
+    const { initialTime, autoPlay, playbackObserver, streamEventsEmitter } = parameters;
     this._currentContentInfo.initialTime = initialTime;
     this._currentContentInfo.autoPlay = autoPlay;
     streamEventsEmitter.pause(); // Only start polling events once ready to play
 
     const { autoPlayResult, initialPlayPerformed } = performInitialSeekAndPlay(
       {
-        mediaElement,
         playbackObserver,
         startTime: initialTime,
         mustAutoPlay: autoPlay,
@@ -1714,6 +1728,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       },
       { clearSignal: cancelSignal, emitCurrentValue: true },
     );
+    const textDisplayer = this._currentContentInfo.textDisplayer;
     const corePlaybackObserver = createCorePlaybackObserver(
       playbackObserver,
       {
@@ -1861,27 +1876,39 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    * playback.
    *
    * @param {Object} parameters
-   * @returns {boolean} - Returns `true` if all conditions where met for
-   * playback start.
    */
-  private _startPlaybackIfReady(parameters: {
-    mediaElement: IMediaElement;
-    textDisplayer: ITextDisplayer | null;
-    playbackObserver: IMediaElementPlaybackObserver;
-    drmInitializationStatus: IReadOnlySharedReference<IDrmInitializationStatus>;
-    mediaSourceStatus: IReadOnlySharedReference<MediaSourceInitializationStatus>;
-    streamEventsEmitter: StreamEventsEmitter;
-  }): boolean {
+  private _startPlaybackIfReady(parameters: IStartPlaybackParams) {
     if (this._currentContentInfo === null || this._currentContentInfo.manifest === null) {
-      return false;
+      return;
     }
-    const drmInitStatus = parameters.drmInitializationStatus.getValue();
-    if (drmInitStatus.initializationState.type !== "initialized") {
-      return false;
+    if (this._isPlaybackReady) {
+      return;
     }
-    const msInitStatus = parameters.mediaSourceStatus.getValue();
-    if (msInitStatus !== MediaSourceInitializationStatus.Attached) {
-      return false;
+    this._isPlaybackReady = true;
+
+    /**
+     * `true` when an `HTMLMediaElement` is available for playback.
+     * In that case we check that other preconditions are filled: DRM
+     * initialization is done, the `MediaSource` is attached etc., before
+     * actually loading the content.
+     *
+     * `false` when the `HTMLMediaElement` is not yet available.
+     * In that case we will just load media segments in memory, where those
+     * pre-conditions are not needed.
+     */
+    const hasMediaElement = parameters.playbackObserver.getMediaElement() !== null;
+
+    let drmSystemId: string | undefined;
+    if (hasMediaElement) {
+      const drmInitStatus = parameters.drmInitializationStatus.getValue();
+      if (drmInitStatus.initializationState.type === "uninitialized") {
+        return false;
+      }
+      drmSystemId = drmInitStatus.drmSystemId;
+      const msInitStatus = parameters.mediaSourceStatus.getValue();
+      if (msInitStatus !== MediaSourceInitializationStatus.Attached) {
+        return false;
+      }
     }
 
     const { contentId, manifest } = this._currentContentInfo;
@@ -1897,8 +1924,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       {
         initialTime,
         autoPlay: this._settings.autoPlay,
-        mediaElement: parameters.mediaElement,
-        textDisplayer: parameters.textDisplayer,
         playbackObserver: parameters.playbackObserver,
         streamEventsEmitter: parameters.streamEventsEmitter,
       },
@@ -1918,9 +1943,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       value: {
         initialTime,
         initialObservation: sentInitialObservation,
-        drmSystemId: drmInitStatus.drmSystemId,
+        drmSystemId,
         enableFastSwitching,
         onCodecSwitch,
+        hasMediaElement,
       },
     });
 
@@ -2070,6 +2096,8 @@ export interface IMediaSourceContentInitializerContentInfos {
    * `null` if none is currently created for the content.
    */
   rebufferingController: RebufferingController | null;
+  /** Text displayer prepared for this content, if text tracks are supported. */
+  textDisplayer: ITextDisplayer | null;
   /**
    * The initial position to seek to in seconds once the content is loadeed.
    * `undefined` if unknown yet.
@@ -2362,6 +2390,7 @@ type IDecryptionInitializationState =
    * `HTMLMediaElement` (such as linking a content / `MediaSource` to it).
    */
   | { type: "uninitialized"; value: null }
+  | { type: "skipped"; value: null }
   /**
    * The `MediaSource` or media url can be linked AND segments can be pushed to
    * the `HTMLMediaElement` on which decryption capabilities were wanted.
@@ -2406,3 +2435,11 @@ function formatSentLogObject(arg: ISentLogValue): IAcceptedLogValue {
   }
   return arg as Exclude<ISentLogValue, ISentError>;
 }
+
+interface IStartPlaybackParams {
+  textDisplayer: ITextDisplayer | null;
+  playbackObserver: IMediaElementPlaybackObserver;
+  drmInitializationStatus: IReadOnlySharedReference<IDrmInitializationStatus>;
+  mediaSourceStatus: IReadOnlySharedReference<MediaSourceInitializationStatus>;
+  streamEventsEmitter: StreamEventsEmitter;
+}
diff --git a/src/main_thread/init/types.ts b/src/main_thread/init/types.ts
index 0b98d215cb..03d5889e93 100644
--- a/src/main_thread/init/types.ts
+++ b/src/main_thread/init/types.ts
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types.ts";
 import type { ISegmentSinkMetrics } from "../../core/segment_sinks/segment_sinks_store.ts";
 import type { IBufferType, IAdaptationChoice, IInbandEvent } from "../../core/types.ts";
 import type {
@@ -69,21 +68,11 @@ export abstract class ContentInitializer extends EventEmitter<IContentInitialize
    * phase before `start` is called (the `ContentInitializer` should stay
    * resilient in both scenarios).
    *
-   * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which the
-   * content will play. This is given to `start` (and not sooner) to ensure
-   * that no prior step influence the `HTMLMediaElement`, on which a previous
-   * content could have been playing until then.
-   *
-   * If a content was already playing on that `HTMLMediaElement`, it will be
-   * stopped.
-   * @param {Object} playbackObserver - Interface allowing to poll playback
-   * information on what's playing on the `HTMLMediaElement` at regular
-   * intervals.
+   * @param {Object} playbackObserver - Interface allowing to interact with
+   * the media element on the page, most notably to poll playback information
+   * on what's playing on the `HTMLMediaElement` at regular intervals.
    */
-  public abstract start(
-    mediaElement: IMediaElement,
-    playbackObserver: IMediaElementPlaybackObserver,
-  ): void;
+  public abstract start(playbackObserver: IMediaElementPlaybackObserver): void;
 
   /**
    * Update URL of the content currently being played (e.g. DASH's MPD).
diff --git a/src/main_thread/init/utils/initial_seek_and_play.ts b/src/main_thread/init/utils/initial_seek_and_play.ts
index d00fe5b88f..636283c8ee 100644
--- a/src/main_thread/init/utils/initial_seek_and_play.ts
+++ b/src/main_thread/init/utils/initial_seek_and_play.ts
@@ -62,14 +62,12 @@ export interface IInitialSeekAndPlayObject {
  */
 export default function performInitialSeekAndPlay(
   {
-    mediaElement,
     playbackObserver,
     startTime,
     mustAutoPlay,
     isDirectfile,
     onWarning,
   }: {
-    mediaElement: IMediaElement;
     playbackObserver: IMediaElementPlaybackObserver;
     startTime: number | (() => number | undefined);
     mustAutoPlay: boolean;
@@ -178,6 +176,10 @@ export default function performInitialSeekAndPlay(
         let hasStartedSeeking = false;
         playbackObserver.listen(
           (obs, stopListening) => {
+            const mediaElement = playbackObserver.getMediaElement();
+            if (mediaElement === null) {
+              return; // Not linked to an HTMLMediaElement yet
+            }
             if (
               !hasStartedSeeking &&
               (obs.seeking !== SeekingState.None ||
@@ -201,7 +203,7 @@ export default function performInitialSeekAndPlay(
             if (cancelSignal.isCancelled()) {
               return;
             }
-            waitForPlayable();
+            waitForPlayable(mediaElement);
           },
           { includeLastObservation: false, clearSignal: cancelSignal },
         );
@@ -214,7 +216,7 @@ export default function performInitialSeekAndPlay(
        * if asked. Potentially send warning if a minor issue has been detected while
        * doing so.
        */
-      function waitForPlayable() {
+      function waitForPlayable(mediaElement: IMediaElement) {
         playbackObserver.listen(
           (observation, stopListening) => {
             if (
@@ -223,7 +225,7 @@ export default function performInitialSeekAndPlay(
               observation.readyState >= 1
             ) {
               stopListening();
-              onPlayable();
+              onPlayable(mediaElement);
             }
           },
           { includeLastObservation: true, clearSignal: cancelSignal },
@@ -237,7 +239,7 @@ export default function performInitialSeekAndPlay(
        * Promise when done.
        * Might also send warnings if minor issues arise.
        */
-      function onPlayable() {
+      function onPlayable(mediaElement: IMediaElement) {
         log.info("Init", "Can begin to play content");
         if (!mustAutoPlay) {
           if (mediaElement.autoplay) {
diff --git a/src/main_thread/init/utils/initialize_content_decryption.ts b/src/main_thread/init/utils/initialize_content_decryption.ts
index 62e006440c..4e1df10ca1 100644
--- a/src/main_thread/init/utils/initialize_content_decryption.ts
+++ b/src/main_thread/init/utils/initialize_content_decryption.ts
@@ -21,8 +21,8 @@ import type { IProcessedProtectionData } from "../../decrypt/index.ts";
  * "`initialized`" state and the `onError` callback will be triggered as soon
  * as protection information is received.
  *
- * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which content
- * decryption may be wanted.
+ * @param {HTMLMediaElement|null} mediaElement - `HTMLMediaElement` on which
+ * content decryption may be wanted.
  * @param {Array.<Object>} keySystems - Key system configuration(s) wanted
  * Empty array if no content decryption capability is wanted.
  * protection initialization data will be sent through.
@@ -34,7 +34,7 @@ import type { IProcessedProtectionData } from "../../decrypt/index.ts";
  * initialization.
  */
 export default function initializeContentDecryption(
-  mediaElement: IMediaElement,
+  mediaElement: IMediaElement | null,
   keySystems: IKeySystemOption[],
   callbacks: {
     onWarning: (err: IPlayerError) => void;
@@ -64,6 +64,9 @@ export default function initializeContentDecryption(
     return createEmeDisabledReference("No `keySystems` option given.");
   } else if (features.decrypt === null) {
     return createEmeDisabledReference("EME feature not activated.");
+  } else if (mediaElement === null) {
+    // XXX TODO store through `protectionRef` instead?
+    return createEmeDisabledReference("Preloading does not allow DRM for now");
   }
 
   const decryptorCanceller = new TaskCanceller("Init: Decryption Capabilities");
diff --git a/src/main_thread/init/utils/rebuffering_controller.ts b/src/main_thread/init/utils/rebuffering_controller.ts
index 4c08f27937..4080c893c1 100644
--- a/src/main_thread/init/utils/rebuffering_controller.ts
+++ b/src/main_thread/init/utils/rebuffering_controller.ts
@@ -183,7 +183,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
          */
         const targetTime = observation.position.isAwaitingFuturePosition()
           ? observation.position.getWanted()
-          : this._playbackObserver.getCurrentTime();
+          : (this._playbackObserver.getCurrentTime() ?? observation.position.getPolled());
 
         if (
           stalledPosition !== null &&
diff --git a/src/main_thread/text_displayer/html/html_text_displayer.ts b/src/main_thread/text_displayer/html/html_text_displayer.ts
index 9f6ce37c89..359dd61102 100644
--- a/src/main_thread/text_displayer/html/html_text_displayer.ts
+++ b/src/main_thread/text_displayer/html/html_text_displayer.ts
@@ -59,13 +59,13 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * The video element the cues refer to.
    * Used to know when the user is seeking, for example.
    */
-  private readonly _videoElement: IMediaElement;
+  private _videoElement: IMediaElement | null;
 
   /** Allows to cancel the interval at which subtitles are updated. */
   private _subtitlesIntervalCanceller: TaskCanceller;
 
   /** HTMLElement which will contain the cues */
-  private readonly _textTrackElement: HTMLElement;
+  private readonly _textTrackElement: HTMLElement | null;
 
   /** Buffer containing the data */
   private readonly _buffer: TextTrackCuesStore;
@@ -101,14 +101,13 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
   private _isAutoRefreshing: boolean;
 
   /**
-   * @param {HTMLMediaElement} videoElement
+   * @param {HTMLMediaElement|null} videoElement
    * @param {HTMLElement} textTrackElement
    */
-  constructor(videoElement: IMediaElement, textTrackElement: HTMLElement) {
+  constructor(videoElement: IMediaElement | null, textTrackElement: HTMLElement) {
     log.debug("text", "Creating HTMLTextDisplayer");
     this._buffered = new ManualTimeRanges();
 
-    this._videoElement = videoElement;
     this._textTrackElement = textTrackElement;
     this._sizeUpdateCanceller = new TaskCanceller("HTMLTextDisplayer size updates");
     this._subtitlesIntervalCanceller = new TaskCanceller(
@@ -117,6 +116,22 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
     this._buffer = new TextTrackCuesStore();
     this._currentCues = [];
     this._isAutoRefreshing = false;
+    this._videoElement = null;
+    if (videoElement !== null) {
+      this.attachMediaElement(videoElement);
+    }
+  }
+
+  public attachMediaElement(videoElement: IMediaElement): void {
+    this._disableCurrentCues("Attaching Media Element to HTMLTextDisplayer");
+    this._isAutoRefreshing = false;
+    this._subtitlesIntervalCanceller.cancel(
+      "Attaching Media Element to HTMLTextDisplayer",
+    );
+    this._videoElement = videoElement;
+    if (!this._isAutoRefreshing && !this._buffer.isEmpty()) {
+      this.autoRefreshSubtitles(this._subtitlesIntervalCanceller.signal);
+    }
   }
 
   /**
@@ -275,6 +290,9 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * Used for debugging matters, especially for debug log inspection.
    */
   private _disableCurrentCues(reason: string): void {
+    if (this._textTrackElement === null) {
+      return;
+    }
     this._sizeUpdateCanceller.cancel(reason);
     if (this._currentCues.length > 0) {
       for (const cue of this._currentCues) {
@@ -289,6 +307,9 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * @param {HTMLElement} elements
    */
   private _displayCues(elements: HTMLElement[]): void {
+    if (this._textTrackElement === null) {
+      return;
+    }
     const nothingChanged =
       this._currentCues.length === elements.length &&
       this._currentCues.every((current, index) => current.element === elements[index]);
@@ -352,7 +373,11 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * @param {Object} cancellationSignal
    */
   private autoRefreshSubtitles(cancellationSignal: CancellationSignal): void {
-    if (this._isAutoRefreshing || cancellationSignal.isCancelled()) {
+    if (
+      this._isAutoRefreshing ||
+      this._videoElement === null ||
+      cancellationSignal.isCancelled()
+    ) {
       return;
     }
     let autoRefreshCanceller: TaskCanceller | null = null;
@@ -401,6 +426,9 @@ export default class HTMLTextDisplayer implements ITextDisplayer {
    * position.
    */
   private refreshSubtitles(): void {
+    if (this._videoElement === null) {
+      return;
+    }
     const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
     let time;
     if (this._videoElement.paused || this._videoElement.playbackRate <= 0) {
diff --git a/src/main_thread/text_displayer/native/native_text_displayer.ts b/src/main_thread/text_displayer/native/native_text_displayer.ts
index c7d892a750..b7a9a42866 100644
--- a/src/main_thread/text_displayer/native/native_text_displayer.ts
+++ b/src/main_thread/text_displayer/native/native_text_displayer.ts
@@ -1,6 +1,7 @@
 import addTextTrack from "../../../compat/add_text_track.ts";
 import type {
   ICompatTextTrack,
+  ICompatVTTCue,
   IMediaElement,
 } from "../../../compat/browser_compatibility_types.ts";
 import removeCue from "../../../compat/remove_cue.ts";
@@ -19,22 +20,38 @@ import parseTextTrackToCues from "./native_parsers.ts";
  * @class NativeTextDisplayer
  */
 export default class NativeTextDisplayer implements ITextDisplayer {
-  private readonly _videoElement: IMediaElement;
-  private readonly _track: ICompatTextTrack;
-  private readonly _trackElement: HTMLTrackElement | undefined;
-
+  private _videoElement: IMediaElement | null;
+  private _track: ICompatTextTrack | null;
+  private _trackElement: HTMLTrackElement | undefined;
   private _buffered: ManualTimeRanges;
 
+  private _cueBuffer: Array<ICompatVTTCue | TextTrackCue>;
+
   /**
    * @param {HTMLMediaElement} videoElement
    */
-  constructor(videoElement: IMediaElement) {
+  constructor(videoElement: IMediaElement | null) {
     log.debug("text", "Creating NativeTextDisplayer");
-    const { track, trackElement } = addTextTrack(videoElement);
+    this._track = null;
+    this._trackElement = undefined;
     this._buffered = new ManualTimeRanges();
+    this._cueBuffer = [];
+    this._videoElement = null;
+    if (videoElement !== null) {
+      this.attachMediaElement(videoElement);
+    }
+  }
+
+  public attachMediaElement(videoElement: IMediaElement): void {
+    this._clearTrackElement();
     this._videoElement = videoElement;
+    const { track, trackElement } = addTextTrack(videoElement);
     this._track = track;
     this._trackElement = trackElement;
+    for (let i = 0; i < this._cueBuffer.length; i++) {
+      this._track.addCue(this._cueBuffer[i]);
+    }
+    this._cueBuffer.length = 0;
   }
 
   /**
@@ -134,15 +151,19 @@ export default class NativeTextDisplayer implements ITextDisplayer {
       // ones are in the past. this is supposed to fix an issue on
       // IE/Edge.
       // TODO Move to compat
-      const currentCues = this._track.cues;
+      const currentCues = this._track?.cues ?? this._cueBuffer;
       if (currentCues !== null && currentCues.length > 0) {
         if (firstCue.startTime < currentCues[currentCues.length - 1].startTime) {
           this._removeData(firstCue.startTime, +Infinity);
         }
       }
 
-      for (const cue of cues) {
-        this._track.addCue(cue);
+      if (this._track === null) {
+        this._cueBuffer.push(...cues);
+      } else {
+        for (const cue of cues) {
+          this._track.addCue(cue);
+        }
       }
     }
     this._buffered.insert(start, end);
@@ -179,7 +200,11 @@ export default class NativeTextDisplayer implements ITextDisplayer {
     this._removeData(0, Infinity);
     const { _trackElement, _videoElement } = this;
 
-    if (_trackElement !== undefined && _videoElement.hasChildNodes()) {
+    if (
+      _videoElement !== null &&
+      _trackElement !== undefined &&
+      _videoElement.hasChildNodes()
+    ) {
       try {
         _videoElement.removeChild(_trackElement);
       } catch (_e) {
@@ -187,7 +212,9 @@ export default class NativeTextDisplayer implements ITextDisplayer {
       }
     }
 
-    this._track.mode = "disabled";
+    if (this._track !== null) {
+      this._track.mode = "disabled";
+    }
 
     if (this._trackElement !== undefined) {
       this._trackElement.innerHTML = "";
@@ -196,14 +223,17 @@ export default class NativeTextDisplayer implements ITextDisplayer {
 
   private _removeData(start: number, end: number): void {
     log.debug("text", "Removing native text track data", { start, end });
-    const track = this._track;
-    const cues = track.cues;
+    const cues = this._track?.cues ?? this._cueBuffer;
     if (cues !== null) {
       for (let i = cues.length - 1; i >= 0; i--) {
         const cue = cues[i];
         const { startTime, endTime } = cue;
         if (startTime >= start && startTime <= end && endTime <= end) {
-          removeCue(track, cue);
+          if (this._track !== null) {
+            removeCue(this._track, cue);
+          } else {
+            this._cueBuffer.splice(i, 1);
+          }
         }
       }
     }
@@ -213,7 +243,11 @@ export default class NativeTextDisplayer implements ITextDisplayer {
   private _clearTrackElement(): void {
     const { _trackElement, _videoElement } = this;
 
-    if (_trackElement !== undefined && _videoElement.hasChildNodes()) {
+    if (
+      _videoElement !== null &&
+      _trackElement !== undefined &&
+      _videoElement.hasChildNodes()
+    ) {
       try {
         _videoElement.removeChild(_trackElement);
       } catch (_e) {
@@ -222,9 +256,11 @@ export default class NativeTextDisplayer implements ITextDisplayer {
     }
 
     // Ugly trick to work-around browser bugs by refreshing its mode
-    const oldMode = this._track.mode;
-    this._track.mode = "disabled";
-    this._track.mode = oldMode;
+    if (this._track !== null) {
+      const oldMode = this._track.mode;
+      this._track.mode = "disabled";
+      this._track.mode = oldMode;
+    }
 
     if (this._trackElement !== undefined) {
       this._trackElement.innerHTML = "";
diff --git a/src/main_thread/text_displayer/types.ts b/src/main_thread/text_displayer/types.ts
index f9359e963a..f56ea6e9ce 100644
--- a/src/main_thread/text_displayer/types.ts
+++ b/src/main_thread/text_displayer/types.ts
@@ -1,3 +1,4 @@
+import type { IMediaElement } from "../../compat/browser_compatibility_types.ts";
 import type { ITextTrackSegmentData } from "../../transports/index.ts";
 import type { IRange } from "../../utils/ranges.ts";
 
@@ -11,6 +12,8 @@ export interface ITextDisplayer {
    */
   reset(): void;
 
+  attachMediaElement(videoElement: IMediaElement): void;
+
   /**
    * Add timed text media data to the displayer so it can later be displayed at
    * the right time.
diff --git a/src/main_thread/types.ts b/src/main_thread/types.ts
index d64d920779..364ebc0f85 100644
--- a/src/main_thread/types.ts
+++ b/src/main_thread/types.ts
@@ -257,11 +257,50 @@ export interface IStartPreparedContentMessageValue {
   /** Behavior when a new video and/or audio codec is encountered. */
   onCodecSwitch: "continue" | "reload";
 
+  /**
+   * If `true` the `HTMLMediaElement` is already ready to play that content.
+   * As such a `MediaSource` can be created and linked to it right away.
+   *
+   * If `false`, the content should start to be loaded, but the
+   * `HTMLMediaElement` is not yet available. As such, loaded data should be
+   * stored temporarily in-JavaScript and no `MediaSource` should be created
+   * yet until an `IMediaElementReadyMessage`  is sent for the same
+   * `contentId`.
+   *
+   * The most likely use-case for it being set to `false` is to enable
+   * content-preloading.
+   */
+  hasMediaElement: boolean;
+
   // TODO prepare chosen Adaptations here?
   // In which case the Period's `id` should probably be given instead of the
   // `initialTime`
 }
 
+/**
+ * Message sent by the main thread in the case where a content previously
+ * started through an `IStartPreparedContentMessage` message had not yet
+ * the `HTMLMediaElement` available for playback.
+ *
+ * This message indicates that the `HTMLMediaElement` is now available for
+ * playing this content.
+ * As such, a `MediaSource` should now be created and linked to the
+ * HTMLMediaElement, `SourceBuffer` objects for the right data types should
+ * then be linked to that `MediaSource` and if media segments have already been
+ * loaded in-memory, they should now be migrated to those `SourceBuffer`.
+ */
+export interface IMediaElementReadyMessage {
+  type: MainThreadMessageType.MediaElementReady;
+  /**
+   * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
+   *
+   * Allows to ensure no race condition lead to starting another content than
+   * the one meant by the main thread.
+   */
+  contentId: string;
+  value: null;
+}
+
 /**
  * Message sent by the main thread when it has updated its list of supported
  * codecs and has reasons to think that the Core is not aware of it
@@ -632,6 +671,7 @@ export const enum MainThreadMessageType {
   SourceBufferError = "sb-error",
   SourceBufferSuccess = "sb-success",
   StartPreparedContent = "start",
+  MediaElementReady = "media-element-ready",
   StopContent = "stop",
   TrackUpdate = "track-update",
   PullSegmentSinkStoreInfos = "pull-segment-sink-store-infos",
@@ -646,6 +686,7 @@ export type IMainThreadMessage =
   | IPrepareContentMessage
   | IStopContentMessage
   | IStartPreparedContentMessage
+  | IMediaElementReadyMessage
   | IReferenceUpdateMessage
   | ICodecSupportUpdateMessage
   | IPlaybackObservationMessage
diff --git a/src/mse/main_media_source_interface.ts b/src/mse/main_media_source_interface.ts
index 168a901174..da8ce2be13 100644
--- a/src/mse/main_media_source_interface.ts
+++ b/src/mse/main_media_source_interface.ts
@@ -275,7 +275,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
   }
 
   /** @see ISourceBufferInterface */
-  public getBuffered(): IRange[] {
+  public getBuffered(): IRange[] | undefined {
     try {
       return convertToRanges(this._sourceBuffer.buffered);
     } catch (err) {
@@ -313,6 +313,7 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
       // we don't care
     }
     this._emptyCurrentQueue(reason);
+    this._canceller.cancel(reason);
   }
 
   private _onError(evt: Event) {
diff --git a/src/mse/types.ts b/src/mse/types.ts
index 1abe51f663..03f69f5482 100644
--- a/src/mse/types.ts
+++ b/src/mse/types.ts
@@ -67,7 +67,7 @@ export interface ISourceBufferInterface {
   appendBuffer(
     data: BufferSource,
     params: ISourceBufferInterfaceAppendBufferParameters,
-  ): Promise<IRange[]>;
+  ): Promise<IRange[] | undefined>;
   /**
    * Remove media data present between the given start time in seconds and the
    * given end time in seconds.
@@ -88,7 +88,7 @@ export interface ISourceBufferInterface {
    * @param {number} end
    * @returns {Promise.<Array.<Object>>}
    */
-  remove(start: number, end: number): Promise<IRange[]>;
+  remove(start: number, end: number): Promise<IRange[] | undefined>;
   /**
    * Abort all operations pending on the `SourceBuffer`.
    * @param {string | undefined} reason - Human-inspectable reason behind the
@@ -199,9 +199,17 @@ export interface IMediaSourceInterface extends EventEmitter<IMediaSourceInterfac
   /**
    * Mean to link the underlying `MediaSource` to an `HTMLMediaElement`.
    *
-   * `undefined` if this `IMediaSourceInterface` cannot rely on MSE API
-   * directly to create a `MediaSource`, in which case it will have sent
-   * message by itself to the main thread for MediaSource creation.
+   * `undefined` if either:
+   *
+   *   - This `IMediaSourceInterface` cannot rely on MSE API directly to create
+   *     a `MediaSource`, in which case it will have sent message by itself to
+   *     the main thread for MediaSource creation.
+   *
+   *   - This `IMediaSourceInterface` does not rely for now on an actual
+   *     `MediaSource` instance as it is only preloading content.
+   *
+   * In both cases, data can still be buffered as usual on its underlying
+   * `SourceBufferInterface` instances.
    */
   handle: IMediaSourceHandle | undefined;
 
diff --git a/src/playback_observer/media_element_playback_observer.ts b/src/playback_observer/media_element_playback_observer.ts
index 9ab5251b9c..f8680c687f 100644
--- a/src/playback_observer/media_element_playback_observer.ts
+++ b/src/playback_observer/media_element_playback_observer.ts
@@ -171,6 +171,59 @@ export default class PlaybackObserver {
     });
   }
 
+  /**
+   * Get direct access to the `HTMLMediaElement`.
+   * `null` if no `HTMLMediaElement` has yet been "attached" to that
+   * `MediaElementPlaybackObserver`.
+   * @returns {HTMLMediaElement|null}
+   */
+  getMediaElement(): IMediaElement | null {
+    return this._mediaElementRef.getValue();
+  }
+
+  onMediaElementAttachment(
+    cb: (mediaElement: IMediaElement) => void,
+    cancelSignal: CancellationSignal,
+  ) {
+    if (cancelSignal.isCancelled()) {
+      return;
+    }
+    const mediaElement = this._mediaElementRef.getValue();
+    if (mediaElement !== null) {
+      try {
+        cb(mediaElement);
+      } catch (err) {
+        log.error(
+          "API",
+          "onMediaElementAttachment error",
+          err instanceof Error ? err : "Unknown Error",
+        );
+      }
+    } else {
+      this._mediaElementRef.onUpdate(
+        (lastMediaElement, stopListening) => {
+          if (lastMediaElement === null) {
+            return;
+          }
+          stopListening();
+          try {
+            cb(lastMediaElement);
+          } catch (err) {
+            log.error(
+              "API",
+              "onMediaElementAttachment error",
+              err instanceof Error ? err : "Unknown Error",
+            );
+          }
+        },
+        {
+          clearSignal: cancelSignal,
+          emitCurrentValue: false,
+        },
+      );
+    }
+  }
+
   /**
    * "Link" the actual `HTMLMediaElement` to this `PlaybackObserver`.
    *
diff --git a/src/playback_observer/types.ts b/src/playback_observer/types.ts
index 7be20eb875..7acc3688af 100644
--- a/src/playback_observer/types.ts
+++ b/src/playback_observer/types.ts
@@ -166,7 +166,8 @@ export interface IReadOnlyPlaybackObserver<TObservationType> {
   /**
    * Get the current playing position, in seconds.
    * Returns `undefined` when this cannot be known, such as when the playback
-   * observer is running in a WebWorker.
+   * observer is running in a WebWorker or when an `HTMLMediaElement` is not
+   * yet attached to the PlaybackObserver.
    * @returns {number|undefined}
    */
   getCurrentTime(): number | undefined;
diff --git a/tests/unit/mocks/playback_observer.ts b/tests/unit/mocks/playback_observer.ts
index 66a9fb4f6f..9b774eeb6b 100644
--- a/tests/unit/mocks/playback_observer.ts
+++ b/tests/unit/mocks/playback_observer.ts
@@ -16,6 +16,7 @@ export const DummyMediaElementPlaybackObserver =
       attachMediaElement: notImplemented("attachMediaElement"),
       getCurrentTime: notImplemented("getCurrentTime"),
       getIsPaused: notImplemented("getIsPaused"),
+      getMediaElement: notImplemented("getMediaElement"),
       getPendingSeekInformation: notImplemented("getPendingSeekInformation"),
       getPlaybackRate: notImplemented("getPlaybackRate"),
       getReadyState: notImplemented("getReadyState"),
@@ -27,6 +28,7 @@ export const DummyMediaElementPlaybackObserver =
       setCurrentTime: notImplemented("setCurrentTime"),
       setPlaybackRate: notImplemented("setPlaybackRate"),
       listen: notImplemented("listen"),
+      onMediaElementAttachment: notImplemented("onMediaElementAttachment"),
       deriveReadOnlyObserver: notImplemented("deriveReadOnlyObserver"),
     },
     {},
diff --git a/tests/unit/src/core/stream/adaptation/adaptation_stream.test.ts b/tests/unit/src/core/stream/adaptation/adaptation_stream.test.ts
index e89236b37a..caf5259606 100644
--- a/tests/unit/src/core/stream/adaptation/adaptation_stream.test.ts
+++ b/tests/unit/src/core/stream/adaptation/adaptation_stream.test.ts
@@ -692,7 +692,10 @@ describe("AdaptationStream", () => {
 
     streamCallbacks?.addedSegment(payload);
 
-    expect(addedSegment).toHaveBeenCalledWith(payload);
+    expect(addedSegment).toHaveBeenCalledWith({
+      buffered: payload.buffered,
+      content: payload.content,
+    });
   });
 
   it("should forward non-buffer-full errors to the adaptation callbacks", () => {
diff --git a/tests/unit/src/core/stream/orchestrator/stream_orchestrator.test.ts b/tests/unit/src/core/stream/orchestrator/stream_orchestrator.test.ts
index 1d5354b4fb..10a24cbf60 100644
--- a/tests/unit/src/core/stream/orchestrator/stream_orchestrator.test.ts
+++ b/tests/unit/src/core/stream/orchestrator/stream_orchestrator.test.ts
@@ -74,7 +74,9 @@ vi.mock("../../../../../../src/utils/queue_microtask", () => ({
 
 const DummySegmentSinksStore = makeMockedClass<SegmentSinksStore>(
   {
+    attachOpenedMediaSource: notImplemented("attachOpenedMediaSource"),
     getBufferTypes: notImplemented("getBufferTypes"),
+    getMediaSourceInterface: notImplemented("getMediaSourceInterface"),
     getNativeBufferTypes: notImplemented("getNativeBufferTypes"),
     getStatus: notImplemented("getStatus"),
     waitForUsableBuffers: notImplemented("waitForUsableBuffers"),
diff --git a/tests/unit/src/main_thread/render_thumbnail.test.ts b/tests/unit/src/main_thread/render_thumbnail.test.ts
index bcd2c46f11..3e38505a48 100644
--- a/tests/unit/src/main_thread/render_thumbnail.test.ts
+++ b/tests/unit/src/main_thread/render_thumbnail.test.ts
@@ -147,6 +147,7 @@ function createContentInfos(
     },
     initializer: {} as IPublicApiContentInfos["initializer"],
     isDirectFile: false,
+    isPreload: false,
     mediaElementTracksStore: null,
     onAudioTracksNotPlayable: "continue",
     onVideoTracksNotPlayable: "continue",