Skip to content

Write HTML. Render video. Built for agents.

5.9 KB
Raw Blame
import { AFTER_FONTS_CLAIM, DEFERRED_FILE, typeAfterFonts } from "../compiler/scriptRuns";
import { postRuntimeMessage } from "./bridge";

/** Past the 3 s a font-display:block face holds text back, far under the engine's 45 s player-ready wait. */
export const FONT_WAIT_TIMEOUT_MS = 5000;

(window as unknown as Record<string, unknown>)[AFTER_FONTS_CLAIM] = true;

/** Resolves once the page's web fonts are ready or the timeout passes, reporting faces still loading. */
export async function waitForFonts(): Promise<void> {
  const fonts = document.fonts;
  if (!fonts) return;
  // Layout starts loading the faces laid-out text uses; with none loading, ready resolves at once.
  void document.body?.offsetHeight;
  let timer: ReturnType<typeof setTimeout> | undefined;
  const timedOut = await Promise.race([
    fonts.ready.then(() => false),
    new Promise<boolean>((resolve) => (timer = setTimeout(resolve, FONT_WAIT_TIMEOUT_MS, true))),
  ]);
  clearTimeout(timer);
  if (!timedOut) return;
  const loadingFamilies = [
    ...new Set(
      Array.from(fonts)
        .filter((face) => face.status === "loading")
        .map((face) => face.family),
    ),
  ];
  console.warn(
    `[hyperframes] fonts still loading after ${FONT_WAIT_TIMEOUT_MS} ms, composition scripts run without them: ${loadingFamilies.join(", ")}`,
  );
  postRuntimeMessage({
    source: "hf-preview",
    type: "diagnostic",
    code: "runtime_font_wait_timeout",
    details: { loadingFamilies, timeoutMs: FONT_WAIT_TIMEOUT_MS },
  });
}

type HeldListener = {
  target: EventTarget;
  type: string;
  listener: EventListenerOrEventListenerObject;
};

/** Queues DOMContentLoaded listeners, and load listeners once the page has loaded: both events have passed. */
function holdPassedLoadEvents(target: Document | Window, held: HeldListener[]): () => void {
  const own = Object.getOwnPropertyDescriptor(target, "addEventListener");
  const add = target.addEventListener;
  const hold = (
    type: string,
    listener: EventListenerOrEventListenerObject | null,
    options?: boolean | AddEventListenerOptions,
  ) => {
    if (!listener) return;
    const passed =
      type === "DOMContentLoaded" ||
      (type === "load" && target === window && document.readyState === "complete");
    if (passed) held.push({ target, type, listener });
    else add.call(target, type, listener, options);
  };
  target.addEventListener = hold;
  return () => {
    // A script that wrapped it meanwhile keeps its wrapper.
    if (target.addEventListener !== hold) return;
    if (own) Object.defineProperty(target, "addEventListener", own);
    else delete (target as { addEventListener?: unknown }).addEventListener;
  };
}

function runInPlace(el: Element): HTMLScriptElement | undefined {
  if (!el.isConnected) return;
  const script = document.createElement("script");
  for (const { name, value } of Array.from(el.attributes)) script.setAttribute(name, value);
  const type = typeAfterFonts(el);
  if (type === null) script.removeAttribute("type");
  else script.setAttribute("type", type);
  // Not async: inserted src and module scripts then run in insertion order.
  script.async = el.hasAttribute("async");
  script.text = el.textContent ?? "";
  el.replaceWith(script);
  return script;
}

export const PREVIEW_SCRIPT_SLICE_MS = 50;

/** A render's virtual clock holds every timer until it advances, so only a preview gives the page turns. */
const givesTurns = () => !(window as { __HF_VIRTUAL_TIME__?: unknown }).__HF_VIRTUAL_TIME__;

function nextUnclampedTask(): Promise<void> {
  const scheduler = (globalThis as { scheduler?: { yield?: () => Promise<void> } }).scheduler;
  if (typeof scheduler?.yield === "function") return scheduler.yield();
  return new Promise((resolve) => {
    const channel = new MessageChannel();
    channel.port1.onmessage = () => {
      channel.port1.close();
      resolve();
    };
    channel.port2.postMessage(null);
  });
}

const loaded = (script: HTMLScriptElement) =>
  new Promise((resolve) => {
    script.addEventListener("load", resolve);
    script.addEventListener("error", resolve);
  });

// An inline module fires no load event; a module queued after the others runs once they have.
function afterQueuedModules(): Promise<unknown> {
  const sentinel = document.createElement("script");
  sentinel.type = "module";
  sentinel.async = false;
  sentinel.text = `document.dispatchEvent(new Event("hf-after-fonts-modules"))`;
  const ran = new Promise((resolve) =>
    document.addEventListener("hf-after-fonts-modules", resolve, { once: true }),
  );
  document.body.appendChild(sentinel);
  return ran.then(() => sentinel.remove());
}

/**
 * Once fonts are ready, runs each script in its own place in parser order (classic, then module and
 * deferred), calls `afterRun`, then the load listeners the scripts added after those events passed.
 */
export async function runScriptsAfterFonts(
  scripts: readonly Element[],
  afterRun?: () => void,
): Promise<void> {
  await waitForFonts();
  const isLate = (el: Element) => typeAfterFonts(el) === "module" || el.matches(DEFERRED_FILE);
  const held: HeldListener[] = [];
  const release = [document, window].map((target) => holdPassedLoadEvents(target, held));
  const turns = givesTurns();
  let slice = performance.now();
  for (const el of [...scripts.filter((el) => !isLate(el)), ...scripts.filter(isLate)]) {
    if (turns && performance.now() - slice > PREVIEW_SCRIPT_SLICE_MS) {
      await nextUnclampedTask();
      slice = performance.now();
    }
    const script = runInPlace(el);
    if (script?.hasAttribute("src") && !script.async && !script.noModule) await loaded(script);
    else if (typeAfterFonts(el) === "module") await afterQueuedModules();
  }
  for (const undo of release) undo();
  afterRun?.();
  for (const { target, type, listener } of held) {
    const event = new Event(type);
    try {
      if (typeof listener === "function") listener.call(target, event);
      else listener.handleEvent(event);
    } catch (error) {
      reportError(error);
    }
  }
}