chore: import upstream snapshot with attribution

2026-07-13 12:58:35 +08:00
commit 85453da49f
4031 changed files with 710987 additions and 0 deletions
@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+
+const target = "src/services/fontData.generated.ts";
+
+if (existsSync(target)) {
+  console.log("[build:fonts] skipped — fontData.generated.ts already exists");
+  process.exit(0);
+}
+
+execSync("node --experimental-strip-types scripts/generate-font-data.ts", {
+  stdio: "inherit",
+});
@@ -0,0 +1,82 @@
+/**
+ * Build script: compile stubs/hf-early-stub.ts → src/generated/hf-early-stub-inline.ts
+ *
+ * Run via: bun run scripts/build-hf-early-stub.ts
+ * (also called automatically as part of `bun run build`)
+ *
+ * Output format mirrors packages/core/scripts/build-hyperframes-runtime-artifact.ts:
+ * a TypeScript module exporting a single string-constant getter that is
+ * compiled by tsc into dist/ — no esbuild, no file I/O, no dynamic paths at
+ * runtime.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildSync } from "esbuild";
+import { execSync } from "node:child_process";
+
+const thisDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(thisDir, "..");
+
+const stubEntry = resolve(repoRoot, "stubs/hf-early-stub.ts");
+const generatedDir = resolve(repoRoot, "src/generated");
+const outPath = resolve(generatedDir, "hf-early-stub-inline.ts");
+
+// ── Compile the stub to a self-contained IIFE ─────────────────────────────────
+const result = buildSync({
+  entryPoints: [stubEntry],
+  bundle: true,
+  write: false,
+  platform: "browser",
+  format: "iife",
+  target: ["es2020"],
+  // Minify for production — the stub is injected on every page load.
+  minify: true,
+  legalComments: "none",
+});
+
+const iife = result.outputFiles[0]?.text ?? "";
+if (!iife) {
+  throw new Error("esbuild produced no output for hf-early-stub.ts");
+}
+
+// ── Write the generated module ────────────────────────────────────────────────
+mkdirSync(generatedDir, { recursive: true });
+
+const escaped = JSON.stringify(iife);
+writeFileSync(
+  outPath,
+  [
+    "// AUTO-GENERATED by scripts/build-hf-early-stub.ts — do not edit",
+    `const HF_EARLY_STUB_IIFE: string = ${escaped};`,
+    "",
+    "/**",
+    " * Returns the pre-built HyperFrames early stub IIFE as a string constant.",
+    " * Inject into <head> before any other scripts so the GSAP batching",
+    " * interceptor is in place when user composition scripts run.",
+    " */",
+    "export function getHfEarlyStub(): string {",
+    "  return HF_EARLY_STUB_IIFE;",
+    "}",
+    "",
+  ].join("\n"),
+  "utf8",
+);
+
+// Format the generated file so `oxfmt --check` passes in CI.
+// Errors are intentionally swallowed — oxfmt unavailable in some envs.
+try {
+  execSync(`bunx oxfmt ${outPath}`, { stdio: "ignore" });
+} catch {
+  // not fatal
+}
+
+console.log(
+  JSON.stringify({
+    event: "hf_early_stub_generated",
+    stubEntry,
+    outPath,
+    bytes: Buffer.byteLength(iife, "utf8"),
+  }),
+);
@@ -0,0 +1,9 @@
+import { discoverProducerTests, summarizeTests } from "./test-classification.mjs";
+
+try {
+  const tests = discoverProducerTests();
+  console.log(JSON.stringify({ event: "producer_tests_classified", ...summarizeTests(tests) }));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
@@ -0,0 +1,169 @@
+/**
+ * Generate embedded font data for deterministic font injection.
+ *
+ * Reads woff2 files from @fontsource/* packages at build time and produces
+ * a TypeScript module with base64 data URIs. This eliminates the runtime
+ * dependency on @fontsource packages, making the CLI self-contained when
+ * bundled via tsup.
+ *
+ * Usage: tsx scripts/generate-font-data.ts
+ */
+
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+type FontFaceSpec = { weight: string; style?: "normal" | "italic" };
+type CanonicalFontSpec = { packageName: string; faces: FontFaceSpec[] };
+
+// Mirror of CANONICAL_FONTS from deterministicFonts.ts — single source of truth
+const CANONICAL_FONTS: Record<string, CanonicalFontSpec> = {
+  inter: {
+    packageName: "@fontsource/inter",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  montserrat: {
+    packageName: "@fontsource/montserrat",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  outfit: {
+    packageName: "@fontsource/outfit",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  nunito: {
+    packageName: "@fontsource/nunito",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  oswald: {
+    packageName: "@fontsource/oswald",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  "league-gothic": {
+    packageName: "@fontsource/league-gothic",
+    faces: [{ weight: "400" }],
+  },
+  "archivo-black": {
+    packageName: "@fontsource/archivo-black",
+    faces: [{ weight: "400" }],
+  },
+  "space-mono": {
+    packageName: "@fontsource/space-mono",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  "ibm-plex-mono": {
+    packageName: "@fontsource/ibm-plex-mono",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  "jetbrains-mono": {
+    packageName: "@fontsource/jetbrains-mono",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  "eb-garamond": {
+    packageName: "@fontsource/eb-garamond",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  "playfair-display": {
+    packageName: "@fontsource/playfair-display",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  "source-code-pro": {
+    packageName: "@fontsource/source-code-pro",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  "noto-sans-jp": {
+    packageName: "@fontsource/noto-sans-jp",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  roboto: {
+    packageName: "@fontsource/roboto",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  "open-sans": {
+    packageName: "@fontsource/open-sans",
+    faces: [{ weight: "400" }, { weight: "700" }],
+  },
+  lato: {
+    packageName: "@fontsource/lato",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+  poppins: {
+    packageName: "@fontsource/poppins",
+    faces: [{ weight: "400" }, { weight: "700" }, { weight: "900" }],
+  },
+};
+
+function packageRoot(packageName: string): string {
+  const packageJsonPath = require.resolve(`${packageName}/package.json`);
+  return dirname(packageJsonPath);
+}
+
+function resolveFontFile(
+  packageName: string,
+  weight: string,
+  style: "normal" | "italic" = "normal",
+): string {
+  const root = packageRoot(packageName);
+  const filesDir = join(root, "files");
+  const slug = packageName.replace("@fontsource/", "");
+  const files = readdirSync(filesDir);
+
+  const exact = `${slug}-latin-${weight}-${style}.woff2`;
+  if (files.includes(exact)) {
+    return join(filesDir, exact);
+  }
+
+  const relaxed = files.find((file) => {
+    return file.endsWith(`-${weight}-${style}.woff2`) && file.includes("-latin-");
+  });
+  if (relaxed) {
+    return join(filesDir, relaxed);
+  }
+
+  throw new Error(`No font asset found for ${packageName} weight=${weight} style=${style}`);
+}
+
+function main() {
+  const entries: Array<{ key: string; dataUri: string }> = [];
+  let totalBytes = 0;
+
+  for (const [, spec] of Object.entries(CANONICAL_FONTS)) {
+    for (const face of spec.faces) {
+      const style = face.style || "normal";
+      const key = `${spec.packageName}:${face.weight}:${style}`;
+      const fontPath = resolveFontFile(spec.packageName, face.weight, style);
+      const content = readFileSync(fontPath);
+      totalBytes += content.length;
+      const dataUri = `data:font/woff2;base64,${content.toString("base64")}`;
+      entries.push({ key, dataUri });
+    }
+  }
+
+  const lines = [
+    "/**",
+    " * AUTO-GENERATED — do not edit manually.",
+    ` * Generated by: scripts/generate-font-data.ts`,
+    ` * ${entries.length} font faces, ${Math.round(totalBytes / 1024)}KB raw woff2`,
+    " */",
+    "",
+    "export const EMBEDDED_FONT_DATA: ReadonlyMap<string, string> = new Map([",
+  ];
+
+  for (const entry of entries) {
+    lines.push(`  ["${entry.key}", "${entry.dataUri}"],`);
+  }
+
+  lines.push("]);");
+  lines.push("");
+
+  const outputPath = resolve(__dirname, "../src/services/fontData.generated.ts");
+  writeFileSync(outputPath, lines.join("\n"), "utf8");
+  console.log(
+    `[generate-font-data] Wrote ${entries.length} font faces (${Math.round(totalBytes / 1024)}KB) → ${outputPath}`,
+  );
+}
+
+main();
@@ -0,0 +1,34 @@
+import { spawnSync } from "node:child_process";
+import { discoverProducerTests, PRODUCER_ROOT } from "./test-classification.mjs";
+
+const lane = process.argv[2];
+const requestedRunner = process.argv[3];
+if (lane !== "unit" && lane !== "integration") {
+  throw new Error("Usage: node scripts/run-test-lane.mjs <unit|integration> [bun|vitest]");
+}
+if (requestedRunner && requestedRunner !== "bun" && requestedRunner !== "vitest") {
+  throw new Error(`Unknown test runner: ${requestedRunner}`);
+}
+
+const tests = discoverProducerTests().filter(
+  (test) => test.lane === lane && (!requestedRunner || test.runner === requestedRunner),
+);
+
+function run(args) {
+  const result = spawnSync("bun", args, {
+    cwd: PRODUCER_ROOT,
+    env: { ...process.env, HYPERFRAMES_TEST_LANE: lane },
+    stdio: "inherit",
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+const vitestFiles = tests.filter((test) => test.runner === "vitest").map((test) => test.file);
+if (vitestFiles.length > 0) run(["x", "vitest", "run", ...vitestFiles]);
+
+// Bun's mock.module registry is process-global. Run each file in a fresh
+// process so mocks from one source test cannot mutate another test's imports.
+for (const test of tests.filter((entry) => entry.runner === "bun")) {
+  run(["test", test.file]);
+}
@@ -0,0 +1,75 @@
+// fallow-ignore-file complexity
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const PRODUCER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+// These tests need host capabilities such as Chrome, ffmpeg, worker threads,
+// or local sockets. Keep the list explicit so a filename-only rename does not
+// make Git/fallow re-audit thousands of unchanged test lines as new code.
+const INTEGRATION_TEST_FILES = new Set([
+  "src/services/coreRuntimeBrowser.test.ts",
+  "src/services/deterministicFonts-systemCapture.test.ts",
+  "src/services/distributed/assemble.test.ts",
+  "src/services/distributed/chunkBoundary.test.ts",
+  "src/services/distributed/crossWorkerIdempotency.test.ts",
+  "src/services/distributed/plan.test.ts",
+  "src/services/distributed/planSizeCap.test.ts",
+  "src/services/distributed/renderChunk.test.ts",
+  "src/services/fileServer.test.ts",
+  "src/services/healthWorker.test.ts",
+  "src/utils/audioRegression.test.ts",
+  "src/utils/streamDurationParity.test.ts",
+]);
+
+function collectTestFiles(directory, files = []) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = resolve(directory, entry.name);
+    if (entry.isDirectory()) collectTestFiles(entryPath, files);
+    else if (entry.isFile() && entry.name.endsWith(".test.ts")) files.push(entryPath);
+  }
+  return files;
+}
+
+export function classifyTestSource(filePath, source, integrationFiles = INTEGRATION_TEST_FILES) {
+  const importsBun = /\bfrom\s+["']bun:test["']/.test(source);
+  const importsVitest = /\bfrom\s+["']vitest["']/.test(source);
+  if (importsBun === importsVitest) {
+    const detail = importsBun ? "imports both bun:test and vitest" : "imports neither runner";
+    throw new Error(`${filePath}: ${detail}`);
+  }
+  return {
+    file: filePath,
+    runner: importsBun ? "bun" : "vitest",
+    lane: integrationFiles.has(filePath) ? "integration" : "unit",
+  };
+}
+
+export function discoverProducerTests(producerRoot = PRODUCER_ROOT) {
+  const srcDir = resolve(producerRoot, "src");
+  const files = collectTestFiles(srcDir).map((absolutePath) => ({
+    absolutePath,
+    filePath: relative(producerRoot, absolutePath).replaceAll("\\", "/"),
+  }));
+  const discoveredFiles = new Set(files.map((test) => test.filePath));
+  const staleEntries = [...INTEGRATION_TEST_FILES].filter((file) => !discoveredFiles.has(file));
+  if (staleEntries.length > 0) {
+    throw new Error(`Integration test manifest contains missing files: ${staleEntries.join(", ")}`);
+  }
+  return files
+    .map(({ absolutePath, filePath }) => {
+      return classifyTestSource(filePath, readFileSync(absolutePath, "utf8"));
+    })
+    .sort((left, right) => left.file.localeCompare(right.file));
+}
+
+export function summarizeTests(tests) {
+  const summary = {
+    total: tests.length,
+    unit: { bun: 0, vitest: 0 },
+    integration: { bun: 0, vitest: 0 },
+  };
+  for (const test of tests) summary[test.lane][test.runner] += 1;
+  return summary;
+}
@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  classifyTestSource,
+  discoverProducerTests,
+  summarizeTests,
+} from "./test-classification.mjs";
+
+describe("producer test classification", () => {
+  it("classifies each supported runner into one lane", () => {
+    assert.deepEqual(classifyTestSource("src/a.test.ts", 'import { it } from "bun:test";'), {
+      file: "src/a.test.ts",
+      runner: "bun",
+      lane: "unit",
+    });
+    assert.deepEqual(
+      classifyTestSource(
+        "src/a.test.ts",
+        'import { it } from "vitest";',
+        new Set(["src/a.test.ts"]),
+      ),
+      { file: "src/a.test.ts", runner: "vitest", lane: "integration" },
+    );
+  });
+
+  it("rejects missing and ambiguous runner imports", () => {
+    assert.throws(() => classifyTestSource("src/a.test.ts", "export {};"), /neither runner/);
+    assert.throws(
+      () =>
+        classifyTestSource(
+          "src/a.test.ts",
+          'import { it } from "bun:test"; import { expect } from "vitest";',
+        ),
+      /both bun:test and vitest/,
+    );
+  });
+
+  it("classifies every current source test exactly once", () => {
+    const tests = discoverProducerTests();
+    assert.equal(new Set(tests.map((test) => test.file)).size, tests.length);
+    const summary = summarizeTests(tests);
+    assert.ok(summary.total > 0);
+    assert.equal(
+      summary.unit.bun + summary.unit.vitest + summary.integration.bun + summary.integration.vitest,
+      summary.total,
+    );
+  });
+});
@@ -0,0 +1,79 @@
+/**
+ * Validate the fast-capture (drawElementImage) VIDEO path on real Linux.
+ *
+ * drawElementImage draws a snapshot taken at the paint event; capturing video
+ * needs a fresh per-frame paint. On Linux headless-shell that paint comes from
+ * the per-frame HeadlessExperimental.beginFrame — so video should capture
+ * correctly there (see docs/fast-capture-limitations.md, Limitation 2). This
+ * could not be validated under Docker-on-rosetta (renders hung); this script is
+ * meant to run on a native amd64 Linux runner inside Dockerfile.test.
+ *
+ * Renders a video composition twice — baseline (screenshot) and fast
+ * (drawElement) — and asserts the fast output matches the baseline (PSNR above
+ * threshold), proving the video was captured and not dropped to black.
+ *
+ *   PRODUCER_VALIDATE_COMP=sub-composition-video \
+ *   bunx tsx scripts/validate-fast-video.ts
+ *
+ * Exit 0 = fast video matches baseline; exit 1 = regression (black/stale video).
+ */
+import { execFileSync } from "node:child_process";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { createRenderJob, executeRenderJob } from "../src/index.js";
+
+// `||` not `??` — the workflow passes empty strings on a push trigger (inputs
+// are only populated for workflow_dispatch), and "" must fall through to the default.
+const COMP = process.env.PRODUCER_VALIDATE_COMP || "sub-composition-video";
+const MIN_PSNR = Number.parseFloat(process.env.PRODUCER_VALIDATE_MIN_PSNR || "25");
+const work = mkdtempSync(join(tmpdir(), "fastvideo-"));
+
+process.env.PRODUCER_ENABLE_BROWSER_POOL = "false";
+
+async function render(mode: "baseline" | "fast", out: string): Promise<void> {
+  process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE = mode === "fast" ? "true" : "false";
+  const job = createRenderJob({
+    fps: 30,
+    quality: "high",
+    format: "mp4",
+    workers: 1,
+    useGpu: false,
+    hdrMode: "force-sdr",
+  });
+  await executeRenderJob(job, resolve("tests", COMP, "src"), out);
+}
+
+function psnr(a: string, b: string): number {
+  const out = execFileSync(
+    "bash",
+    ["-c", `ffmpeg -y -i "${a}" -i "${b}" -lavfi psnr -f null - 2>&1`],
+    { encoding: "utf8" },
+  );
+  const m = out.match(/average:(\S+)/);
+  if (!m) throw new Error(`ffmpeg psnr produced no average:\n${out}`);
+  return m[1] === "inf" ? Number.POSITIVE_INFINITY : Number.parseFloat(m[1]);
+}
+
+async function main(): Promise<void> {
+  const baseline = join(work, "baseline.mp4");
+  const fast = join(work, "fast.mp4");
+  console.log(`[validate-fast-video] comp=${COMP} minPsnr=${MIN_PSNR}`);
+  await render("baseline", baseline);
+  await render("fast", fast);
+  const db = psnr(baseline, fast);
+  console.log(`[validate-fast-video] fast-vs-baseline PSNR = ${db} dB`);
+  if (db < MIN_PSNR) {
+    console.error(
+      `[validate-fast-video] FAIL — ${db} dB < ${MIN_PSNR} dB. Fast capture dropped video ` +
+        `(stale/black snapshot). The Linux BeginFrame paint path is not capturing video.`,
+    );
+    process.exit(1);
+  }
+  console.log("[validate-fast-video] PASS — fast video matches baseline.");
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});