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.
This commit is contained in:
Michael Wang
2026-11-17 07:01:38 +00:00
committed by GitHub
parent d7d416124f
commit e21f56dcad
2 changed files with 219 additions and 27 deletions
@@ -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 = `<img src="a.png" data-var-src="missing">`.repeat(2_000);
const html = `<html><body><div data-variable-values='${values}'>${images}</div></body></html>`;
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 = `<img src="a.png" data-var-src="missing">`.repeat(2_000);
const html = `<html><body>${"<div>".repeat(depth)}${images}${"</div>".repeat(depth)}</body></html>`;
expect(hasVariableBoundMedia(html, undefined)).toBe(true);
});
});
describe("hasRuntimeMediaChanges", () => {
const page = (body: string, script: string) =>
`<html><body>${body}<script>${script}</script></body></html>`;
it("finds a source write aimed at a video by id or by selector", () => {
const video = `<div class="scene"><video id="clip" src="a.mp4"></video></div>`;
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(
`<video><source id="s" src="a.mp4"></video>`,
`document.getElementById("s").src = "b";`,
),
),
).toBe(true);
});
it("ignores source writes aimed at other elements", () => {
const body = `<img id="poster" class="still" src="a.png"><video id="clip" src="a.mp4"></video>`;
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(`<img id="clip">`, `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) => `<div id="d${i}"></div>`);
const writes = Array.from(
{ length: count },
(_, i) => `document.getElementById("n${i}").src = "x";`,
);
const html = page(`${divs.join("")}<video id="clip" src="a.mp4"></video>`, 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 =
`<!doctype html><head><script>document.getElementById("clip").src = "b.mp4";</script></head>` +
`<body><video id="clip" src="a.mp4"></video></body>`;
expect(hasRuntimeMediaChanges(html)).toBe(true);
});
it("lets the browser probe decide when there are too many selectors to check", () => {
const videos = `<video src="a.mp4"></video>`.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 = `<video src="a.mp4"></video>`.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(`<video></video>`, 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(`<video src="a.mp4"></video>`, 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("<html></html>").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;
@@ -189,26 +189,58 @@ export function hasAutoStartVideos(html: string): boolean {
type VariablesByComp = Record<string, Record<string, unknown>>;
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<Element, ReadonlySet<string>>;
steps: number;
}
function variableIdsOn(scan: VariableScopeScan, element: Element): ReadonlySet<string> {
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<string, unknown> | 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<string, unknown> | 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<string>();
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;