From ee4ced3e9212353d260284457096561e2956d7b6 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sat, 10 Oct 2026 23:11:27 -0700
Subject: [PATCH 1/9] fix(producer): export plays a split or trimmed scene's
 media from its in-point

A sub-composition host with a non-zero data-playback-start now shifts and cuts
the video and audio it holds in render, matching Studio preview. Hosts without
an in-point resolve exactly as before.
---
 .../src/services/renderMediaCollector.test.ts | 63 ++++++++++++++
 .../src/services/renderMediaCollector.ts      | 87 +++++++++++++++----
 2 files changed, 131 insertions(+), 19 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.test.ts b/packages/producer/src/services/renderMediaCollector.test.ts
index 1e2af711956..8425642ad95 100644
--- a/packages/producer/src/services/renderMediaCollector.test.ts
+++ b/packages/producer/src/services/renderMediaCollector.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { MEDIA_RENDER_ID_ATTR } from "@hyperframes/core";
+import { resolveTimelineExtractionWindow } from "@hyperframes/engine";
 import { collectRenderMedia } from "./renderMediaCollector.js";
 
 describe("collectRenderMedia host windows", () => {
@@ -96,3 +97,65 @@ describe("collectRenderMedia host windows", () => {
     expect(audios.find((audio) => audio.id === "global-audio")).toMatchObject({ start: 2, end: 8 });
   });
 });
+
+const media = (attrs: string) =>
+  `<video ${MEDIA_RENDER_ID_ATTR}="clip" id="clip" src="clip.mp4" ${attrs}></video>` +
+  `<audio ${MEDIA_RENDER_ID_ATTR}="vo" id="vo" src="vo.m4a" ${attrs}></audio>`;
+
+describe("collectRenderMedia in-point hosts", () => {
+  it("plays a head-trimmed scene's media from its in-point", () => {
+    const html =
+      `<div data-composition-id="scene" data-start="0" data-duration="12" data-playback-start="7">` +
+      media(`data-start="0" data-duration="19" data-end="19"`) +
+      `</div>`;
+
+    const { videos, audios } = collectRenderMedia(html);
+    const video = videos.find((v) => v.id === "clip")!;
+    // Local 0 sits 7 s before the root; the engine trims that preroll from the source.
+    expect(video).toMatchObject({ start: -7, end: 12, mediaStart: 0 });
+    expect(resolveTimelineExtractionWindow(video, video.end - video.start, 12)).toMatchObject({
+      compositionStart: 0,
+      mediaStart: 7,
+      durationSeconds: 12,
+    });
+    expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
+  });
+
+  it("cuts a split scene's media to the second half's slot", () => {
+    const html =
+      `<div data-composition-file="scene.html" data-composition-id="scene" data-start="5" data-duration="7" data-playback-start="5">` +
+      media(`data-start="0" data-duration="12" data-end="12" data-playback-start="1"`) +
+      `<audio ${MEDIA_RENDER_ID_ATTR}="early" id="early" src="early.m4a" data-start="1" data-duration="3" data-end="4"></audio>` +
+      `<video ${MEDIA_RENDER_ID_ATTR}="early-clip" id="early-clip" src="early.mp4" data-start="1" data-duration="3"></video>` +
+      `<audio ${MEDIA_RENDER_ID_ATTR}="fast" id="fast" src="fast.m4a" data-start="3" data-duration="20" data-end="23" data-playback-rate="2"></audio>` +
+      `</div>`;
+
+    const { videos, audios } = collectRenderMedia(html);
+    // Video keeps its origin: frames before the host's start are hidden with the host.
+    expect(videos.find((v) => v.id === "clip")).toMatchObject({ start: 0, end: 12, mediaStart: 1 });
+    expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 5, end: 12, mediaStart: 6 });
+    // Wholly before the in-point: never played.
+    expect(audios.find((a) => a.id === "early")).toBeUndefined();
+    expect(videos.find((v) => v.id === "early-clip")).toBeUndefined();
+    // Cut at the host's end, its 2 s head consumed at 2x.
+    expect(audios.find((a) => a.id === "fast")).toMatchObject({ start: 5, end: 12, mediaStart: 4 });
+  });
+
+  it("changes nothing for a host without an in-point", () => {
+    const scene = (inPoint: string) =>
+      `<div data-composition-id="inline" data-start="3" data-duration="4"${inPoint}>` +
+      media(`data-start="1" data-duration="9" data-end="10" data-playback-start="2"`) +
+      `</div>` +
+      `<div data-composition-file="scene.html" data-composition-id="scene" data-start="2" data-duration="6"${inPoint}>` +
+      `<video ${MEDIA_RENDER_ID_ATTR}="nested" id="nested" src="n.mp4" data-start="1" data-duration="9" data-has-audio="true"></video>` +
+      `</div>`;
+
+    const absent = collectRenderMedia(scene(""));
+    expect(collectRenderMedia(scene(` data-playback-start="0"`))).toEqual(absent);
+    expect(absent.audios.find((a) => a.id === "nested-audio")).toMatchObject({
+      start: 3,
+      end: 8,
+      mediaStart: 0,
+    });
+  });
+});
diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index c497280ce20..be97020f77c 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -15,9 +15,19 @@
  */
 
 import { parseHTML } from "linkedom";
-import { MEDIA_RENDER_ID_ATTR, resolveAuthoredTimingWindow } from "@hyperframes/core";
+import {
+  MEDIA_RENDER_ID_ATTR,
+  normalizeRateSpec,
+  resolveAuthoredTimingWindow,
+  shiftRateLane,
+  sourceTimeAt,
+} from "@hyperframes/core";
 import {
   MEDIA_START_BASIS_ATTR,
+  compositionOriginSeconds,
+  cutToHostSlots,
+  hostInPointSeconds,
+  type HostSlot,
   readMediaStartBasis,
   resolveAbsoluteMediaStartSeconds,
   type MediaStartBasis,
@@ -62,9 +72,27 @@ interface HostWindow {
   limit: number;
   /** Whether authored media time is composition-local or legacy root-global. */
   basis: MediaStartBasis;
+  /** Root-time slots of the enclosing hosts with an in-point. */
+  slots: HostSlot[];
 }
 
-const ROOT_WINDOW: HostWindow = { offset: 0, limit: Infinity, basis: "local" };
+const ROOT_WINDOW: HostWindow = { offset: 0, limit: Infinity, basis: "local", slots: [] };
+
+// Any composition host with an in-point counts, inline or anonymous, as in core's start resolver.
+const isInPointHost = (element: Element): boolean =>
+  element.matches("[data-composition-id], [data-composition-src]") &&
+  hostInPointSeconds(element) > 0;
+
+/** Composition hosts that place `element`, root first: inlined files, plus any host with an in-point. */
+function enclosingHosts(element: Element): Element[] {
+  const hosts: Element[] = [];
+  for (let ancestor = element.parentElement; ancestor; ancestor = ancestor.parentElement) {
+    if (ancestor.hasAttribute(COMPOSITION_HOST_ATTR) || isInPointHost(ancestor)) {
+      hosts.unshift(ancestor);
+    }
+  }
+  return hosts;
+}
 
 /**
  * Fold a media element's chain of composition hosts into one window.
@@ -82,20 +110,20 @@ function resolveHostWindow(
   startCache: Map<RefResolverEl, number>,
   visiting: Set<RefResolverEl>,
 ): HostWindow {
-  const hosts: Element[] = [];
-  for (let ancestor = element.parentElement; ancestor; ancestor = ancestor.parentElement) {
-    if (ancestor.hasAttribute(COMPOSITION_HOST_ATTR)) hosts.push(ancestor);
-  }
+  const hosts = enclosingHosts(element);
   if (hosts.length === 0) return ROOT_WINDOW;
 
   let offset = 0;
   let limit = Infinity;
-  // parentElement walks leaf → root; the offsets accumulate root → leaf.
-  for (const host of hosts.reverse()) {
+  const slots: HostSlot[] = [];
+  for (const host of hosts) {
     const hostStart = resolveReferencedStart(document, host, startCache, visiting);
     const hostEnd = resolveHostEnd(host, hostStart);
     if (hostEnd != null) limit = Math.min(limit, offset + hostEnd);
-    offset += hostStart;
+    if (hostInPointSeconds(host) > 0) {
+      slots.push({ start: offset + hostStart, end: offset + (hostEnd ?? Infinity) });
+    }
+    offset += compositionOriginSeconds(hostStart, host);
   }
   const tag = element.tagName.toLowerCase();
   const basis =
@@ -106,6 +134,7 @@ function resolveHostWindow(
     offset,
     limit,
     basis,
+    slots,
   };
 }
 
@@ -133,13 +162,14 @@ function collectHostWindows(html: string): Map<string, HostWindow> {
 /**
  * Shift a scene-relative window onto the root timeline.
  * Returns null when the clip starts after its host has already ended, matching
- * the `start < absoluteEnd` drop the file-tree walk applied.
+ * the `start < absoluteEnd` drop the file-tree walk applied, or when in-point hosts cut all of it.
+ * `start` stays the clip's origin; `played` is the part the in-point hosts' slots keep.
  */
 function toAbsoluteWindow(
   start: number,
   end: number,
   window: HostWindow,
-): { start: number; end: number } | null {
+): { start: number; end: number; played: { start: number; end: number } } | null {
   const absoluteStart = resolveAbsoluteMediaStartSeconds({
     authoredStart: start,
     hostStart: window.offset,
@@ -151,7 +181,24 @@ function toAbsoluteWindow(
     hostStart: window.offset,
     basis: window.basis,
   });
-  return { start: absoluteStart, end: Math.min(absoluteEnd, window.limit) };
+  const absolute = { start: absoluteStart, end: Math.min(absoluteEnd, window.limit) };
+  if (window.slots.length === 0) return { ...absolute, played: absolute };
+  const played = cutToHostSlots(absolute, window.slots);
+  if (played.end === played.start && absolute.end > absolute.start) return null;
+  return { start: absolute.start, end: played.end, played };
+}
+
+/** Start audio where its in-point hosts let it play, that much further into its source. */
+function startAtPlayed<T extends AudioElement>(audio: T, played: { start: number }): T {
+  const head = played.start - audio.start;
+  if (head <= 0) return audio;
+  const rate = normalizeRateSpec(audio.playbackRate);
+  return {
+    ...audio,
+    start: played.start,
+    mediaStart: audio.mediaStart + sourceTimeAt(rate, head),
+    playbackRate: shiftRateLane(rate, head),
+  };
 }
 
 export interface RenderMedia {
@@ -172,16 +219,17 @@ export function collectRenderMedia(html: string): RenderMedia {
   const windows = collectHostWindows(html);
   const windowFor = (id: string): HostWindow => windows.get(id) ?? ROOT_WINDOW;
 
+  // Pictures keep their origin: the engine trims a negative start, and the host hides them before its own.
   const videos: VideoElement[] = [];
   for (const video of parseVideoElements(html)) {
     const absolute = toAbsoluteWindow(video.start, video.end, windowFor(video.id));
-    if (absolute) videos.push({ ...video, ...absolute });
+    if (absolute) videos.push({ ...video, start: absolute.start, end: absolute.end });
   }
 
   const images: ImageElement[] = [];
   for (const image of parseImageElements(html)) {
     const absolute = toAbsoluteWindow(image.start, image.end, windowFor(image.id));
-    if (absolute) images.push({ ...image, ...absolute });
+    if (absolute) images.push({ ...image, start: absolute.start, end: absolute.end });
   }
 
   // A <video data-has-audio> track is reported as "<renderId>-audio"; strip the
@@ -194,11 +242,12 @@ export function collectRenderMedia(html: string): RenderMedia {
     const authoredEnd = audio.end > 0 ? audio.end : Infinity;
     const absolute = toAbsoluteWindow(audio.start, authoredEnd, windowFor(elementId));
     if (!absolute) continue;
-    audios.push({
-      ...audio,
-      start: absolute.start,
-      end: Number.isFinite(absolute.end) ? absolute.end : 0,
-    });
+    audios.push(
+      startAtPlayed(
+        { ...audio, start: absolute.start, end: Number.isFinite(absolute.end) ? absolute.end : 0 },
+        absolute.played,
+      ),
+    );
   }
 
   return { videos, audios, images };

From 8a149295c6b4b8a4378d58b40cb1926b833b0fa9 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 00:27:31 -0700
Subject: [PATCH 2/9] fix(producer): export finds in-point scenes in projects
 without scene files

Media in a document with no inlined composition files carry no render id, so
the collector never looked up their host and ignored an inline host's in-point.
Key host windows on the id the parsers report, and cut a video's head the same
way as audio so nothing plays before the host starts.
---
 .../src/services/renderMediaCollector.test.ts | 34 +++++++++++++++--
 .../src/services/renderMediaCollector.ts      | 38 ++++++++++++-------
 2 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.test.ts b/packages/producer/src/services/renderMediaCollector.test.ts
index 8425642ad95..95896115b99 100644
--- a/packages/producer/src/services/renderMediaCollector.test.ts
+++ b/packages/producer/src/services/renderMediaCollector.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { MEDIA_RENDER_ID_ATTR } from "@hyperframes/core";
 import { resolveTimelineExtractionWindow } from "@hyperframes/engine";
+import { compileForRender } from "./htmlCompiler.js";
 import { collectRenderMedia } from "./renderMediaCollector.js";
 
 describe("collectRenderMedia host windows", () => {
@@ -111,8 +115,7 @@ describe("collectRenderMedia in-point hosts", () => {
 
     const { videos, audios } = collectRenderMedia(html);
     const video = videos.find((v) => v.id === "clip")!;
-    // Local 0 sits 7 s before the root; the engine trims that preroll from the source.
-    expect(video).toMatchObject({ start: -7, end: 12, mediaStart: 0 });
+    expect(video).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
     expect(resolveTimelineExtractionWindow(video, video.end - video.start, 12)).toMatchObject({
       compositionStart: 0,
       mediaStart: 7,
@@ -121,6 +124,30 @@ describe("collectRenderMedia in-point hosts", () => {
     expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
   });
 
+  it("finds an inline in-point host in a compiled document with no sub-composition files", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "hf-inpoint-"));
+    try {
+      writeFileSync(
+        join(dir, "index.html"),
+        `<!doctype html><html><body>` +
+          `<div id="root" data-composition-id="main" data-start="0" data-duration="12" data-width="1280" data-height="720">` +
+          `<div id="scene" data-composition-id="scene" class="clip" data-start="0" data-duration="12" data-playback-start="7">` +
+          `<video id="clip" class="clip" src="clip.mp4" data-start="0" data-duration="19" muted></video>` +
+          `<audio id="vo" src="vo.m4a" data-start="0" data-duration="19"></audio>` +
+          `</div></div></body></html>`,
+      );
+      const { videos, audios } = await compileForRender(dir, join(dir, "index.html"), dir);
+      expect(videos.find((v) => v.id === "clip")).toMatchObject({
+        start: 0,
+        end: 12,
+        mediaStart: 7,
+      });
+      expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("cuts a split scene's media to the second half's slot", () => {
     const html =
       `<div data-composition-file="scene.html" data-composition-id="scene" data-start="5" data-duration="7" data-playback-start="5">` +
@@ -131,8 +158,7 @@ describe("collectRenderMedia in-point hosts", () => {
       `</div>`;
 
     const { videos, audios } = collectRenderMedia(html);
-    // Video keeps its origin: frames before the host's start are hidden with the host.
-    expect(videos.find((v) => v.id === "clip")).toMatchObject({ start: 0, end: 12, mediaStart: 1 });
+    expect(videos.find((v) => v.id === "clip")).toMatchObject({ start: 5, end: 12, mediaStart: 6 });
     expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 5, end: 12, mediaStart: 6 });
     // Wholly before the in-point: never played.
     expect(audios.find((a) => a.id === "early")).toBeUndefined();
diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index be97020f77c..1ffd43860ec 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -139,17 +139,19 @@ function resolveHostWindow(
 }
 
 /**
- * Map each render id to the window of the composition hosts it is nested in.
- * Keyed on the render id rather than document position so the caller never has
- * to assume two separate parses walk the document in the same order.
+ * Map each media id to the window of the composition hosts it is nested in.
+ * Keyed on the id the parsers report (render id, else author id: render ids are
+ * only stamped when files are inlined) rather than document position so the caller
+ * never has to assume two separate parses walk the document in the same order.
  */
 function collectHostWindows(html: string): Map<string, HostWindow> {
   const { document } = parseHTML(html);
   const windows = new Map<string, HostWindow>();
   const startCache = new Map<RefResolverEl, number>();
   const visiting = new Set<RefResolverEl>();
-  for (const element of document.querySelectorAll(`[${MEDIA_RENDER_ID_ATTR}]`)) {
-    const renderId = element.getAttribute(MEDIA_RENDER_ID_ATTR);
+  const media = `[${MEDIA_RENDER_ID_ATTR}], video[id], audio[id], img[id]`;
+  for (const element of document.querySelectorAll(media)) {
+    const renderId = element.getAttribute(MEDIA_RENDER_ID_ATTR) || element.getAttribute("id");
     if (!renderId) continue;
     windows.set(
       renderId,
@@ -188,15 +190,20 @@ function toAbsoluteWindow(
   return { start: absolute.start, end: played.end, played };
 }
 
-/** Start audio where its in-point hosts let it play, that much further into its source. */
-function startAtPlayed<T extends AudioElement>(audio: T, played: { start: number }): T {
-  const head = played.start - audio.start;
-  if (head <= 0) return audio;
-  const rate = normalizeRateSpec(audio.playbackRate);
+/** Start a clip where its in-point hosts let it play, that much further into its source. */
+function startAtPlayed<T extends AudioElement | VideoElement>(
+  clip: T,
+  played: { start: number },
+): T {
+  const head = played.start - clip.start;
+  // ponytail: a looping video keeps its origin (its loop runs from mediaStart), so a head cut
+  // after 0 is not applied to it; that needs a visible start separate from the origin in the engine.
+  if (head <= 0 || ("loop" in clip && clip.loop)) return clip;
+  const rate = normalizeRateSpec(clip.playbackRate);
   return {
-    ...audio,
+    ...clip,
     start: played.start,
-    mediaStart: audio.mediaStart + sourceTimeAt(rate, head),
+    mediaStart: clip.mediaStart + sourceTimeAt(rate, head),
     playbackRate: shiftRateLane(rate, head),
   };
 }
@@ -219,11 +226,14 @@ export function collectRenderMedia(html: string): RenderMedia {
   const windows = collectHostWindows(html);
   const windowFor = (id: string): HostWindow => windows.get(id) ?? ROOT_WINDOW;
 
-  // Pictures keep their origin: the engine trims a negative start, and the host hides them before its own.
   const videos: VideoElement[] = [];
   for (const video of parseVideoElements(html)) {
     const absolute = toAbsoluteWindow(video.start, video.end, windowFor(video.id));
-    if (absolute) videos.push({ ...video, start: absolute.start, end: absolute.end });
+    if (absolute) {
+      videos.push(
+        startAtPlayed({ ...video, start: absolute.start, end: absolute.end }, absolute.played),
+      );
+    }
   }
 
   const images: ImageElement[] = [];

From f5814587829bc9242329951d6be850b77e915bd9 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 00:47:36 -0700
Subject: [PATCH 3/9] refactor(producer): drop dead no-slot branch in media
 window and tighten comments

---
 .../src/services/renderMediaCollector.ts       | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index 1ffd43860ec..f9a23643af2 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -139,10 +139,8 @@ function resolveHostWindow(
 }
 
 /**
- * Map each media id to the window of the composition hosts it is nested in.
- * Keyed on the id the parsers report (render id, else author id: render ids are
- * only stamped when files are inlined) rather than document position so the caller
- * never has to assume two separate parses walk the document in the same order.
+ * Map each media id the parsers report (render id, else author id: render ids are only stamped
+ * when files are inlined) to its hosts' window, keyed on id so two parses need not walk in step.
  */
 function collectHostWindows(html: string): Map<string, HostWindow> {
   const { document } = parseHTML(html);
@@ -151,10 +149,10 @@ function collectHostWindows(html: string): Map<string, HostWindow> {
   const visiting = new Set<RefResolverEl>();
   const media = `[${MEDIA_RENDER_ID_ATTR}], video[id], audio[id], img[id]`;
   for (const element of document.querySelectorAll(media)) {
-    const renderId = element.getAttribute(MEDIA_RENDER_ID_ATTR) || element.getAttribute("id");
-    if (!renderId) continue;
+    const id = element.getAttribute(MEDIA_RENDER_ID_ATTR) || element.getAttribute("id");
+    if (!id) continue;
     windows.set(
-      renderId,
+      id,
       resolveHostWindow(element as unknown as Element, document, startCache, visiting),
     );
   }
@@ -162,9 +160,8 @@ function collectHostWindows(html: string): Map<string, HostWindow> {
 }
 
 /**
- * Shift a scene-relative window onto the root timeline.
- * Returns null when the clip starts after its host has already ended, matching
- * the `start < absoluteEnd` drop the file-tree walk applied, or when in-point hosts cut all of it.
+ * Shift a scene-relative window onto the root timeline; null when the clip starts after its host
+ * ends (the file-tree walk's `start < absoluteEnd` drop) or its in-point hosts cut all of it.
  * `start` stays the clip's origin; `played` is the part the in-point hosts' slots keep.
  */
 function toAbsoluteWindow(
@@ -184,7 +181,6 @@ function toAbsoluteWindow(
     basis: window.basis,
   });
   const absolute = { start: absoluteStart, end: Math.min(absoluteEnd, window.limit) };
-  if (window.slots.length === 0) return { ...absolute, played: absolute };
   const played = cutToHostSlots(absolute, window.slots);
   if (played.end === played.start && absolute.end > absolute.start) return null;
   return { start: absolute.start, end: played.end, played };

From 8d69b545b7959153d121a8af5b091b09249b68a8 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 02:35:06 -0700
Subject: [PATCH 4/9] fix(producer): export starts an inline scene's media at
 the scene's start

A scene written inline in index.html (no scene file, no in-point) with a
start after 0 exported its video and audio from 0 s. Every composition
host now shifts its media, as the preview's start resolver does; the root
composition still does not cut media at its end.

Also from review: a looping video in an in-point scene stays inside the
scene's slot, and a media id only takes the window of an element the
parsers report, never displacing a render id.
---
 .../src/services/renderMediaCollector.test.ts | 131 +++++++++++++++---
 .../src/services/renderMediaCollector.ts      |  67 +++++----
 2 files changed, 143 insertions(+), 55 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.test.ts b/packages/producer/src/services/renderMediaCollector.test.ts
index 95896115b99..4b5a159efcf 100644
--- a/packages/producer/src/services/renderMediaCollector.test.ts
+++ b/packages/producer/src/services/renderMediaCollector.test.ts
@@ -102,6 +102,25 @@ describe("collectRenderMedia host windows", () => {
   });
 });
 
+async function compileProject(files: Record<string, string>) {
+  const dir = mkdtempSync(join(tmpdir(), "hf-media-"));
+  try {
+    for (const [name, html] of Object.entries(files)) writeFileSync(join(dir, name), html);
+    return await compileForRender(dir, join(dir, "index.html"), dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+const inlineScene = (sceneTiming: string, extra = "") =>
+  `<!doctype html><html><body>` +
+  `<div id="root" data-composition-id="main" data-start="0" data-duration="12" data-width="1280" data-height="720">` +
+  `<div id="scene" data-composition-id="scene" class="clip" ${sceneTiming}>` +
+  `<video id="clip" class="clip" src="clip.mp4" data-start="0" data-duration="19" muted></video>` +
+  `<audio id="vo" src="vo.m4a" data-start="0" data-duration="19"></audio>` +
+  extra +
+  `</div></div></body></html>`;
+
 const media = (attrs: string) =>
   `<video ${MEDIA_RENDER_ID_ATTR}="clip" id="clip" src="clip.mp4" ${attrs}></video>` +
   `<audio ${MEDIA_RENDER_ID_ATTR}="vo" id="vo" src="vo.m4a" ${attrs}></audio>`;
@@ -125,27 +144,99 @@ describe("collectRenderMedia in-point hosts", () => {
   });
 
   it("finds an inline in-point host in a compiled document with no sub-composition files", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "hf-inpoint-"));
-    try {
-      writeFileSync(
-        join(dir, "index.html"),
+    const { videos, audios } = await compileProject({
+      "index.html": inlineScene(`data-start="0" data-duration="12" data-playback-start="7"`),
+    });
+    expect(videos.find((v) => v.id === "clip")).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
+    expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
+  });
+
+  it("starts an inline scene's media at the scene's start in a compiled document", async () => {
+    const legacy = `<video id="legacy" src="l.mp4" data-start="6" data-duration="3" data-hf-media-start-basis="global" muted></video>`;
+    const { videos, audios } = await compileProject({
+      "index.html": inlineScene(`data-start="6" data-duration="6"`, legacy),
+    });
+    expect(videos.find((v) => v.id === "clip")).toMatchObject({ start: 6, end: 12, mediaStart: 0 });
+    expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 6, end: 12, mediaStart: 0 });
+    // Already root time: the scene's start is not added again.
+    expect(videos.find((v) => v.id === "legacy")).toMatchObject({ start: 6, end: 9 });
+  });
+
+  it("leaves media running past the root composition's end uncut", () => {
+    const html =
+      `<div data-composition-id="main" data-start="0" data-duration="12">` +
+      `<audio id="music" src="m.mp3" data-start="0" data-duration="19" data-end="19"></audio>` +
+      `</div>`;
+
+    expect(collectRenderMedia(html).audios[0]).toMatchObject({ start: 0, end: 19 });
+  });
+
+  it("places an in-point scene inside a later inline scene", () => {
+    const html =
+      `<div data-composition-id="outer" data-start="10" data-duration="10">` +
+      `<div data-composition-id="inner" data-start="0" data-duration="5" data-playback-start="3">` +
+      media(`data-start="0" data-duration="19" data-end="19"`) +
+      `</div></div>`;
+
+    const { videos, audios } = collectRenderMedia(html);
+    expect(videos.find((v) => v.id === "clip")).toMatchObject({
+      start: 10,
+      end: 15,
+      mediaStart: 3,
+    });
+    expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 10, end: 15, mediaStart: 3 });
+  });
+
+  it("keeps a looping video inside its in-point scene's slot", () => {
+    const html =
+      `<div data-composition-id="scene" data-start="2" data-duration="5" data-playback-start="3">` +
+      `<video id="bg" src="bg.mp4" loop data-start="0" data-duration="10"></video>` +
+      `</div>`;
+
+    expect(collectRenderMedia(html).videos.find((v) => v.id === "bg")).toMatchObject({
+      start: 2,
+      end: 7,
+      mediaStart: 0,
+    });
+  });
+
+  it("never lets an author id take a render id's window", () => {
+    const html =
+      `<div data-composition-file="a.html" data-composition-id="a" data-start="5" data-duration="6">` +
+      `<video ${MEDIA_RENDER_ID_ATTR}="clip" id="x" src="a.mp4" data-start="0" data-duration="12"></video>` +
+      `</div>` +
+      `<video id="clip" src="b.mp4" data-start="0" data-duration="3"></video>`;
+
+    expect(collectRenderMedia(html).videos[0]).toMatchObject({ src: "a.mp4", start: 5, end: 11 });
+  });
+
+  it("skips an element the parsers do not report when matching author ids", () => {
+    const html =
+      `<div data-composition-id="main"><img id="clip">` +
+      `<div data-composition-id="scene" data-start="5" data-duration="6">` +
+      `<video id="clip" src="a.mp4" data-start="0" data-duration="12"></video>` +
+      `</div></div>`;
+
+    expect(collectRenderMedia(html).videos[0]).toMatchObject({ start: 5, end: 11 });
+  });
+
+  it("keeps a scene clip's window when a root element without a src shares its id", async () => {
+    const { videos, images } = await compileProject({
+      "index.html":
         `<!doctype html><html><body>` +
-          `<div id="root" data-composition-id="main" data-start="0" data-duration="12" data-width="1280" data-height="720">` +
-          `<div id="scene" data-composition-id="scene" class="clip" data-start="0" data-duration="12" data-playback-start="7">` +
-          `<video id="clip" class="clip" src="clip.mp4" data-start="0" data-duration="19" muted></video>` +
-          `<audio id="vo" src="vo.m4a" data-start="0" data-duration="19"></audio>` +
-          `</div></div></body></html>`,
-      );
-      const { videos, audios } = await compileForRender(dir, join(dir, "index.html"), dir);
-      expect(videos.find((v) => v.id === "clip")).toMatchObject({
-        start: 0,
-        end: 12,
-        mediaStart: 7,
-      });
-      expect(audios.find((a) => a.id === "vo")).toMatchObject({ start: 0, end: 12, mediaStart: 7 });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
+        `<div id="root" data-composition-id="main" data-start="0" data-duration="12" data-width="1280" data-height="720">` +
+        `<div data-composition-src="a.html" data-start="5" data-duration="6"></div>` +
+        `<img id="clip" data-start="0" data-duration="3"><img id="pic">` +
+        `</div></body></html>`,
+      "a.html":
+        `<template><div data-composition-id="a" data-width="1280" data-height="720">` +
+        `<video id="clip" src="clip.mp4" data-start="0" data-duration="12" muted></video>` +
+        `<img id="pic" src="p.png" data-start="1" data-duration="2">` +
+        `</div></template>`,
+    });
+    // The windows main exports for this project.
+    expect(videos.find((v) => v.id === "clip")).toMatchObject({ start: 5, end: 11 });
+    expect(images.find((i) => i.id === "pic")).toMatchObject({ start: 6, end: 8 });
   });
 
   it("cuts a split scene's media to the second half's slot", () => {
diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index f9a23643af2..7059c869458 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -9,9 +9,9 @@
  * into a single entry. See mediaRenderIds.ts for the full failure.
  *
  * Reading the inlined document instead makes the render document the single
- * source of truth for what media exists: every element is present exactly once,
- * `assignMediaRenderIds` has already given it a document-unique key, and the
- * timeline offsets are recoverable from the composition hosts it sits inside.
+ * source of truth: every element is present exactly once, keyed by its render id
+ * (stamped when files are inlined) or else its author id, and placed by the
+ * composition hosts it sits inside.
  */
 
 import { parseHTML } from "linkedom";
@@ -44,13 +44,6 @@ import {
   type AudioElement,
 } from "@hyperframes/engine";
 
-/**
- * Marks a host element that `inlineSubCompositions` hoisted a composition into.
- * Set unconditionally on every inlined host, which makes it the reliable signal
- * for "this ancestor shifts its children along the timeline".
- */
-const COMPOSITION_HOST_ATTR = "data-composition-file";
-
 /**
  * Where a composition host closes in its parent's time, or null when unbounded.
  * Delegates to `resolveAuthoredTimingWindow`, the same window the runtime uses to hide descendants.
@@ -78,16 +71,15 @@ interface HostWindow {
 
 const ROOT_WINDOW: HostWindow = { offset: 0, limit: Infinity, basis: "local", slots: [] };
 
-// Any composition host with an in-point counts, inline or anonymous, as in core's start resolver.
-const isInPointHost = (element: Element): boolean =>
-  element.matches("[data-composition-id], [data-composition-src]") &&
-  hostInPointSeconds(element) > 0;
+// Every composition host shifts what it holds, inline or inlined from a file, as in core's start resolver.
+const COMPOSITION_HOST_SELECTOR =
+  "[data-composition-id], [data-composition-src], [data-composition-file]";
 
-/** Composition hosts that place `element`, root first: inlined files, plus any host with an in-point. */
+/** Composition hosts that place `element`, root first. */
 function enclosingHosts(element: Element): Element[] {
   const hosts: Element[] = [];
   for (let ancestor = element.parentElement; ancestor; ancestor = ancestor.parentElement) {
-    if (ancestor.hasAttribute(COMPOSITION_HOST_ATTR) || isInPointHost(ancestor)) {
+    if (ancestor.matches(COMPOSITION_HOST_SELECTOR)) {
       hosts.unshift(ancestor);
     }
   }
@@ -116,26 +108,29 @@ function resolveHostWindow(
   let offset = 0;
   let limit = Infinity;
   const slots: HostSlot[] = [];
-  for (const host of hosts) {
+  for (const [index, host] of hosts.entries()) {
     const hostStart = resolveReferencedStart(document, host, startCache, visiting);
     const hostEnd = resolveHostEnd(host, hostStart);
-    if (hostEnd != null) limit = Math.min(limit, offset + hostEnd);
+    if (hostEnd != null && !isRootComposition(host, index)) {
+      limit = Math.min(limit, offset + hostEnd);
+    }
     if (hostInPointSeconds(host) > 0) {
       slots.push({ start: offset + hostStart, end: offset + (hostEnd ?? Infinity) });
     }
     offset += compositionOriginSeconds(hostStart, host);
   }
+  return { offset, limit, basis: mediaStartBasis(element), slots };
+}
+
+// The root composition's end is the render's length, not a cut: a cut would move clip fade-outs.
+const isRootComposition = (host: Element, depth: number): boolean =>
+  depth === 0 && !host.matches("[data-composition-src], [data-composition-file]");
+
+function mediaStartBasis(element: Element): MediaStartBasis {
   const tag = element.tagName.toLowerCase();
-  const basis =
-    tag === "video" || tag === "audio"
-      ? readMediaStartBasis(element.getAttribute(MEDIA_START_BASIS_ATTR))
-      : "local";
-  return {
-    offset,
-    limit,
-    basis,
-    slots,
-  };
+  return tag === "video" || tag === "audio"
+    ? readMediaStartBasis(element.getAttribute(MEDIA_START_BASIS_ATTR))
+    : "local";
 }
 
 /**
@@ -147,10 +142,11 @@ function collectHostWindows(html: string): Map<string, HostWindow> {
   const windows = new Map<string, HostWindow>();
   const startCache = new Map<RefResolverEl, number>();
   const visiting = new Set<RefResolverEl>();
-  const media = `[${MEDIA_RENDER_ID_ATTR}], video[id], audio[id], img[id]`;
-  for (const element of document.querySelectorAll(media)) {
-    const id = element.getAttribute(MEDIA_RENDER_ID_ATTR) || element.getAttribute("id");
-    if (!id) continue;
+  // What the parsers report; an author id never displaces a render id, or another author id.
+  for (const element of document.querySelectorAll("video, audio, img[src]")) {
+    const renderId = element.getAttribute(MEDIA_RENDER_ID_ATTR);
+    const id = renderId || element.getAttribute("id");
+    if (!id || (!renderId && windows.has(id))) continue;
     windows.set(
       id,
       resolveHostWindow(element as unknown as Element, document, startCache, visiting),
@@ -192,9 +188,10 @@ function startAtPlayed<T extends AudioElement | VideoElement>(
   played: { start: number },
 ): T {
   const head = played.start - clip.start;
-  // ponytail: a looping video keeps its origin (its loop runs from mediaStart), so a head cut
-  // after 0 is not applied to it; that needs a visible start separate from the origin in the engine.
-  if (head <= 0 || ("loop" in clip && clip.loop)) return clip;
+  if (head <= 0) return clip;
+  // ponytail: a loop runs from mediaStart, so it only moves to its slot and keeps main's phase error;
+  // an exact cut needs a visible start separate from the loop origin in the engine.
+  if ("loop" in clip && clip.loop) return { ...clip, start: played.start };
   const rate = normalizeRateSpec(clip.playbackRate);
   return {
     ...clip,

From 179bd36b7427e40b04581971271c7c64741211f4 Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 14:47:24 -0700
Subject: [PATCH 5/9] docs(producer): media collector header states the id rule
 without history

---
 .../src/services/renderMediaCollector.ts        | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index 7059c869458..8e2b4118eaf 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -1,17 +1,12 @@
 /**
  * Collect the render pipeline's media list from the fully inlined document.
  *
- * Sub-composition media used to be gathered from each composition FILE before
- * inlining, then merged with the main document's media and deduplicated by
- * element id. That merge is unsound: ids are unique per file, not per render
- * document, so two scenes that both declare `<video id="clip">` — or that both
- * declare a bare `<video>` and get the per-file auto-id `hf-video-0` — collapse
- * into a single entry. See mediaRenderIds.ts for the full failure.
- *
- * Reading the inlined document instead makes the render document the single
- * source of truth: every element is present exactly once, keyed by its render id
- * (stamped when files are inlined) or else its author id, and placed by the
- * composition hosts it sits inside.
+ * Element ids are unique per composition file, not per render document: two scenes
+ * that both declare `<video id="clip">`, or a bare `<video>` auto-id'd `hf-video-0`,
+ * would collapse into one entry if media were gathered per file and merged by id
+ * (see mediaRenderIds.ts). The inlined document holds every element exactly once,
+ * keyed by its render id (stamped when files are inlined) or else its author id, and
+ * placed by the composition hosts it sits inside.
  */
 
 import { parseHTML } from "linkedom";

From 0dd8f5cbe3b2cc07ff3e160da1c07dd59b726e7b Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 16:14:30 -0700
Subject: [PATCH 6/9] fix(producer): a trimmed clip in a split scene keeps
 picture and sound in sync when export probes

The browser probe compared the page's start point against the value the media
collector had already moved by the scene's in-point, so it reset the picture to
the clip's own trim while its sound track kept the in-point. It now compares
against the start point written in the markup, moves the collected value by
whatever the page changed, and moves a video's sound track with its picture.
---
 .../services/render/stages/probeStage.test.ts | 39 ++++++++++++
 .../src/services/render/stages/probeStage.ts  | 63 ++++++++++++++-----
 2 files changed, 86 insertions(+), 16 deletions(-)

diff --git a/packages/producer/src/services/render/stages/probeStage.test.ts b/packages/producer/src/services/render/stages/probeStage.test.ts
index 2528d826352..051e3eec17b 100644
--- a/packages/producer/src/services/render/stages/probeStage.test.ts
+++ b/packages/producer/src/services/render/stages/probeStage.test.ts
@@ -411,6 +411,45 @@ describe("runProbeStage — forceScreenshot threading", () => {
     expect(mediaPreflightComposition).toBe(input.composition);
   });
 
+  // Scene in-point 5 and clip trim 1: the collector starts picture and sound at source 6.
+  it.each([
+    { pageStart: 1, expected: 6 },
+    { pageStart: 3, expected: 8 },
+  ])(
+    "keeps a trimmed clip's picture and sound together inside a trimmed scene (page start $pageStart)",
+    async ({ pageStart, expected }) => {
+      resetRetryMocks();
+      browserMediaResults = [
+        {
+          id: "a",
+          tagName: "video",
+          src: "a.mp4",
+          start: 0,
+          end: 18,
+          duration: 18,
+          mediaStart: pageStart,
+          loop: false,
+          hasAudio: true,
+          volume: 1,
+          muted: false,
+        },
+      ];
+      const { runProbeStage } = await import("./probeStage.js");
+      const input = makeProbeInput({});
+      const window = { src: "a.mp4", start: 0, end: 6, mediaStart: 6 };
+      input.composition.videos.push({ id: "a", ...window, loop: false, hasAudio: true });
+      input.composition.audios.push({ id: "a-audio", ...window, layer: 0, type: "video" });
+      input.compiled.html = `<div data-composition-id="scene" data-start="0" data-duration="6" data-playback-start="5">
+        <video id="a" src="a.mp4" data-start="0" data-duration="18" data-playback-start="1" data-has-audio="true"></video>
+      </div>`;
+
+      await runProbeStage(input);
+
+      expect(input.composition.videos[0]?.mediaStart).toBe(expected);
+      expect(input.composition.audios[0]?.mediaStart).toBe(expected);
+    },
+  );
+
   it("reconciles a nested source's selected runtime URL before media-type preflight", async () => {
     resetRetryMocks();
     browserMediaResults = [
diff --git a/packages/producer/src/services/render/stages/probeStage.ts b/packages/producer/src/services/render/stages/probeStage.ts
index 1a0977e310e..7fc1ceee2fa 100644
--- a/packages/producer/src/services/render/stages/probeStage.ts
+++ b/packages/producer/src/services/render/stages/probeStage.ts
@@ -44,9 +44,9 @@ import {
   isTransientBrowserError,
   probeBeginFrameLiveness,
 } from "@hyperframes/engine";
-import { fpsToNumber } from "@hyperframes/core";
+import { MEDIA_RENDER_ID_ATTR, fpsToNumber, readMediaStart } from "@hyperframes/core";
 import { extractMediaSrcMutations } from "@hyperframes/parsers";
-import type { CompiledComposition } from "../../htmlCompiler.js";
+import type { BrowserMediaElement, CompiledComposition } from "../../htmlCompiler.js";
 import {
   discoverMediaFromBrowser,
   discoverAudioVolumeAutomationFromTimeline,
@@ -181,6 +181,40 @@ export function hasVariableBoundMedia(
   });
 }
 
+/** Each clip's own start point as the compiled markup gives it, keyed like the browser probe. */
+function authoredMediaStarts(html: string): Map<string, number> {
+  const { document } = parseHTML(html);
+  const starts = new Map<string, number>();
+  for (const media of document.querySelectorAll("video, audio")) {
+    const id = media.getAttribute(MEDIA_RENDER_ID_ATTR) || media.getAttribute("id");
+    if (id && !starts.has(id)) starts.set(id, readMediaStart(media));
+  }
+  return starts;
+}
+
+/**
+ * Take a start point the page changed by moving the collected one by the same amount, so the
+ * in-point its scene added survives, and a video's sound track moves with its picture.
+ */
+function adoptRuntimeMediaStart(
+  composition: Pick<CompositionMetadata, "videos" | "audios">,
+  el: BrowserMediaElement,
+  authored: number,
+): void {
+  const shift = el.mediaStart - authored;
+  if (el.mediaStart <= 0 || Math.abs(shift) <= BROWSER_MEDIA_EPSILON) return;
+  const entries =
+    el.tagName === "video"
+      ? [
+          ...composition.videos.filter((video) => video.id === el.id),
+          ...composition.audios.filter(
+            (audio) => audio.type === "video" && audio.id === `${el.id}-audio`,
+          ),
+        ]
+      : composition.audios.filter((audio) => audio.id === el.id);
+  for (const entry of entries) entry.mediaStart += shift;
+}
+
 function reconcileBrowserMediaEnd(
   existingEnd: number,
   projectedEnd: number,
@@ -524,6 +558,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
         const existingVideoIds = new Set(composition.videos.map((v) => v.id));
         const existingAudioIds = new Set(composition.audios.map((a) => a.id));
         const existingImageIds = new Set(composition.images.map((image) => image.id));
+        const authoredStarts = authoredMediaStarts(compiled.html);
 
         pruneMutedBrowserMedia(composition, browserMedia, existingAudioIds);
 
@@ -558,13 +593,11 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   sourceChanged,
                   el.durationInferred,
                 );
-                if (
-                  el.mediaStart > 0 &&
-                  (existing.mediaStart <= 0 ||
-                    Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)
-                ) {
-                  existing.mediaStart = el.mediaStart;
-                }
+                adoptRuntimeMediaStart(
+                  composition,
+                  el,
+                  authoredStarts.get(el.id) ?? existing.mediaStart,
+                );
                 if (el.hasAudio && !el.muted && !existing.hasAudio) {
                   existing.hasAudio = true;
                 }
@@ -605,13 +638,11 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   sourceChanged,
                   el.durationInferred,
                 );
-                if (
-                  el.mediaStart > 0 &&
-                  (existing.mediaStart <= 0 ||
-                    Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)
-                ) {
-                  existing.mediaStart = el.mediaStart;
-                }
+                adoptRuntimeMediaStart(
+                  composition,
+                  el,
+                  authoredStarts.get(el.id) ?? existing.mediaStart,
+                );
                 if (
                   el.volume > 0 &&
                   Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON

From 173c581915c75230e3ab6dab4834320433434a4c Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 18:20:39 -0700
Subject: [PATCH 7/9] fix(producer): export no longer replays a split scene's
 cut-away clips when it probes

The media collector drops clips a scene's in-point cuts away entirely (and
clips that start after their scene ends). When the render probed the page,
the probe saw those clips in the DOM and added them back at their
scene-local time, so a split scene's audio played twice. The collector now
reports the ids it dropped and the probe does not re-add them.

An <audio id="v-audio"> start change no longer also moves video v's sound
track, which reports the same id.
---
 .../producer/src/services/htmlCompiler.ts     |  4 +-
 .../services/render/stages/probeStage.test.ts | 62 +++++++++++++++++++
 .../src/services/render/stages/probeStage.ts  |  8 +--
 .../src/services/renderMediaCollector.test.ts | 22 +++++++
 .../src/services/renderMediaCollector.ts      | 21 +++++--
 5 files changed, 106 insertions(+), 11 deletions(-)

diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.ts
index f03f109743d..93d1da970cf 100644
--- a/packages/producer/src/services/htmlCompiler.ts
+++ b/packages/producer/src/services/htmlCompiler.ts
@@ -110,6 +110,7 @@ export interface CompiledComposition {
   videos: VideoElement[];
   audios: AudioElement[];
   images: ImageElement[];
+  droppedMediaIds: Set<string>;
   unresolvedCompositions: UnresolvedElement[];
   /** Assets that resolve outside projectDir. Keys are the path used in HTML, values are absolute filesystem paths. */
   externalAssets: Map<string, string>;
@@ -2145,7 +2146,7 @@ export async function compileForRender(
   // within one composition file: two scenes declaring `<video id="clip">` — or
   // two bare `<video>`s, both auto-numbered `hf-video-0` — collapsed into one
   // entry and injected frames onto whichever element came first. See #3340.
-  const { videos, audios, images } = collectRenderMedia(html);
+  const { videos, audios, images, droppedMediaIds } = collectRenderMedia(html);
 
   // Advisory video checks (sparse keyframes, VFR). Fire-and-forget — these spawn
   // ffprobe subprocesses and should not block compilation since they only produce warnings.
@@ -2198,6 +2199,7 @@ export async function compileForRender(
     videos,
     audios,
     images,
+    droppedMediaIds,
     unresolvedCompositions,
     externalAssets,
     width,
diff --git a/packages/producer/src/services/render/stages/probeStage.test.ts b/packages/producer/src/services/render/stages/probeStage.test.ts
index 051e3eec17b..9d2cf6f7d81 100644
--- a/packages/producer/src/services/render/stages/probeStage.test.ts
+++ b/packages/producer/src/services/render/stages/probeStage.test.ts
@@ -271,6 +271,7 @@ function makeProbeInput(overrides: {
       videos: [],
       audios: [],
       images: [],
+      droppedMediaIds: new Set<string>(),
       unresolvedCompositions: [],
       externalAssets: new Map(),
       width: 1920,
@@ -450,6 +451,67 @@ describe("runProbeStage — forceScreenshot threading", () => {
     },
   );
 
+  it("does not add back clips the collector dropped", async () => {
+    resetRetryMocks();
+    const common = { start: 1, end: 4, duration: 3, mediaStart: 0, volume: 1, muted: false };
+    browserMediaResults = [
+      { ...common, id: "early", tagName: "audio", src: "early.m4a" },
+      { ...common, id: "early__hf2", tagName: "audio", src: "early.m4a" },
+      { ...common, id: "clip__hf2", tagName: "video", src: "clip.mp4" },
+      { ...common, id: "pic__hf2", tagName: "image", src: "pic.png" },
+    ];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.audios.push({
+      id: "early",
+      src: "early.m4a",
+      start: 1,
+      end: 4,
+      mediaStart: 0,
+      layer: 0,
+      type: "audio",
+    });
+    input.compiled.droppedMediaIds = new Set(["early__hf2", "clip__hf2", "pic__hf2"]);
+
+    await runProbeStage(input);
+
+    expect(input.composition.audios.map((audio) => audio.id)).toEqual(["early"]);
+    expect(input.composition.videos).toEqual([]);
+    expect(input.composition.images).toEqual([]);
+  });
+
+  it("moves an audio's start without moving a video track that shares its id", async () => {
+    resetRetryMocks();
+    browserMediaResults = [
+      {
+        id: "v-audio",
+        tagName: "audio",
+        src: "a.m4a",
+        start: 0,
+        end: 6,
+        duration: 6,
+        mediaStart: 4,
+        loop: false,
+        hasAudio: false,
+        volume: 1,
+        muted: false,
+      },
+    ];
+    const { runProbeStage } = await import("./probeStage.js");
+    const input = makeProbeInput({});
+    input.composition.audios.push(
+      { id: "v-audio", src: "a.m4a", start: 0, end: 6, mediaStart: 2, layer: 0, type: "audio" },
+      { id: "v-audio", src: "v.mp4", start: 0, end: 6, mediaStart: 0, layer: 0, type: "video" },
+    );
+    input.compiled.html =
+      `<video id="v" src="v.mp4" data-start="0" data-duration="6" data-has-audio="true"></video>` +
+      `<audio id="v-audio" src="a.m4a" data-start="0" data-duration="6" data-playback-start="2"></audio>`;
+
+    await runProbeStage(input);
+
+    expect(input.composition.audios.map((audio) => audio.mediaStart)).toEqual([4, 0]);
+  });
+
   it("reconciles a nested source's selected runtime URL before media-type preflight", async () => {
     resetRetryMocks();
     browserMediaResults = [
diff --git a/packages/producer/src/services/render/stages/probeStage.ts b/packages/producer/src/services/render/stages/probeStage.ts
index 7fc1ceee2fa..0203e8f963e 100644
--- a/packages/producer/src/services/render/stages/probeStage.ts
+++ b/packages/producer/src/services/render/stages/probeStage.ts
@@ -211,7 +211,7 @@ function adoptRuntimeMediaStart(
             (audio) => audio.type === "video" && audio.id === `${el.id}-audio`,
           ),
         ]
-      : composition.audios.filter((audio) => audio.id === el.id);
+      : composition.audios.filter((audio) => audio.type !== "video" && audio.id === el.id);
   for (const entry of entries) entry.mediaStart += shift;
 }
 
@@ -605,7 +605,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   existing.loop = true;
                 }
               }
-            } else {
+            } else if (!compiled.droppedMediaIds.has(el.id)) {
               // New video discovered from browser
               composition.videos.push({
                 id: el.id,
@@ -650,7 +650,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   existing.volume = el.volume;
                 }
               }
-            } else {
+            } else if (!compiled.droppedMediaIds.has(el.id)) {
               composition.audios.push({
                 id: el.id,
                 src,
@@ -681,7 +681,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageR
                   existing.end = projectedEnd;
                 }
               }
-            } else {
+            } else if (!compiled.droppedMediaIds.has(el.id)) {
               composition.images.push({
                 id: el.id,
                 src,
diff --git a/packages/producer/src/services/renderMediaCollector.test.ts b/packages/producer/src/services/renderMediaCollector.test.ts
index 4b5a159efcf..d5f80ee93a1 100644
--- a/packages/producer/src/services/renderMediaCollector.test.ts
+++ b/packages/producer/src/services/renderMediaCollector.test.ts
@@ -258,6 +258,28 @@ describe("collectRenderMedia in-point hosts", () => {
     expect(audios.find((a) => a.id === "fast")).toMatchObject({ start: 5, end: 12, mediaStart: 4 });
   });
 
+  it("reports the clips a split scene's in-point cuts away", async () => {
+    const host = (timing: string) =>
+      `<div data-composition-id="scene" data-composition-src="scene.html" ${timing}></div>`;
+    const compiled = await compileProject({
+      "index.html":
+        `<!doctype html><html><body>` +
+        `<div id="root" data-composition-id="main" data-start="0" data-duration="12" data-width="1280" data-height="720">` +
+        host(`data-start="0" data-duration="5"`) +
+        host(`data-start="5" data-duration="7" data-playback-start="5"`) +
+        `</div></body></html>`,
+      "scene.html":
+        `<template><div data-composition-id="scene" data-width="1280" data-height="720">` +
+        `<audio id="early" src="early.m4a" data-start="1" data-duration="3"></audio>` +
+        `</div></template>`,
+    });
+
+    expect(compiled.audios.map(({ id, start, end }) => ({ id, start, end }))).toEqual([
+      { id: "early", start: 1, end: 4 },
+    ]);
+    expect([...compiled.droppedMediaIds]).toEqual(["early__hf2"]);
+  });
+
   it("changes nothing for a host without an in-point", () => {
     const scene = (inPoint: string) =>
       `<div data-composition-id="inline" data-start="3" data-duration="4"${inPoint}>` +
diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index 8e2b4118eaf..776427a04ec 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -200,6 +200,8 @@ export interface RenderMedia {
   videos: VideoElement[];
   audios: AudioElement[];
   images: ImageElement[];
+  /** Ids of clips in the document that never play; the browser probe must not add them back. */
+  droppedMediaIds: Set<string>;
 }
 
 /**
@@ -213,21 +215,25 @@ export interface RenderMedia {
 export function collectRenderMedia(html: string): RenderMedia {
   const windows = collectHostWindows(html);
   const windowFor = (id: string): HostWindow => windows.get(id) ?? ROOT_WINDOW;
+  const droppedMediaIds = new Set<string>();
 
   const videos: VideoElement[] = [];
   for (const video of parseVideoElements(html)) {
     const absolute = toAbsoluteWindow(video.start, video.end, windowFor(video.id));
-    if (absolute) {
-      videos.push(
-        startAtPlayed({ ...video, start: absolute.start, end: absolute.end }, absolute.played),
-      );
+    if (!absolute) {
+      droppedMediaIds.add(video.id);
+      continue;
     }
+    videos.push(
+      startAtPlayed({ ...video, start: absolute.start, end: absolute.end }, absolute.played),
+    );
   }
 
   const images: ImageElement[] = [];
   for (const image of parseImageElements(html)) {
     const absolute = toAbsoluteWindow(image.start, image.end, windowFor(image.id));
     if (absolute) images.push({ ...image, start: absolute.start, end: absolute.end });
+    else droppedMediaIds.add(image.id);
   }
 
   // A <video data-has-audio> track is reported as "<renderId>-audio"; strip the
@@ -239,7 +245,10 @@ export function collectRenderMedia(html: string): RenderMedia {
     // unbounded track must stay unbounded rather than collapse onto its start.
     const authoredEnd = audio.end > 0 ? audio.end : Infinity;
     const absolute = toAbsoluteWindow(audio.start, authoredEnd, windowFor(elementId));
-    if (!absolute) continue;
+    if (!absolute) {
+      droppedMediaIds.add(elementId);
+      continue;
+    }
     audios.push(
       startAtPlayed(
         { ...audio, start: absolute.start, end: Number.isFinite(absolute.end) ? absolute.end : 0 },
@@ -248,5 +257,5 @@ export function collectRenderMedia(html: string): RenderMedia {
     );
   }
 
-  return { videos, audios, images };
+  return { videos, audios, images, droppedMediaIds };
 }

From b1c7dd1043287abdbf7a72c01e7b275a383ddcfb Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 19:10:49 -0700
Subject: [PATCH 8/9] docs(producer): shorten the media collector header to the
 id rule

---
 packages/producer/src/services/renderMediaCollector.ts | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index 776427a04ec..3376eeb209d 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -1,12 +1,9 @@
 /**
  * Collect the render pipeline's media list from the fully inlined document.
  *
- * Element ids are unique per composition file, not per render document: two scenes
- * that both declare `<video id="clip">`, or a bare `<video>` auto-id'd `hf-video-0`,
- * would collapse into one entry if media were gathered per file and merged by id
- * (see mediaRenderIds.ts). The inlined document holds every element exactly once,
- * keyed by its render id (stamped when files are inlined) or else its author id, and
- * placed by the composition hosts it sits inside.
+ * Ids are unique per composition file, not per render document (see mediaRenderIds.ts), so media is
+ * read from the inlined document: each element once, keyed by its render id or else its author id,
+ * and placed by the composition hosts it sits inside.
  */
 
 import { parseHTML } from "linkedom";

From 2e5755e66108e3816425004e7e1df8be485de5bf Mon Sep 17 00:00:00 2001
From: Miguel Angel Simon Sierra <miguel.sierra@heygen.com>
Date: Sun, 11 Oct 2026 20:14:13 -0700
Subject: [PATCH 9/9] refactor(producer): place each audio track in its own
 helper

---
 .../src/services/renderMediaCollector.ts      | 27 +++++++++----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/packages/producer/src/services/renderMediaCollector.ts b/packages/producer/src/services/renderMediaCollector.ts
index 3376eeb209d..6414acec408 100644
--- a/packages/producer/src/services/renderMediaCollector.ts
+++ b/packages/producer/src/services/renderMediaCollector.ts
@@ -238,21 +238,20 @@ export function collectRenderMedia(html: string): RenderMedia {
   const audios: AudioElement[] = [];
   for (const audio of parseAudioElements(html)) {
     const elementId = audio.type === "video" ? audio.id.replace(/-audio$/, "") : audio.id;
-    // The mixer reads end === 0 as "run to the natural media length", so an
-    // unbounded track must stay unbounded rather than collapse onto its start.
-    const authoredEnd = audio.end > 0 ? audio.end : Infinity;
-    const absolute = toAbsoluteWindow(audio.start, authoredEnd, windowFor(elementId));
-    if (!absolute) {
-      droppedMediaIds.add(elementId);
-      continue;
-    }
-    audios.push(
-      startAtPlayed(
-        { ...audio, start: absolute.start, end: Number.isFinite(absolute.end) ? absolute.end : 0 },
-        absolute.played,
-      ),
-    );
+    const placed = placeAudio(audio, windowFor(elementId));
+    if (placed) audios.push(placed);
+    else droppedMediaIds.add(elementId);
   }
 
   return { videos, audios, images, droppedMediaIds };
 }
+
+function placeAudio(audio: AudioElement, window: HostWindow): AudioElement | null {
+  // The mixer reads end === 0 as "run to the natural media length", so an
+  // unbounded track must stay unbounded rather than collapse onto its start.
+  const authoredEnd = audio.end > 0 ? audio.end : Infinity;
+  const absolute = toAbsoluteWindow(audio.start, authoredEnd, window);
+  if (!absolute) return null;
+  const end = Number.isFinite(absolute.end) ? absolute.end : 0;
+  return startAtPlayed({ ...audio, start: absolute.start, end }, absolute.played);
+}