From e21f56dcad6d2afe8a650b53b41df396959c07f5 Mon Sep 17 00:00:00 2001 From: Michael Wang Date: Tue, 17 Nov 2026 07:01:38 +0000 Subject: [PATCH] fix(producer): keep the probe stage's media pre-checks linear in page size (#8044) * fix(producer): keep the probe stage's media pre-checks linear in page size hasRuntimeMediaChanges now collects the page's media elements in one walk, answers id lookups from a set, de-duplicates selectors and checks them only against media elements. Past a fixed number of checks it lets the browser probe decide. hasVariableBoundMedia parses each element's variable attributes once per scan and shares one step budget across the ancestor walks. Past the budget it gives the conservative answer and probes in the browser. * fix(producer): bound the media-source scan by selector length, and walk every top-level element The selector budget now counts selector characters times media elements, since each match parses the selector again. A selector with a sibling combinator goes to the browser probe. The media walk starts from every top-level element, so a page written without the html tag is still scanned. Tests now count lookups and JSON parses instead of timing them. --- .../services/render/stages/probeStage.test.ts | 134 +++++++++++++++++- .../src/services/render/stages/probeStage.ts | 112 +++++++++++---- 2 files changed, 219 insertions(+), 27 deletions(-) diff --git a/packages/producer/src/services/render/stages/probeStage.test.ts b/packages/producer/src/services/render/stages/probeStage.test.ts index d347b48054..49320cd339 100644 --- a/packages/producer/src/services/render/stages/probeStage.test.ts +++ b/packages/producer/src/services/render/stages/probeStage.test.ts @@ -1,4 +1,4 @@ -import { afterAll, describe, expect, it, mock } from "bun:test"; +import { afterAll, describe, expect, it, mock, spyOn } from "bun:test"; import { mkdtempSync, rmSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; @@ -14,8 +14,10 @@ import { collectRenderMedia } from "../../renderMediaCollector.js"; const workDir = mkdtempSync(join(tmpdir(), "hf-stage-test-")); afterAll(() => rmSync(workDir, { recursive: true, force: true })); import { createHash } from "node:crypto"; +import { parseHTML } from "linkedom"; import { hasAutoStartVideos, + hasRuntimeMediaChanges, hasScriptedAudioVolumeAutomation, hasVariableBoundMedia, reportedLengthSource, @@ -445,6 +447,136 @@ describe("hasVariableBoundMedia", () => { }); }); +describe("hasVariableBoundMedia — page size", () => { + it("parses a large variables attribute once, not once per bound element", () => { + const values = JSON.stringify( + Object.fromEntries(Array.from({ length: 1_000 }, (_, i) => [`k${i}`, "v"])), + ); + const images = ``.repeat(2_000); + const html = `
${images}
`; + const parse = spyOn(JSON, "parse"); + try { + expect(hasVariableBoundMedia(html, undefined)).toBe(false); + expect(parse.mock.calls.length).toBeLessThanOrEqual(1); + } finally { + parse.mockRestore(); + } + }); + + it("takes the conservative answer when the ancestor walks run past their budget", () => { + const depth = 600; + const images = ``.repeat(2_000); + const html = `${"
".repeat(depth)}${images}${"
".repeat(depth)}`; + + expect(hasVariableBoundMedia(html, undefined)).toBe(true); + }); +}); + +describe("hasRuntimeMediaChanges", () => { + const page = (body: string, script: string) => + `${body}`; + + it("finds a source write aimed at a video by id or by selector", () => { + const video = `
`; + expect( + hasRuntimeMediaChanges(page(video, `document.getElementById("clip").src = "b.mp4";`)), + ).toBe(true); + expect( + hasRuntimeMediaChanges(page(video, `document.querySelector(".scene video").src = "b.mp4";`)), + ).toBe(true); + expect( + hasRuntimeMediaChanges( + page( + ``, + `document.getElementById("s").src = "b";`, + ), + ), + ).toBe(true); + }); + + it("ignores source writes aimed at other elements", () => { + const body = ``; + const script = `document.getElementById("poster").src = "b.png"; + document.querySelector(".still").setAttribute("src", "c.png"); + document.querySelector("[[bad").src = "d.png";`; + expect(hasRuntimeMediaChanges(page(body, script))).toBe(false); + expect( + hasRuntimeMediaChanges(page(``, `document.getElementById("clip").src = "b";`)), + ).toBe(false); + }); + + it("answers id writes from one index, with no document lookup per write", () => { + const count = 2_000; + const divs = Array.from({ length: count }, (_, i) => `
`); + const writes = Array.from( + { length: count }, + (_, i) => `document.getElementById("n${i}").src = "x";`, + ); + const html = page(`${divs.join("")}`, writes.join("\n")); + const lookups = documentLookupSpies(); + try { + expect(hasRuntimeMediaChanges(html)).toBe(false); + expect(lookups.getElementById.mock.calls.length).toBe(0); + expect(lookups.querySelectorAll.mock.calls.length).toBeLessThanOrEqual(1); + } finally { + lookups.restore(); + } + }); + + it("finds a source write on a page written without the html, head or body tags", () => { + const html = + `` + + ``; + expect(hasRuntimeMediaChanges(html)).toBe(true); + }); + + it("lets the browser probe decide when there are too many selectors to check", () => { + const videos = ``.repeat(50); + const writes = Array.from( + { length: 8_000 }, + (_, i) => `document.querySelector(".q${i}").src = "x";`, + ); + expect(hasRuntimeMediaChanges(page(videos, writes.join("\n")))).toBe(true); + }); + + it("lets the browser probe decide a long selector against many media elements", () => { + const videos = ``.repeat(100); + const selector = `${".nope ".repeat(2_000)}video`; + const script = `document.querySelector(${JSON.stringify(selector)}).src = "x";`; + expect(hasRuntimeMediaChanges(page(videos, script))).toBe(true); + expect(hasRuntimeMediaChanges(page(``, script))).toBe(false); + }); + + it("lets the browser probe decide a selector with a sibling combinator", () => { + const script = `document.querySelector(".nope ~ .none").src = "x";`; + expect(hasRuntimeMediaChanges(page(``, script))).toBe(true); + }); +}); + +/** Spies on the linkedom document's own lookups, wherever on its prototype chain they live. */ +function documentLookupSpies() { + const owner = (name: string): object => { + for ( + let proto = Object.getPrototypeOf(parseHTML("").document); + proto; + proto = Object.getPrototypeOf(proto) + ) { + if (Object.hasOwn(proto, name)) return proto; + } + throw new Error(`no ${name} on the document`); + }; + const getElementById = spyOn(owner("getElementById") as Document, "getElementById"); + const querySelectorAll = spyOn(owner("querySelectorAll") as Document, "querySelectorAll"); + return { + getElementById, + querySelectorAll, + restore() { + getElementById.mockRestore(); + querySelectorAll.mockRestore(); + }, + }; +} + describe("runProbeStage — forceScreenshot threading", () => { it("runs media-type preflight after the browser-reconciliation phase", async () => { mediaPreflightCallCount = 0; diff --git a/packages/producer/src/services/render/stages/probeStage.ts b/packages/producer/src/services/render/stages/probeStage.ts index 0d909fcda8..9a0e5bdc18 100644 --- a/packages/producer/src/services/render/stages/probeStage.ts +++ b/packages/producer/src/services/render/stages/probeStage.ts @@ -189,26 +189,58 @@ export function hasAutoStartVideos(html: string): boolean { type VariablesByComp = Record>; -function scopedVariablesFor(element: Element, variablesByComp: VariablesByComp) { - const scope = element.closest("[data-composition-id]"); - const compId = scope?.getAttribute("data-composition-id")?.trim() ?? ""; - return compId && Object.hasOwn(variablesByComp, compId) ? variablesByComp[compId] : undefined; +/** Ancestor steps one variable-media scan may take before it gives the conservative answer. */ +const MAX_VARIABLE_SCOPE_STEPS = 1_000_000; + +interface VariableScopeScan { + readonly ids: Map>; + steps: number; } +function variableIdsOn(scan: VariableScopeScan, element: Element): ReadonlySet { + let ids = scan.ids.get(element); + if (!ids) { + ids = new Set([ + ...Object.keys(parseHostVariableValues(element)), + ...Object.keys(readDeclaredDefaults(element)), + ]); + scan.ids.set(element, ids); + } + return ids; +} + +/** The compiled table of the element's composition scope; null once the scan is out of steps. */ +function scopedVariablesFor( + scan: VariableScopeScan, + element: Element, + variablesByComp: VariablesByComp, +): Record | undefined | null { + for (let node: Element | null = element; node; node = node.parentElement) { + if (++scan.steps > MAX_VARIABLE_SCOPE_STEPS) return null; + if (!node.hasAttribute("data-composition-id")) continue; + const compId = node.getAttribute("data-composition-id")?.trim() ?? ""; + return compId && Object.hasOwn(variablesByComp, compId) ? variablesByComp[compId] : undefined; + } + return undefined; +} + +/** True when the variable has a value, or when the scan ran out of steps and cannot rule one out. */ function variableHasValue( + scan: VariableScopeScan, element: Element, variableId: string, variables: Record | undefined, variablesByComp: VariablesByComp, ): boolean { if (variables && Object.hasOwn(variables, variableId)) return true; - const scoped = scopedVariablesFor(element, variablesByComp); + const scoped = scopedVariablesFor(scan, element, variablesByComp); + if (scoped === null) return true; if (scoped) return Object.hasOwn(scoped, variableId); for (let scope = element.parentElement; scope; scope = scope.parentElement) { - if (Object.hasOwn(parseHostVariableValues(scope), variableId)) return true; - if (Object.hasOwn(readDeclaredDefaults(scope), variableId)) return true; + if (++scan.steps > MAX_VARIABLE_SCOPE_STEPS) return true; + if (variableIdsOn(scan, scope).has(variableId)) return true; } - return Object.hasOwn(readDeclaredDefaults(element.ownerDocument.documentElement), variableId); + return variableIdsOn(scan, element.ownerDocument.documentElement).has(variableId); } /** @@ -221,13 +253,16 @@ export function hasVariableBoundMedia( variablesByComp: VariablesByComp = {}, ): boolean { const { document } = parseHTML(html); + const scan: VariableScopeScan = { ids: new Map(), steps: 0 }; return Array.from( document.querySelectorAll( "img[data-var-src], audio[data-var-src], video[data-var-src], source[data-var-src]", ), ).some((element) => { const variableId = element.getAttribute("data-var-src")?.trim(); - return Boolean(variableId && variableHasValue(element, variableId, variables, variablesByComp)); + return Boolean( + variableId && variableHasValue(scan, element, variableId, variables, variablesByComp), + ); }); } @@ -289,13 +324,33 @@ function reconcileBrowserMediaEnd( return existingEnd <= 0 ? projectedEnd : Math.min(existingEnd, projectedEnd); } +/** Selector characters times media elements matched statically before the browser probe decides. */ +const MAX_MEDIA_SELECTOR_WORK = 1_000_000; +// Sibling combinators can make one match walk the page; the browser probe answers those. +const SIBLING_COMBINATOR = /[~+]/; + +function managedMediaElements(document: Document): Element[] { + const managed: Element[] = []; + const pending: Array<{ element: Element; inMedia: boolean }> = []; + for (const element of Array.from(document.children)) pending.push({ element, inMedia: false }); + for (let next = pending.pop(); next; next = pending.pop()) { + const name = next.element.tagName.toLowerCase(); + const isMedia = name === "video" || name === "audio"; + if (isMedia || (next.inMedia && name === "source")) managed.push(next.element); + for (const child of Array.from(next.element.children)) { + pending.push({ element: child, inMedia: next.inMedia || isMedia }); + } + } + return managed; +} + /** * Runtime-created media does not exist when the static compiler scans the HTML. * Launch a browser probe so discoverMediaFromBrowser can reconcile it before * extraction, even when the root duration is already known. External script * sources have no inline text to inspect and remain a known heuristic gap. */ -function hasRuntimeMediaChanges(html: string): boolean { +export function hasRuntimeMediaChanges(html: string): boolean { const { document } = parseHTML(html); const scriptBodies = [...document.querySelectorAll("script")].map( (script) => script.textContent ?? "", @@ -308,25 +363,30 @@ function hasRuntimeMediaChanges(html: string): boolean { ); if (insertedMedia) return true; - const isManagedMedia = (element: Element): boolean => { - const name = element.tagName.toLowerCase(); - if (name === "video" || name === "audio") return true; - return name === "source" && element.closest("video, audio") !== null; - }; + const managed = managedMediaElements(document); + if (managed.length === 0) return false; + const managedIds = new Set(managed.map((element) => element.getAttribute("id")).filter(Boolean)); + const selectors = new Set(); + let selectorChars = 0; for (const script of scriptBodies) { for (const mutation of extractMediaSrcMutations(script)) { - try { - const id = /^#[A-Za-z_][\w-]*$/.test(mutation.selector) ? mutation.selector.slice(1) : null; - const idTarget = id ? document.getElementById(id) : null; - const targets = id - ? idTarget - ? [idTarget] - : [] - : [...document.querySelectorAll(mutation.selector)]; - if (targets.some(isManagedMedia)) return true; - } catch { - // Invalid selectors are diagnosed by lint and cannot prove a media target here. + const id = /^#[A-Za-z_][\w-]*$/.test(mutation.selector) ? mutation.selector.slice(1) : null; + if (id) { + if (managedIds.has(id)) return true; + continue; } + if (selectors.has(mutation.selector)) continue; + if (SIBLING_COMBINATOR.test(mutation.selector)) return true; + selectors.add(mutation.selector); + selectorChars += mutation.selector.length; + if (selectorChars * managed.length > MAX_MEDIA_SELECTOR_WORK) return true; + } + } + for (const selector of selectors) { + try { + if (managed.some((element) => element.matches(selector))) return true; + } catch { + // Invalid selectors are diagnosed by lint and cannot prove a media target here. } } return false;