From 2565fba59ad333fc0bbcaf5a43623a336ba6dd53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miguel=20=C3=81ngel?= <miguel.sierra@heygen.com>
Date: Fri, 24 Apr 2026 11:51:07 -0400
Subject: [PATCH 1/4] fix: preserve template-wrapped sub-composition media
 offsets

---
 packages/engine/src/services/audioMixer.ts    |   3 +-
 .../src/services/videoFrameExtractor.ts       |   5 +-
 packages/engine/src/utils/htmlTemplate.ts     |  11 ++
 .../src/services/htmlCompiler.test.ts         | 115 ++++++++++++++++++
 .../producer/src/services/htmlCompiler.ts     |   7 +-
 5 files changed, 135 insertions(+), 6 deletions(-)
 create mode 100644 packages/engine/src/utils/htmlTemplate.ts

diff --git a/packages/engine/src/services/audioMixer.ts b/packages/engine/src/services/audioMixer.ts
index 726726425..a3ccb804c 100644
--- a/packages/engine/src/services/audioMixer.ts
+++ b/packages/engine/src/services/audioMixer.ts
@@ -11,6 +11,7 @@ import { extractAudioMetadata } from "../utils/ffprobe.js";
 import { downloadToTemp, isHttpUrl } from "../utils/urlDownloader.js";
 import { DEFAULT_CONFIG, type EngineConfig } from "../config.js";
 import { runFfmpeg } from "../utils/runFfmpeg.js";
+import { unwrapTemplate } from "../utils/htmlTemplate.js";
 import type { AudioElement, AudioTrack, MixResult } from "./audioMixer.types.js";
 
 export type { AudioElement, AudioTrack, MixResult } from "./audioMixer.types.js";
@@ -24,7 +25,7 @@ interface ExtractResult {
 
 export function parseAudioElements(html: string): AudioElement[] {
   const elements: AudioElement[] = [];
-  const { document } = parseHTML(html);
+  const { document } = parseHTML(unwrapTemplate(html));
 
   // Parse <audio> elements
   const audioEls = document.querySelectorAll("audio[id][src]");
diff --git a/packages/engine/src/services/videoFrameExtractor.ts b/packages/engine/src/services/videoFrameExtractor.ts
index 8f81c6dee..ac6ea8e5a 100644
--- a/packages/engine/src/services/videoFrameExtractor.ts
+++ b/packages/engine/src/services/videoFrameExtractor.ts
@@ -18,6 +18,7 @@ import {
 import { downloadToTemp, isHttpUrl } from "../utils/urlDownloader.js";
 import { runFfmpeg } from "../utils/runFfmpeg.js";
 import { DEFAULT_CONFIG, type EngineConfig } from "../config.js";
+import { unwrapTemplate } from "../utils/htmlTemplate.js";
 import {
   FRAME_FILENAME_PREFIX,
   ensureCacheEntryDir,
@@ -102,7 +103,7 @@ export interface ExtractionResult {
 
 export function parseVideoElements(html: string): VideoElement[] {
   const videos: VideoElement[] = [];
-  const { document } = parseHTML(html);
+  const { document } = parseHTML(unwrapTemplate(html));
 
   const videoEls = document.querySelectorAll("video[src]");
   let autoIdCounter = 0;
@@ -156,7 +157,7 @@ export interface ImageElement {
 
 export function parseImageElements(html: string): ImageElement[] {
   const images: ImageElement[] = [];
-  const { document } = parseHTML(html);
+  const { document } = parseHTML(unwrapTemplate(html));
 
   const imgEls = document.querySelectorAll("img[src]");
   let autoIdCounter = 0;
diff --git a/packages/engine/src/utils/htmlTemplate.ts b/packages/engine/src/utils/htmlTemplate.ts
new file mode 100644
index 000000000..d24e79249
--- /dev/null
+++ b/packages/engine/src/utils/htmlTemplate.ts
@@ -0,0 +1,11 @@
+/**
+ * linkedom follows browser semantics for <template>: its descendants live in a
+ * DocumentFragment, so plain querySelectorAll() calls against the document do
+ * not see media nested inside a top-level template wrapper. Sub-compositions
+ * in HyperFrames commonly use a single top-level <template>, so unwrap one
+ * level before parsing media from that HTML string.
+ */
+export function unwrapTemplate(html: string): string {
+  const match = html.match(/<template[^>]*>([\s\S]*)<\/template>/i);
+  return match && match[1] !== undefined ? match[1] : html;
+}
diff --git a/packages/producer/src/services/htmlCompiler.test.ts b/packages/producer/src/services/htmlCompiler.test.ts
index 6653c84ce..a4ae86c27 100644
--- a/packages/producer/src/services/htmlCompiler.test.ts
+++ b/packages/producer/src/services/htmlCompiler.test.ts
@@ -7,6 +7,7 @@ import {
   compileForRender,
   detectRenderModeHints,
   inlineExternalScripts,
+  recompileWithResolutions,
 } from "./htmlCompiler.js";
 
 // ── collectExternalAssets ──────────────────────────────────────────────────
@@ -456,3 +457,117 @@ describe("detectRenderModeHints", () => {
     }
   });
 });
+
+describe("template-wrapped sub-composition media offsets", () => {
+  function writeTemplateWrappedProject(hostAttrs: string): {
+    projectDir: string;
+    indexPath: string;
+  } {
+    const projectDir = mkdtempSync(join(tmpdir(), "hf-template-offset-"));
+    const compositionsDir = join(projectDir, "compositions");
+    mkdirSync(compositionsDir, { recursive: true });
+    writeFileSync(
+      join(projectDir, "index.html"),
+      `<!DOCTYPE html>
+<html>
+  <body>
+    <div
+      id="root"
+      data-composition-id="root"
+      data-start="0"
+      data-width="640"
+      data-height="360"
+      data-duration="4"
+    >
+      <div
+        id="scene-host"
+        data-composition-id="scene"
+        data-composition-src="compositions/scene.html"
+        ${hostAttrs}
+      ></div>
+    </div>
+    <script>
+      window.__timelines = window.__timelines || {};
+      window.__timelines["root"] = { duration: () => 4 };
+    </script>
+  </body>
+</html>`,
+    );
+    writeFileSync(
+      join(compositionsDir, "scene.html"),
+      `<template id="scene-template">
+  <div
+    data-composition-id="scene"
+    data-start="0"
+    data-width="640"
+    data-height="360"
+    data-duration="4"
+  >
+    <video
+      id="scene-video"
+      src="../assets/clip.mp4"
+      data-start="0"
+      data-duration="4"
+      data-track-index="0"
+    ></video>
+    <script>
+      window.__timelines = window.__timelines || {};
+      window.__timelines["scene"] = { duration: () => 4 };
+    </script>
+  </div>
+</template>`,
+    );
+
+    return { projectDir, indexPath: join(projectDir, "index.html") };
+  }
+
+  it("offsets template-wrapped media to the host start during compile", async () => {
+    const { projectDir, indexPath } = writeTemplateWrappedProject(
+      'data-start="2" data-duration="2" data-width="640" data-height="360"',
+    );
+
+    const compiled = await compileForRender(projectDir, indexPath, projectDir);
+
+    expect(compiled.videos).toHaveLength(1);
+    expect(compiled.videos[0]).toMatchObject({
+      id: "scene-video",
+      start: 2,
+      end: 6,
+    });
+    expect(compiled.audios).toHaveLength(1);
+    expect(compiled.audios[0]).toMatchObject({
+      id: "scene-video-audio",
+      start: 2,
+      end: 6,
+    });
+  });
+
+  it("preserves first-pass media offsets when durations are resolved after inlining", async () => {
+    const { projectDir, indexPath } = writeTemplateWrappedProject(
+      'data-start="2" data-width="640" data-height="360"',
+    );
+
+    const compiled = await compileForRender(projectDir, indexPath, projectDir);
+    expect(compiled.videos[0]?.start).toBe(2);
+
+    const recompiled = await recompileWithResolutions(
+      compiled,
+      [{ id: "scene-host", duration: 2 }],
+      projectDir,
+      projectDir,
+    );
+
+    expect(recompiled.videos).toHaveLength(1);
+    expect(recompiled.videos[0]).toMatchObject({
+      id: "scene-video",
+      start: 2,
+      end: 6,
+    });
+    expect(recompiled.audios).toHaveLength(1);
+    expect(recompiled.audios[0]).toMatchObject({
+      id: "scene-video-audio",
+      start: 2,
+      end: 6,
+    });
+  });
+});
diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.ts
index 5e1418135..5be6ea351 100644
--- a/packages/producer/src/services/htmlCompiler.ts
+++ b/packages/producer/src/services/htmlCompiler.ts
@@ -1233,9 +1233,10 @@ export async function recompileWithResolutions(
   const mainImages = parseImageElements(html);
 
   // Keep inlined sub-composition media authoritative on ID collisions.
-  const videos = dedupeElementsById([...mainVideos, ...subVideos]);
-  const audios = dedupeElementsById([...mainAudios, ...subAudios]);
-  const images = dedupeElementsById([...mainImages, ...subImages]);
+  const hasSubMedia = subVideos.length > 0 || subAudios.length > 0 || subImages.length > 0;
+  const videos = hasSubMedia ? dedupeElementsById([...mainVideos, ...subVideos]) : compiled.videos;
+  const audios = hasSubMedia ? dedupeElementsById([...mainAudios, ...subAudios]) : compiled.audios;
+  const images = hasSubMedia ? dedupeElementsById([...mainImages, ...subImages]) : compiled.images;
 
   const remaining = compiled.unresolvedCompositions.filter(
     (c) => !resolutions.some((r) => r.id === c.id),

From 5d23706e01656c7db3a34cab316b1117a4a821b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miguel=20=C3=81ngel?= <miguel.sierra@heygen.com>
Date: Fri, 24 Apr 2026 11:58:45 -0400
Subject: [PATCH 2/4] fix: avoid regex in template unwrap helper

---
 .../engine/src/utils/htmlTemplate.test.ts     | 42 +++++++++++++++
 packages/engine/src/utils/htmlTemplate.ts     | 53 ++++++++++++++++---
 2 files changed, 88 insertions(+), 7 deletions(-)
 create mode 100644 packages/engine/src/utils/htmlTemplate.test.ts

diff --git a/packages/engine/src/utils/htmlTemplate.test.ts b/packages/engine/src/utils/htmlTemplate.test.ts
new file mode 100644
index 000000000..96cc27ecb
--- /dev/null
+++ b/packages/engine/src/utils/htmlTemplate.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { unwrapTemplate } from "./htmlTemplate.js";
+
+describe("unwrapTemplate", () => {
+  it("returns the input unchanged when there is no template wrapper", () => {
+    const html = `<div>hello</div>`;
+    expect(unwrapTemplate(html)).toBe(html);
+  });
+
+  it("unwraps a bare top-level template fragment", () => {
+    const inner = `<span>hi</span>`;
+    const html = `<template id="t" data-x="1">${inner}</template>`;
+    expect(unwrapTemplate(html)).toBe(inner);
+  });
+
+  it("unwraps a full document whose body only contains a template", () => {
+    const inner = `<div id="root"><audio id="a" src="a.mp3"></audio></div>`;
+    const html = `<!doctype html><html><body><template>${inner}</template></body></html>`;
+    expect(unwrapTemplate(html)).toBe(inner);
+  });
+
+  it("returns the input unchanged when the closing template tag is missing", () => {
+    const html = `<template><div>broken`;
+    expect(unwrapTemplate(html)).toBe(html);
+  });
+
+  it("returns an empty string for an empty template", () => {
+    const html = `<body><template></template></body>`;
+    expect(unwrapTemplate(html)).toBe("");
+  });
+
+  it("preserves nested templates inside the outer wrapper", () => {
+    const inner = `outer-before<template>inner-content</template>outer-after`;
+    const html = `<template>${inner}</template>`;
+    expect(unwrapTemplate(html)).toBe(inner);
+  });
+
+  it("leaves multiple sibling templates unchanged", () => {
+    const html = `<template>a</template>middle<template>b</template>`;
+    expect(unwrapTemplate(html)).toBe(html);
+  });
+});
diff --git a/packages/engine/src/utils/htmlTemplate.ts b/packages/engine/src/utils/htmlTemplate.ts
index d24e79249..f1d0200fa 100644
--- a/packages/engine/src/utils/htmlTemplate.ts
+++ b/packages/engine/src/utils/htmlTemplate.ts
@@ -1,11 +1,50 @@
+import { parseHTML } from "linkedom";
+
+function parseHTMLContent(html: string): Document {
+  const trimmed = html.trimStart().toLowerCase();
+  if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html")) {
+    return parseHTML(html).document;
+  }
+  return parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`).document;
+}
+
+function getSingleMeaningfulChild(container: Element): Element | null {
+  let child: Element | null = null;
+  for (const node of Array.from(container.childNodes)) {
+    if (node.nodeType === 3 && !(node.textContent || "").trim()) continue;
+    if (node.nodeType === 8) continue;
+    if (node.nodeType !== 1) return null;
+    if (child) return null;
+    child = node as Element;
+  }
+  return child;
+}
+
 /**
- * linkedom follows browser semantics for <template>: its descendants live in a
- * DocumentFragment, so plain querySelectorAll() calls against the document do
- * not see media nested inside a top-level template wrapper. Sub-compositions
- * in HyperFrames commonly use a single top-level <template>, so unwrap one
- * level before parsing media from that HTML string.
+ * Sub-compositions commonly use a single top-level <template> wrapper. Parse
+ * the HTML and unwrap only that exact shape, rather than pattern-matching the
+ * raw string. This avoids both regex backtracking risk and accidental rewrites
+ * of inputs that contain multiple sibling templates or other top-level content.
  */
 export function unwrapTemplate(html: string): string {
-  const match = html.match(/<template[^>]*>([\s\S]*)<\/template>/i);
-  return match && match[1] !== undefined ? match[1] : html;
+  const lowered = html.toLowerCase();
+  if (!lowered.includes("<template") || !lowered.includes("</template>")) {
+    return html;
+  }
+
+  const { body } = parseHTMLContent(html);
+  if (!body) return html;
+
+  let container: Element = body;
+  const bodyWrapper = getSingleMeaningfulChild(container);
+  if (bodyWrapper?.tagName === "BODY") {
+    container = bodyWrapper;
+  }
+
+  const template = getSingleMeaningfulChild(container);
+  if (template?.tagName !== "TEMPLATE") {
+    return html;
+  }
+
+  return template.innerHTML ?? html;
 }

From 5d4ed9c12d1dee10addd075017634b6044fd5444 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miguel=20=C3=81ngel?= <miguel.sierra@heygen.com>
Date: Fri, 24 Apr 2026 12:29:09 -0400
Subject: [PATCH 3/4] fix(producer): keep browser media offsets in host
 timeline

---
 .../src/services/htmlCompiler.test.ts         | 30 +++++++++--
 .../src/services/renderOrchestrator.test.ts   | 15 ++++++
 .../src/services/renderOrchestrator.ts        | 53 ++++++++++++++++---
 3 files changed, 88 insertions(+), 10 deletions(-)

diff --git a/packages/producer/src/services/htmlCompiler.test.ts b/packages/producer/src/services/htmlCompiler.test.ts
index a4ae86c27..7ca9443ff 100644
--- a/packages/producer/src/services/htmlCompiler.test.ts
+++ b/packages/producer/src/services/htmlCompiler.test.ts
@@ -459,7 +459,10 @@ describe("detectRenderModeHints", () => {
 });
 
 describe("template-wrapped sub-composition media offsets", () => {
-  function writeTemplateWrappedProject(hostAttrs: string): {
+  function writeTemplateWrappedProject(
+    hostAttrs: string,
+    mediaAttrs: string = 'data-start="0" data-duration="4"',
+  ): {
     projectDir: string;
     indexPath: string;
   } {
@@ -506,8 +509,7 @@ describe("template-wrapped sub-composition media offsets", () => {
     <video
       id="scene-video"
       src="../assets/clip.mp4"
-      data-start="0"
-      data-duration="4"
+      ${mediaAttrs}
       data-track-index="0"
     ></video>
     <script>
@@ -570,4 +572,26 @@ describe("template-wrapped sub-composition media offsets", () => {
       end: 6,
     });
   });
+
+  it("offsets scene-local media in compositions that start much later on the timeline", async () => {
+    const { projectDir, indexPath } = writeTemplateWrappedProject(
+      'data-start="20" data-duration="6" data-width="640" data-height="360"',
+      'data-start="1.5" data-duration="4"',
+    );
+
+    const compiled = await compileForRender(projectDir, indexPath, projectDir);
+
+    expect(compiled.videos).toHaveLength(1);
+    expect(compiled.videos[0]).toMatchObject({
+      id: "scene-video",
+      start: 21.5,
+      end: 25.5,
+    });
+    expect(compiled.audios).toHaveLength(1);
+    expect(compiled.audios[0]).toMatchObject({
+      id: "scene-video-audio",
+      start: 21.5,
+      end: 25.5,
+    });
+  });
 });
diff --git a/packages/producer/src/services/renderOrchestrator.test.ts b/packages/producer/src/services/renderOrchestrator.test.ts
index c805fd026..7902bde8a 100644
--- a/packages/producer/src/services/renderOrchestrator.test.ts
+++ b/packages/producer/src/services/renderOrchestrator.test.ts
@@ -8,6 +8,7 @@ import type { CompiledComposition } from "./htmlCompiler.js";
 import {
   applyRenderModeHints,
   extractStandaloneEntryFromIndex,
+  projectBrowserEndToCompositionTimeline,
   writeCompiledArtifacts,
 } from "./renderOrchestrator.js";
 import { toExternalAssetKey } from "../utils/paths.js";
@@ -244,3 +245,17 @@ describe("applyRenderModeHints", () => {
     expect(log.warn).not.toHaveBeenCalled();
   });
 });
+
+describe("projectBrowserEndToCompositionTimeline", () => {
+  it("keeps end unchanged when browser and compiled starts share the same origin", () => {
+    expect(projectBrowserEndToCompositionTimeline(2, 2, 6)).toBe(6);
+  });
+
+  it("reprojects a scene-local browser end into the compiled host timeline", () => {
+    expect(projectBrowserEndToCompositionTimeline(4.417, 0, 85.52)).toBeCloseTo(89.937, 6);
+  });
+
+  it("preserves scene-local media offsets inside compositions that start much later", () => {
+    expect(projectBrowserEndToCompositionTimeline(21.5, 1.5, 5.5)).toBe(25.5);
+  });
+});
diff --git a/packages/producer/src/services/renderOrchestrator.ts b/packages/producer/src/services/renderOrchestrator.ts
index 33afa3200..cf7da61a4 100644
--- a/packages/producer/src/services/renderOrchestrator.ts
+++ b/packages/producer/src/services/renderOrchestrator.ts
@@ -321,6 +321,24 @@ export interface CompositionMetadata {
   height: number;
 }
 
+const BROWSER_MEDIA_EPSILON = 0.0001;
+
+/**
+ * Browser-discovered media inside inlined sub-compositions can still report
+ * scene-local timing from the merged DOM (e.g. start=0, end=85.52) while the
+ * compiled metadata is already offset into the parent host timeline
+ * (e.g. start=4.417, end=89.937). Reproject browser end-time into the
+ * compiled element's time origin before reconciling it back into the render
+ * metadata.
+ */
+export function projectBrowserEndToCompositionTimeline(
+  existingStart: number,
+  browserStart: number,
+  browserEnd: number,
+): number {
+  return browserEnd + (existingStart - browserStart);
+}
+
 function updateJobStatus(
   job: RenderJob,
   status: RenderStatus,
@@ -1191,13 +1209,22 @@ export async function executeRenderJob(
                 if (existing.src !== src) {
                   existing.src = src;
                 }
-                if (el.end > 0 && (existing.end <= 0 || Math.abs(existing.end - el.end) > 0.0001)) {
-                  existing.end = el.end;
+                const projectedEnd = projectBrowserEndToCompositionTimeline(
+                  existing.start,
+                  el.start,
+                  el.end,
+                );
+                if (
+                  projectedEnd > 0 &&
+                  (existing.end <= 0 ||
+                    Math.abs(existing.end - projectedEnd) > BROWSER_MEDIA_EPSILON)
+                ) {
+                  existing.end = projectedEnd;
                 }
                 if (
                   el.mediaStart > 0 &&
                   (existing.mediaStart <= 0 ||
-                    Math.abs(existing.mediaStart - el.mediaStart) > 0.0001)
+                    Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)
                 ) {
                   existing.mediaStart = el.mediaStart;
                 }
@@ -1224,17 +1251,29 @@ export async function executeRenderJob(
                 if (existing.src !== src) {
                   existing.src = src;
                 }
-                if (el.end > 0 && (existing.end <= 0 || Math.abs(existing.end - el.end) > 0.0001)) {
-                  existing.end = el.end;
+                const projectedEnd = projectBrowserEndToCompositionTimeline(
+                  existing.start,
+                  el.start,
+                  el.end,
+                );
+                if (
+                  projectedEnd > 0 &&
+                  (existing.end <= 0 ||
+                    Math.abs(existing.end - projectedEnd) > BROWSER_MEDIA_EPSILON)
+                ) {
+                  existing.end = projectedEnd;
                 }
                 if (
                   el.mediaStart > 0 &&
                   (existing.mediaStart <= 0 ||
-                    Math.abs(existing.mediaStart - el.mediaStart) > 0.0001)
+                    Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)
                 ) {
                   existing.mediaStart = el.mediaStart;
                 }
-                if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > 0.0001) {
+                if (
+                  el.volume > 0 &&
+                  Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON
+                ) {
                   existing.volume = el.volume;
                 }
               }

From 3b6d262769685fb98018fa7e2033311466f03731 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miguel=20=C3=81ngel?= <miguel.sierra@heygen.com>
Date: Fri, 24 Apr 2026 12:40:01 -0400
Subject: [PATCH 4/4] fix(ci): avoid paths-filter PR API timeouts

---
 .github/workflows/ci.yml             | 8 +++++++-
 .github/workflows/player-perf.yml    | 7 ++++++-
 .github/workflows/regression.yml     | 8 +++++++-
 .github/workflows/windows-render.yml | 8 +++++++-
 4 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c11208110..38b8c2837 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -24,10 +24,16 @@ jobs:
     outputs:
       code: ${{ steps.filter.outputs.code }}
     steps:
+      # Force git-based change detection instead of the pull_request REST API.
+      # The API path can fail the whole workflow on transient listFiles
+      # timeouts before any real CI work starts.
       - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
+        with:
+          fetch-depth: 0
+      - uses: dorny/paths-filter@v4
         id: filter
         with:
+          token: ""
           filters: |
             code:
               - "packages/**"
diff --git a/.github/workflows/player-perf.yml b/.github/workflows/player-perf.yml
index 4a990bdf2..c22dbe6eb 100644
--- a/.github/workflows/player-perf.yml
+++ b/.github/workflows/player-perf.yml
@@ -17,10 +17,15 @@ jobs:
     outputs:
       perf: ${{ steps.filter.outputs.perf }}
     steps:
+      # Force git-based change detection instead of the pull_request REST API.
+      # The API path can fail the perf workflow on transient listFiles timeouts.
       - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
+        with:
+          fetch-depth: 0
+      - uses: dorny/paths-filter@v4
         id: filter
         with:
+          token: ""
           filters: |
             perf:
               - "packages/player/**"
diff --git a/.github/workflows/regression.yml b/.github/workflows/regression.yml
index 98045c632..5d52bd702 100644
--- a/.github/workflows/regression.yml
+++ b/.github/workflows/regression.yml
@@ -14,10 +14,16 @@ jobs:
     outputs:
       code: ${{ steps.filter.outputs.code }}
     steps:
+      # Force git-based change detection instead of the pull_request REST API.
+      # The API path can fail the whole workflow on transient listFiles
+      # timeouts before any regression shard even starts.
       - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
+        with:
+          fetch-depth: 0
+      - uses: dorny/paths-filter@v4
         id: filter
         with:
+          token: ""
           filters: |
             code:
               - "packages/core/**"
diff --git a/.github/workflows/windows-render.yml b/.github/workflows/windows-render.yml
index ea727dfa0..feeeb7925 100644
--- a/.github/workflows/windows-render.yml
+++ b/.github/workflows/windows-render.yml
@@ -36,10 +36,16 @@ jobs:
     outputs:
       code: ${{ steps.filter.outputs.code }}
     steps:
+      # Force git-based change detection instead of the pull_request REST API.
+      # The API path can fail the workflow on transient listFiles timeouts
+      # before the Windows render jobs even start.
       - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
+        with:
+          fetch-depth: 0
+      - uses: dorny/paths-filter@v4
         id: filter
         with:
+          token: ""
           filters: |
             code:
               - "packages/**"