fix(core): don't tear the runtime down on a bfcache pagehide

`pagehide` also fires with persisted === true when the document is frozen
into the back-forward cache. That is not a death: `pageshow` restores the
same document without re-running initialization. Tearing down there
latched state.tornDown, stripped the listeners and injected styles, and
closed the AudioContext — leaving a restored player permanently inert with
nothing to bring it back.

The destructive path is now gated to non-persisted page hides — the
srcdoc-replacement case the listener was added for. A BFCached document is
frozen by the browser, which suspends its AudioContext and media anyway,
so skipping teardown while it sits there costs nothing, and the listener
stays armed for the eventual real hide.

Author: I-bangash

packages/core/src/runtime/init.test.ts

@@ -652,6 +652,52 @@ describe("initSandboxRuntimeModular", () => {
     expect(injectedLink?.isConnected).toBe(false);
   });
 
+  describe("pagehide teardown", () => {
+    async function initMinimalRuntime(): Promise<void> {
+      const root = document.createElement("div");
+      root.setAttribute("data-composition-id", "main");
+      root.setAttribute("data-root", "true");
+      root.setAttribute("data-start", "0");
+      root.setAttribute("data-width", "1920");
+      root.setAttribute("data-height", "1080");
+      document.body.appendChild(root);
+      window.__timelines = { main: createMockTimeline(3) };
+      initSandboxRuntimeModular();
+      await new Promise<void>((resolve) => window.setTimeout(resolve, 0));
+    }
+
+    function firePageHide(persisted: boolean): void {
+      const event = new Event("pagehide");
+      Object.defineProperty(event, "persisted", { value: persisted });
+      window.dispatchEvent(event);
+    }
+
+    it("tears down on a real page hide", async () => {
+      await initMinimalRuntime();
+      expect(window.__hfRuntimeTeardown).toBeTypeOf("function");
+
+      firePageHide(false);
+
+      expect(window.__hfRuntimeTeardown).toBeNull();
+    });
+
+    it("survives a bfcache page hide so a pageshow restore stays playable", async () => {
+      await initMinimalRuntime();
+
+      // persisted === true means the document is frozen into the back-forward
+      // cache, not destroyed — `pageshow` restores it WITHOUT re-running init,
+      // so a teardown here would leave the player permanently inert.
+      firePageHide(true);
+
+      expect(window.__hfRuntimeTeardown).toBeTypeOf("function");
+
+      // ...and the listener is still armed, so the eventual real hide still
+      // reclaims the AudioContext and decoded buffers.
+      firePageHide(false);
+      expect(window.__hfRuntimeTeardown).toBeNull();
+    });
+  });
+
   it("keeps compiled external composition hosts visible through their authored duration", async () => {
     const root = document.createElement("div");
     root.setAttribute("data-composition-id", "main");

packages/core/src/runtime/init.ts

@@ -3365,7 +3365,7 @@ export function initSandboxRuntimeModular(): void {
       window.removeEventListener("beforeunload", state.beforeUnloadHandler);
       state.beforeUnloadHandler = null;
     }
-    window.removeEventListener("pagehide", teardown);
+    window.removeEventListener("pagehide", handlePageHide);
     picker.disablePickMode();
     for (const adapter of state.deterministicAdapters) {
       if (!adapter || typeof adapter.revert !== "function") continue;
@@ -3417,15 +3417,27 @@ export function initSandboxRuntimeModular(): void {
       window.__hfRuntimeTeardown = null;
     }
   };
-  window.__hfRuntimeTeardown = teardown;
-  state.beforeUnloadHandler = teardown;
-  window.addEventListener("beforeunload", state.beforeUnloadHandler);
   // `pagehide` too: in an iframe whose document is replaced (an editor writing
   // a new `srcdoc` on every edit), pagehide is the dependable unload signal.
   // Without a teardown there, each discarded document keeps a live
   // AudioContext + decoded-buffer cache until GC gets around to it — under
   // rapid edits that transiently stacks hundreds of MB of PCM per reload.
   // teardown() is idempotent (state.tornDown), so double-firing with
   // beforeunload is harmless.
-  window.addEventListener("pagehide", teardown);
+  //
+  // But `pagehide` ALSO fires with `persisted: true` when the document enters
+  // the back-forward cache, and that is not a death — the very same document is
+  // restored by `pageshow` with no re-initialization. Tearing down there would
+  // leave the restored player permanently inert (tornDown latched, listeners and
+  // injected styles gone, AudioContext closed) with nothing to bring it back. A
+  // BFCached document is frozen by the browser, which suspends its AudioContext
+  // and media for us, so skipping teardown costs nothing while it sits there.
+  const handlePageHide = (event: PageTransitionEvent) => {
+    if (event.persisted) return;
+    teardown();
+  };
+  window.__hfRuntimeTeardown = teardown;
+  state.beforeUnloadHandler = teardown;
+  window.addEventListener("beforeunload", state.beforeUnloadHandler);
+  window.addEventListener("pagehide", handlePageHide);
 }