@@ -5,6 +5,10 @@ on:
     branches:
       - main
   pull_request:
+    types: [opened, synchronize, reopened, labeled]
+  schedule:
+    - cron: "0 6 * * *"
+  workflow_dispatch:
 
 jobs:
   build-core:
@@ -108,3 +112,39 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - run: pnpm test:install
       - run: pnpm test --project browser-st --project browser-mt
+  heavy:
+    # FATE samples + benchmarks: nightly, on demand, or with the "heavy" PR label.
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'heavy')
+    runs-on: ubuntu-latest
+    needs: [build-core, build-core-mt]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: ffmpeg-core
+          path: packages/core/dist
+      - uses: actions/download-artifact@v4
+        with:
+          name: ffmpeg-core-mt
+          path: packages/core-mt/dist
+      - uses: pnpm/action-setup@v6
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: pnpm
+      - uses: actions/cache@v4
+        with:
+          path: .cache/fate-suite
+          key: fate-suite-v1
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm test:install
+      - name: FATE samples
+        run: pnpm test:heavy
+      - name: Benchmarks
+        if: always()
+        run: pnpm bench
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: heavy-results
+          path: tests/heavy/results
@@ -8,3 +8,5 @@ dist
 
 # Local Netlify folder
 .netlify
+.cache
+tests/heavy/results
@@ -14,7 +14,9 @@
     "postinstall": "pnpm build",
     "pretest": "pnpm build",
     "test": "vitest run",
-    "test:install": "playwright install --with-deps chromium"
+    "test:install": "playwright install --with-deps chromium",
+    "test:heavy": "node tests/heavy/fate.mjs",
+    "bench": "node tests/heavy/bench.mjs"
   },
   "devDependencies": {
     "@ffmpeg/ffmpeg": "workspace:*",
 
@@ -0,0 +1,90 @@
+// Times common jobs with @ffmpeg/core and @ffmpeg/core-mt in Chromium (and
+// native ffmpeg with --native). Inputs are generated, so nothing is downloaded.
+//
+//   pnpm bench
+//   pnpm bench --runs=5 --only=x264 --type=st --native
+//
+// Prints a table and writes tests/heavy/results/bench.json.
+import { mkdirSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir, cpus } from "node:os";
+import { join } from "node:path";
+import { chromium } from "playwright";
+import { startServer, root } from "../helpers/server.js";
+
+const args = Object.fromEntries(
+  process.argv.slice(2).map((a) => {
+    const [key, value = true] = a.replace(/^--/, "").split("=");
+    return [key, value];
+  })
+);
+const runs = Number(args.runs ?? 3);
+
+const video = (size) => ["-f", "lavfi", "-i", `testsrc2=s=${size}:r=30:d=5`];
+const h264 = (size) => [...video(size), "-c:v", "libx264", "-preset", "ultrafast", "-f", "mp4", "/in"];
+const wav = ["-f", "lavfi", "-i", "sine=f=440:d=30", "-ac", "2", "-f", "wav", "/in"];
+
+// name, untimed setup writing /in, timed command reading /in
+const JOBS = [
+  ["decode h264 1080p 5s", h264("1920x1080"), ["-i", "/in", "-f", "null", "-"]],
+  ["x264 veryfast 720p 5s", h264("1280x720"), ["-i", "/in", "-c:v", "libx264", "-preset", "veryfast", "-f", "mp4", "/out"]],
+  ["vp9 realtime 480p 5s", h264("854x480"), ["-i", "/in", "-c:v", "libvpx-vp9", "-deadline", "realtime", "-cpu-used", "8", "-f", "webm", "/out"]],
+  ["scale 1080p to 480p", h264("1920x1080"), ["-i", "/in", "-vf", "scale=-2:480", "-f", "null", "-"]],
+  ["remux mp4 to mkv", h264("1920x1080"), ["-i", "/in", "-c", "copy", "-f", "matroska", "/out"]],
+  ["aac encode 30s", wav, ["-i", "/in", "-c:a", "aac", "-f", "ipod", "/out"]],
+  ["mp3 encode 30s", wav, ["-i", "/in", "-f", "mp3", "/out"]],
+  ["opus encode 30s", wav, ["-i", "/in", "-c:a", "libopus", "-f", "ogg", "/out"]],
+].filter(([name]) => !args.only || name.includes(args.only));
+
+const median = (xs) => [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)];
+
+function native(setup, command) {
+  const dir = mkdtempSync(join(tmpdir(), "ffbench-"));
+  const local = (list) => list.map((a) => (a === "/in" || a === "/out" ? join(dir, a) : a));
+  spawnSync("ffmpeg", ["-y", "-v", "error", ...local(setup)]);
+  const times = [];
+  for (let i = 0; i < runs; i++) {
+    const start = performance.now();
+    spawnSync("ffmpeg", ["-y", "-v", "error", ...local(command)]);
+    times.push(performance.now() - start);
+  }
+  rmSync(dir, { recursive: true });
+  return Math.round(median(times));
+}
+
+const { server, url } = await startServer();
+const browser = await chromium.launch();
+const results = {};
+
+for (const type of (args.type ?? "st,mt").split(",")) {
+  const page = await browser.newPage();
+  await page.goto(`${url}/tests/heavy/page.html?type=${type}`);
+  await page.waitForFunction(() => window.ready);
+  for (const [name, setup, command] of JOBS) {
+    const times = [];
+    for (let i = 0; i < runs; i++) {
+      const r = await page.evaluate((job) => window.run(job), { setup, args: command });
+      if (r.ret !== 0) throw new Error(`${name} (${type}) failed: ${r.tail}`);
+      times.push(r.ms);
+    }
+    (results[name] ??= {})[type] = median(times);
+    console.log(`${type} ${name}: ${results[name][type]} ms`);
+  }
+  await page.close();
+}
+await browser.close();
+server.close();
+
+if (args.native) {
+  for (const [name, setup, command] of JOBS) results[name].native = native(setup, command);
+}
+
+const cols = [...(args.type ?? "st,mt").split(","), ...(args.native ? ["native"] : [])];
+console.log(`\n| job | ${cols.join(" ms | ")} ms |\n|---|${cols.map(() => "---:").join("|")}|`);
+for (const [name, r] of Object.entries(results)) console.log(`| ${name} | ${cols.map((c) => r[c]).join(" | ")} |`);
+
+mkdirSync(join(root, "tests/heavy/results"), { recursive: true });
+writeFileSync(
+  join(root, "tests/heavy/results/bench.json"),
+  JSON.stringify({ date: new Date().toISOString(), cpu: cpus()[0].model, cores: cpus().length, runs, results }, null, 2)
+);
@@ -0,0 +1,158 @@
+// Decodes every sample of FFmpeg's FATE suite with ffmpeg.wasm and compares
+// the result with tests/heavy/baseline/fate-<type>.json.
+//
+//   pnpm test:heavy                     st and mt, fails on regressions
+//   pnpm test:heavy --type=st --only=h264,vp9 --jobs=4
+//   pnpm test:heavy --update         write the results as the new baseline
+//   pnpm test:heavy --native         also run native `ffmpeg`, list what only it decodes
+//
+// The samples (~1.3 GB) are rsynced to .cache/fate-suite, or FATE_SUITE=<dir>
+// points at an existing copy.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, symlinkSync, readdirSync, statSync } from "node:fs";
+import { execFileSync, spawnSync } from "node:child_process";
+import { join, relative, extname } from "node:path";
+import { chromium } from "playwright";
+import { startServer, root } from "../helpers/server.js";
+
+const args = Object.fromEntries(
+  process.argv.slice(2).map((a) => {
+    const [key, value = true] = a.replace(/^--/, "").split("=");
+    return [key, value];
+  })
+);
+const types = (args.type ?? "st,mt").split(",");
+const jobs = Number(args.jobs ?? 4);
+const only = args.only?.split(",");
+const SECONDS = 5;
+const TIMEOUT_MS = 30000;
+
+// Checksums, reference text and similar files in the suite that are not media.
+const NOT_MEDIA = new Set([".md5", ".sha1", ".sha256", ".txt", ".html", ".xml", ".json", ".lst", ".ffmeta", ".cfg", ".sub-ref"]);
+
+const suite = join(root, ".cache/fate-suite");
+if (!existsSync(suite)) {
+  mkdirSync(join(root, ".cache"), { recursive: true });
+  if (process.env.FATE_SUITE) {
+    symlinkSync(process.env.FATE_SUITE, suite);
+  } else {
+    console.log("Downloading the FATE suite to .cache/fate-suite (~1.3 GB)...");
+    execFileSync("rsync", ["-rlLt", "--delete", "rsync://fate-suite.ffmpeg.org/fate-suite/", `${suite}/`], { stdio: "inherit" });
+  }
+}
+
+const walk = (dir) =>
+  readdirSync(dir).sort().flatMap((name) => {
+    const path = join(dir, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+const files = walk(suite)
+  .map((f) => relative(suite, f))
+  .filter((f) => !NOT_MEDIA.has(extname(f).toLowerCase()))
+  .filter((f) => !only || only.some((o) => f.startsWith(`${o}/`)));
+
+// First video and first audio stream, at most SECONDS, hashed per frame.
+const command = (input) => ["-i", input, "-map", "0:v:0?", "-map", "0:a:0?", "-t", String(SECONDS), "-f", "framemd5", "/out"];
+
+function summarize({ ret, error, out, tail, ms }) {
+  if (error) return { status: "crash", error };
+  if (ms >= TIMEOUT_MS) return { status: "timeout" };
+  const frames = out?.text?.split("\n").filter((l) => l && !l.startsWith("#")).length ?? 0;
+  if (ret !== 0 || !frames) return { status: "error", error: tail.split("\n").at(-1) };
+  return { status: "ok", frames, hash: out.sha256.slice(0, 16) };
+}
+
+function native(file) {
+  const r = spawnSync("ffmpeg", ["-v", "error", ...command(join(suite, file)).slice(0, -1), "-"], { maxBuffer: 1 << 26, timeout: TIMEOUT_MS });
+  const frames = r.stdout?.toString().split("\n").filter((l) => l && !l.startsWith("#")).length ?? 0;
+  return r.status === 0 && frames > 0 ? "ok" : "error";
+}
+
+const { server, url } = await startServer();
+const browser = await chromium.launch();
+let failed = false;
+
+for (const type of types) {
+  console.log(`\n# ${type}: ${files.length} files, ${jobs} pages`);
+  const results = {};
+  const queue = [...files];
+  let done = 0;
+
+  const worker = async () => {
+    let page;
+    const open = async () => {
+      await page?.close();
+      page = await browser.newPage();
+      await page.goto(`${url}/tests/heavy/page.html?type=${type}`);
+      await page.waitForFunction(() => window.ready);
+    };
+    await open();
+    while (queue.length) {
+      const file = queue.shift();
+      // Keep the extension: FFmpeg probes some formats by file name.
+      const name = `/in${extname(file)}`;
+      const job = page.evaluate((job) => window.run(job), {
+        input: `/.cache/fate-suite/${file}`,
+        name,
+        args: command(name),
+        timeout: TIMEOUT_MS,
+      });
+      // exec()'s own timeout can't interrupt a thread that is stuck, so also
+      // give up from the outside and start a new page.
+      const stuck = new Promise((r) => setTimeout(() => r({ error: "hang" }), TIMEOUT_MS + 15000));
+      const r = await Promise.race([job, stuck]).catch((e) => ({ error: String(e) }));
+      results[file] = r.error === "hang" ? { status: "hang" } : summarize(r);
+      if (r.error === "hang") await open();
+      if (++done % 100 === 0) console.log(`  ${done}/${files.length}`);
+    }
+    await page.close();
+  };
+  await Promise.all(Array.from({ length: jobs }, worker));
+
+  if (args.native) {
+    for (const file of files) results[file].native = native(file);
+  }
+
+  const baselinePath = join(root, `tests/heavy/baseline/fate-${type}.json`);
+  const baseline = existsSync(baselinePath) ? JSON.parse(readFileSync(baselinePath, "utf8")) : {};
+  const regressions = [];
+  const fixed = [];
+  const changed = [];
+  for (const file of files) {
+    const now = results[file];
+    const was = baseline[file];
+    if (!was) continue;
+    if (was.status === "ok" && now.status !== "ok") regressions.push(`${file}: ${now.status} ${now.error ?? ""}`);
+    else if (was.status !== "ok" && now.status === "ok") fixed.push(file);
+    else if (was.status === "ok" && was.hash !== now.hash) changed.push(`${file}: ${was.frames} -> ${now.frames} frames`);
+  }
+
+  const count = (s) => files.filter((f) => results[f].status === s).length;
+  console.log(`  ok ${count("ok")}  error ${count("error")}  crash ${count("crash")}  timeout ${count("timeout")}  hang ${count("hang")}`);
+  if (args.native) {
+    const gaps = files.filter((f) => results[f].native === "ok" && results[f].status !== "ok");
+    console.log(`  native ffmpeg decodes ${files.filter((f) => results[f].native === "ok").length}; ffmpeg.wasm fails ${gaps.length} of those:`);
+    for (const f of gaps) console.log(`    ${f}: ${results[f].status} ${results[f].error ?? ""}`);
+  }
+  for (const [title, list] of [["regressions", regressions], ["now decoding", fixed], ["different output", changed]]) {
+    if (list.length) console.log(`  ${title} (${list.length}):\n    ${list.join("\n    ")}`);
+  }
+
+  mkdirSync(join(root, "tests/heavy/results"), { recursive: true });
+  writeFileSync(join(root, `tests/heavy/results/fate-${type}.json`), JSON.stringify(results, null, 1));
+  if (args.update) {
+    mkdirSync(join(root, "tests/heavy/baseline"), { recursive: true });
+    // One file per line, so baseline changes read well in a diff.
+    const lines = files.map((f) => {
+      const { status, frames, hash } = results[f];
+      return `${JSON.stringify(f)}: ${JSON.stringify({ status, frames, hash })}`;
+    });
+    writeFileSync(baselinePath, `{\n${lines.join(",\n")}\n}\n`);
+    console.log(`  wrote ${relative(root, baselinePath)}`);
+  } else if (regressions.length) {
+    failed = true;
+  }
+}
+
+await browser.close();
+server.close();
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>ffmpeg.wasm heavy tests</title>
+  </head>
+  <body>
+    <script type="module">
+      import { FFmpeg } from "/packages/ffmpeg/dist/esm/index.js";
+
+      const type = new URLSearchParams(location.search).get("type");
+      const coreURL = `${location.origin}/packages/core${type === "mt" ? "-mt" : ""}/dist/esm/ffmpeg-core.js`;
+      let ffmpeg;
+      const logs = [];
+
+      async function load() {
+        ffmpeg?.terminate();
+        ffmpeg = new FFmpeg();
+        ffmpeg.on("log", ({ message }) => logs.push(message));
+        await ffmpeg.load({ coreURL });
+      }
+
+      const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+
+      // Runs `args` and returns the exit code, time, the last log lines and
+      // the SHA-256 of /out. `name` (default /in) is the fetched `input`, or
+      // what the untimed `setup` command wrote.
+      window.run = async ({ input, name = "/in", setup, args, timeout }) => {
+        if (!ffmpeg) await load();
+        if (input) await ffmpeg.writeFile(name, new Uint8Array(await (await fetch(input)).arrayBuffer()));
+        if (setup) await ffmpeg.exec(setup);
+        logs.length = 0;
+        const start = performance.now();
+        let ret;
+        let error;
+        try {
+          ret = await ffmpeg.exec(args, timeout);
+        } catch (e) {
+          error = String(e);
+        }
+        const ms = Math.round(performance.now() - start);
+        let out;
+        if (ret !== undefined) {
+          try {
+            out = await ffmpeg.readFile("/out");
+            await ffmpeg.deleteFile("/out");
+          } catch {
+            // no output
+          }
+          if (input || setup) await ffmpeg.deleteFile(name);
+        } else {
+          await load(); // the core threw or aborted; start over with a fresh one
+        }
+        return {
+          ret, error, ms,
+          tail: logs.filter((l) => l !== "Aborted()").slice(-3).join("\n"),
+          out: out && { bytes: out.length, sha256: hex(await crypto.subtle.digest("SHA-256", out)), text: out.length < 1e6 ? new TextDecoder().decode(out) : null },
+        };
+      };
+      window.reload = load;
+      window.ready = true;
+    </script>
+  </body>
+</html>