diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 000000000..319617403
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,62 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: tests-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  unit:
+    name: Unit tests (Vitest)
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile
+      - run: bun run test --run
+
+  e2e:
+    name: Export end-to-end (Playwright)
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile
+
+      # ffmpeg makes the input fixtures and ffprobe checks the exported files.
+      - name: Install ffmpeg
+        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends ffmpeg
+
+      - name: Make video fixtures
+        run: scripts/make-fixtures.sh --small
+
+      # Telemetry off: CI must never report to Datadog.
+      - name: Build the static site
+        run: bun run build
+        env:
+          NEXT_PUBLIC_DATADOG_ENV: "off"
+
+      - name: Install Chromium for Playwright
+        run: bunx playwright install --with-deps chromium
+
+      # Served with COOP/COEP (multi-threaded core, as in production) and
+      # without (single-threaded core); see playwright.config.ts.
+      - name: Run Playwright
+        run: bunx playwright test
+
+      - name: Upload Playwright report
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-results
+          path: test-results/
+          retention-days: 7
diff --git a/.gitignore b/.gitignore
index 1d982f0b4..cc717af46 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,3 +50,10 @@ chromatic.log
 
 # Local Netlify folder
 .netlify
+
+# generated video fixtures (scripts/make-fixtures.sh)
+/test/fixtures/
+
+# playwright
+/test-results/
+/playwright-report/
diff --git a/bun.lock b/bun.lock
index c91ebf99a..ffc20a3a5 100644
--- a/bun.lock
+++ b/bun.lock
@@ -22,6 +22,7 @@
         "wasm-feature-detect": "^1.8.0",
       },
       "devDependencies": {
+        "@playwright/test": "1.64.1",
         "@storybook/addon-a11y": "^10.5.10",
         "@storybook/addon-docs": "^10.5.10",
         "@storybook/addon-themes": "^10.5.10",
@@ -566,6 +567,8 @@
 
     "@oxc-resolver/binding-win32-x64-msvc": ["@oxc-resolver/binding-win32-x64-msvc@11.21.2", "", { "os": "win32", "cpu": "x64" }, "sha512-VPoCAhKvCQTlG7vxqaBXcmuvbh77BfnGXj8g0pbvVXpm1F/R8rDVwqIWcEbMzrI1JvJlm8v7T9uMVQb6UctMRg=="],
 
+    "@playwright/test": ["@playwright/test@1.64.1", "", { "dependencies": { "playwright": "1.64.1" }, "bin": { "playwright": "cli.js" } }, "sha512-IaYGml/nSOiZWROfPtuIL7neuu9qDOZ3TNvNljUIrhDMxiGTgPjzj/g9p9RxpS2tSepPDRY+UwAaEeiKtUvIAg=="],
+
     "@pmmmwh/react-refresh-webpack-plugin": ["@pmmmwh/react-refresh-webpack-plugin@0.5.17", "", { "dependencies": { "ansi-html": "^0.0.9", "core-js-pure": "^3.23.3", "error-stack-parser": "^2.0.6", "html-entities": "^2.1.0", "loader-utils": "^2.0.4", "schema-utils": "^4.2.0", "source-map": "^0.7.3" }, "peerDependencies": { "@types/webpack": "4.x || 5.x", "react-refresh": ">=0.10.0 <1.0.0", "sockjs-client": "^1.4.0", "type-fest": ">=0.17.0 <5.0.0", "webpack": ">=4.43.0 <6.0.0", "webpack-dev-server": "3.x || 4.x || 5.x", "webpack-hot-middleware": "2.x", "webpack-plugin-serve": "0.x || 1.x" }, "optionalPeers": ["@types/webpack", "sockjs-client", "type-fest", "webpack-dev-server", "webpack-hot-middleware", "webpack-plugin-serve"] }, "sha512-tXDyE1/jzFsHXjhRZQ3hMl0IVhYe5qula43LDWIhVfjp9G/nT5OQY5AORVOrkEGAUltBJOfOWeETbmhm6kHhuQ=="],
 
     "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.6", "", { "os": "android", "cpu": "arm" }, "sha512-b+jTcARdTiFLI6jB4a5XjTm0RWd6KcRfQj/I2356fxUZemiho9zQLxo0RtCuMDAyKcLo6cEltkgbQp6d1+sjjQ=="],
@@ -1626,6 +1629,10 @@
 
     "pkg-dir": ["pkg-dir@7.0.0", "", { "dependencies": { "find-up": "^6.3.0" } }, "sha512-Ie9z/WINcxxLp27BKOCHGde4ITq9UklYKDzVo1nhk5sqGEXU3FpkwP5GM2voTGJkGd9B3Otl+Q4uwSOeSUtOBA=="],
 
+    "playwright": ["playwright@1.64.1", "", { "dependencies": { "playwright-core": "1.64.1" }, "bin": { "playwright": "cli.js" } }, "sha512-HCrVhHr5QQuwYoswEUGTb7gGp522yflbv/ST8nF4sFWGuLjQCt17Q/EubpGGSNKYn1tsTCPZxqHhHCfVURu7UA=="],
+
+    "playwright-core": ["playwright-core@1.64.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-BC4s8y6SEVA6Q1rSxZTto8hI1KUI3xXlHGZgvGqP4IqPdI/a6FX9H29IDNz7vKo9l21b6LfYosScPL6M3xxyDQ=="],
+
     "possible-typed-array-names": ["possible-typed-array-names@1.1.0", "", {}, "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg=="],
 
     "postcss": ["postcss@8.5.26", "", { "dependencies": { "nanoid": "^3.3.17", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ=="],
diff --git a/docs/DATADOG.md b/docs/DATADOG.md
index 72e99746e..99b7662a5 100644
--- a/docs/DATADOG.md
+++ b/docs/DATADOG.md
@@ -44,8 +44,8 @@ its own, so we can see which browser and device combinations fail.
 |---|---|---|
 | `export_started` | Export clicked and settings validated | `format`, `resolution`, `input_size`, `clip_length`, `has_text`, `has_music`, `has_image_overlay`, `is_retry`, `retry_after` (retries only: the previous failure's category) |
 | `export_succeeded` | Terminal | the context above, plus `engine`, `fell_back` (true after an engine fallback), `durationMs` (click to done), `encode_ms`, `output_size` |
-| `export_failed` | Terminal | the context, plus `engine`, `durationMs`, `stage` (`engine` / `encode`), `category` |
-| `export_cancelled` | Terminal: the user cancelled | the context, plus `engine`, `durationMs`, `stage` |
+| `export_failed` | Terminal | the context, plus `engine`, `durationMs`, `stage` (`engine` / `encode`), `category`, and `stall_reason` for stalls |
+| `export_cancelled` | Terminal: the user cancelled | the context, plus `engine`, `durationMs`, `stage`, `stuck` (true when progress hadn't changed for 60 s: the user gave up on a hang, and monitors count it as a failure) |
 | `engine_fallback` | The multi-threaded engine stalled; the same export restarts automatically on the single-threaded engine. Not terminal: the attempt's outcome follows | the context, plus `from: multi`, `to: single`, `stall_reason` |
 | `ffmpeg_load_success` | A worker loaded the engine (once per worker) | `engine` (`multi` / `single`, what actually loaded), `engine_requested`, `single_reason` (`not_isolated` / `after_stall` / `mt_load_failed`, single-threaded only), `load_number` (`first` / `repeat`), `durationMs` |
 | `ffmpeg_load_failure` | A worker failed to load (not sent when the user cancelled) | `engine_requested`, `load_number`, `category` (`network` / `integrity` / `wasm` / `worker_script` / `unknown`), `durationMs` |
@@ -69,12 +69,21 @@ as part of the schema.
 | Category | Meaning |
 |---|---|
 | `engine_load` | The engine never became ready (any failure in the `engine` stage) |
-| `timeout` | No progress for 60 s; the next attempt uses the single-threaded engine |
+| `timeout` | The stall watchdog stopped the export (see `stall_reason`); the next attempt uses the single-threaded engine |
 | `unsupported_format` | FFmpeg couldn't decode the input |
 | `out_of_memory` | An allocation failed, or a `RangeError` |
 | `encoder_crash` | A WASM trap in the encoder (`memory access out of bounds`, `unreachable`) |
 | `network` | A network error after the engine started |
 | `encode_error` | Any other FFmpeg failure |
+| `unknown_duration` | The browser couldn't tell how long the clip is (`clip_length: unknown`), and the export then stalled or failed. Usually a live recording with no duration header that the seek-to-end fallback couldn't resolve |
+
+`export_failed.stall_reason` (stalls only):
+
+| Reason | Meaning |
+|---|---|
+| `no_activity` | No heartbeat or log line for 60 s: the engine is wedged (the multi-threaded thread-pool deadlock looked like this) |
+| `no_progress` | FFmpeg kept logging, but the encoded time didn't change for 120 s ("stuck at 100%") |
+| `overrun` | Encoding ran past 1.25 × the expected length + 15 s, for example looped music that never stops |
 
 ### Guarantees (covered by tests)
 
@@ -125,10 +134,25 @@ Created through the API on 2026-11-03 (site `datadoghq.com`):
 | Item | ID |
 |---|---|
 | Dashboard "Reframe — export reliability" | [`2tw-pge-qkk`](https://app.datadoghq.com/dashboard/2tw-pge-qkk) |
-| Monitor: exports failing in production (> 10 `export_failed` in 1 h; warning at 5) | `340137974` |
+| Monitor: exports not completing (started − succeeded − ordinary cancellations > 10 in 1 h; warning at 5). Counts failures, stuck cancellations (`stuck: true`) and abandoned exports | `340137974` |
 | Monitor: FFmpeg engine failing to load (> 5 `ffmpeg_load_failure` in 1 h) | `340138002` |
 | Monitor: cross-origin isolation missing (> 3 loads with `single_reason:not_isolated` in 1 h) | `340138004` |
 | Monitor: frontend errors spike (> 25 uncaught errors in 1 h) | `340138012` |
+| Monitor: exports start but none succeed (> 3 `export_started` and 0 `export_succeeded` in 6 h) | `340168191` |
+| RUM-based metrics `reframe.export.started` and `reframe.export.succeeded` (production action counts, from 2026-11-03) | — |
+| SLO: 95% of started exports succeed, 30 days (and 7 days), warning at 97% | `0ac26b24a9a156729eaa2bdab83d07ff` |
+| Monitor: SLO error budget burning > 6× over 6 h and 30 min | `340187598` |
+
+Why the "none succeed" and "not completing" monitors exist: during the
+multi-threaded engine outage (2026-10-22 to 2026-11-03) every export hung,
+and hung exports produced no `export_failed` at all, only cancellations or
+nothing. The original failure monitor counted only `export_failed`, so it
+stayed OK the whole time.
+
+The SLO counts every start that didn't end in success, so user
+cancellations count against it as well; that is deliberate (a cancel is
+usually an export that was too slow). With today's traffic a single failure
+moves it a lot; treat it as meaningful after a few hundred exports.
 
 The monitors only watch `env:production`, never page anyone, and email the
 maintainer. Their thresholds are absolute counts, chosen for today's low
diff --git a/docs/datadog/export-reliability.dashboard.json b/docs/datadog/export-reliability.dashboard.json
index 3ebee75c5..53b2a31b9 100644
--- a/docs/datadog/export-reliability.dashboard.json
+++ b/docs/datadog/export-reliability.dashboard.json
@@ -1,5 +1,5 @@
 {
-  "title": "Reframe — export reliability",
+  "title": "Reframe \u2014 export reliability",
   "description": "Export outcomes from Reframe's browser RUM events (src/lib/exportTelemetry.ts). Success rate = export_succeeded / (export_succeeded + export_failed); cancellations are excluded. Treat groups with few finished exports as noise. Setup and facets: docs/DATADOG.md.",
   "layout_type": "ordered",
   "template_variables": [
@@ -1009,6 +1009,56 @@
           }
         ]
       }
+    },
+    {
+      "definition": {
+        "title": "Stalled exports by reason and engine",
+        "type": "query_table",
+        "requests": [
+          {
+            "response_format": "scalar",
+            "queries": [
+              {
+                "data_source": "rum",
+                "name": "stalled",
+                "indexes": [
+                  "*"
+                ],
+                "compute": {
+                  "aggregation": "count"
+                },
+                "search": {
+                  "query": "@type:action service:reframe $env @action.target.name:export_failed @context.category:(timeout OR unknown_duration)"
+                },
+                "group_by": [
+                  {
+                    "facet": "@context.stall_reason",
+                    "limit": 3,
+                    "sort": {
+                      "aggregation": "count",
+                      "order": "desc"
+                    }
+                  },
+                  {
+                    "facet": "@context.engine",
+                    "limit": 3,
+                    "sort": {
+                      "aggregation": "count",
+                      "order": "desc"
+                    }
+                  }
+                ]
+              }
+            ],
+            "formulas": [
+              {
+                "formula": "stalled",
+                "alias": "Stalled exports"
+              }
+            ]
+          }
+        ]
+      }
     }
   ]
 }
diff --git a/package.json b/package.json
index 8cf6b3057..5037164c9 100644
--- a/package.json
+++ b/package.json
@@ -31,6 +31,7 @@
     "wasm-feature-detect": "^1.8.0"
   },
   "devDependencies": {
+    "@playwright/test": "1.64.1",
     "@storybook/addon-a11y": "^10.5.10",
     "@storybook/addon-docs": "^10.5.10",
     "@storybook/addon-themes": "^10.5.10",
diff --git a/playwright.config.ts b/playwright.config.ts
new file mode 100644
index 000000000..533b7f532
--- /dev/null
+++ b/playwright.config.ts
@@ -0,0 +1,44 @@
+import { defineConfig, devices } from "@playwright/test";
+
+// End-to-end export tests against the production build (out/), served with
+// the same cross-origin isolation headers as Netlify.
+//
+//   scripts/make-fixtures.sh --small
+//   NEXT_PUBLIC_DATADOG_ENV=off bun run build
+//   bunx playwright test
+//
+// Two projects: "multi-threaded" (COOP/COEP set, so @ffmpeg/core-mt loads,
+// as on the live site) and "single-threaded" (no isolation headers).
+export default defineConfig({
+  testDir: "test/e2e",
+  // Each test runs real FFmpeg.wasm encodes; one worker keeps CPU contention
+  // from making timings meaningless.
+  workers: 1,
+  fullyParallel: false,
+  timeout: 240_000,
+  expect: { timeout: 15_000 },
+  retries: process.env.CI ? 1 : 0,
+  reporter: process.env.CI ? [["list"], ["junit", { outputFile: "test-results/e2e-junit.xml" }]] : "list",
+  use: {
+    ...devices["Desktop Chrome"],
+    acceptDownloads: true,
+    trace: "retain-on-failure",
+  },
+  projects: [
+    { name: "multi-threaded", use: { baseURL: "http://127.0.0.1:4173" } },
+    { name: "single-threaded", use: { baseURL: "http://127.0.0.1:4174" } },
+  ],
+  webServer: [
+    {
+      command: "node scripts/serve-isolated.mjs 4173",
+      url: "http://127.0.0.1:4173",
+      reuseExistingServer: !process.env.CI,
+    },
+    {
+      command: "node scripts/serve-isolated.mjs 4174",
+      url: "http://127.0.0.1:4174",
+      env: { ISOLATED: "0" },
+      reuseExistingServer: !process.env.CI,
+    },
+  ],
+});
diff --git a/scripts/make-fixtures.sh b/scripts/make-fixtures.sh
new file mode 100755
index 000000000..495a63284
--- /dev/null
+++ b/scripts/make-fixtures.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# Recreates the video fixtures used by the end-to-end export tests.
+# Output goes to test/fixtures/ (gitignored). Needs the ffmpeg CLI
+# (macOS: `brew install ffmpeg`, Ubuntu: `sudo apt-get install ffmpeg`).
+#
+#   scripts/make-fixtures.sh          # all fixtures
+#   scripts/make-fixtures.sh --small  # everything except the ~300 MB clip
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+OUT=test/fixtures
+mkdir -p "$OUT"
+
+command -v ffmpeg >/dev/null || { echo "ffmpeg not found; install it first." >&2; exit 1; }
+
+ff() { ffmpeg -hide_banner -loglevel error -y "$@"; }
+
+# A moving test pattern with a tone, so trims, speed changes and audio edits
+# are visible in the output.
+video() { echo "testsrc2=size=$1:rate=30:duration=$2"; }
+tone() { echo "sine=frequency=440:sample_rate=48000:duration=$1"; }
+
+echo "normal.mp4: 1280x720 H.264/AAC, 10 s"
+ff -f lavfi -i "$(video 1280x720 10)" -f lavfi -i "$(tone 10)" \
+  -c:v libx264 -pix_fmt yuv420p -preset veryfast -c:a aac -b:a 128k \
+  -movflags +faststart -shortest "$OUT/normal.mp4"
+
+# Browser screen recordings (MediaRecorder) are written as a live stream: the
+# WebM header has no duration and there are no cues, so <video>.duration is
+# Infinity until the whole file is read. `-live 1` produces the same layout.
+echo "no-duration.webm: 1280x720 VP8/Opus, 6 s, no duration in the container"
+ff -f lavfi -i "$(video 1280x720 6)" -f lavfi -i "$(tone 6)" \
+  -c:v libvpx -b:v 1M -deadline realtime -cpu-used 8 -c:a libopus \
+  -f webm -live 1 -shortest "$OUT/no-duration.webm"
+
+echo "portrait.mp4: 720x1280 H.264/AAC, 6 s"
+ff -f lavfi -i "$(video 720x1280 6)" -f lavfi -i "$(tone 6)" \
+  -c:v libx264 -pix_fmt yuv420p -preset veryfast -c:a aac -b:a 128k \
+  -movflags +faststart -shortest "$OUT/portrait.mp4"
+
+echo "no-audio.mp4: 1280x720 H.264, 6 s, no audio track"
+ff -f lavfi -i "$(video 1280x720 6)" \
+  -c:v libx264 -pix_fmt yuv420p -preset veryfast -an \
+  -movflags +faststart "$OUT/no-audio.mp4"
+
+if [[ "${1:-}" != "--small" ]]; then
+  # Noise defeats compression, so a constant 40 Mb/s for 60 s lands near 300 MB.
+  echo "large.mp4: 1920x1080 H.264/AAC, 60 s, ~300 MB (memory testing)"
+  ff -f lavfi -i "$(video 1920x1080 60),noise=alls=60:allf=t" -f lavfi -i "$(tone 60)" \
+    -c:v libx264 -pix_fmt yuv420p -preset ultrafast \
+    -b:v 40M -minrate 40M -maxrate 40M -bufsize 80M \
+    -c:a aac -b:a 128k -movflags +faststart -shortest "$OUT/large.mp4"
+fi
+
+echo
+for f in "$OUT"/*.{mp4,webm}; do
+  [[ -e "$f" ]] || continue
+  printf '%-28s %8s  duration=%s\n' "$f" "$(du -h "$f" | cut -f1)" \
+    "$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$f")"
+done
diff --git a/scripts/serve-isolated.mjs b/scripts/serve-isolated.mjs
new file mode 100644
index 000000000..0c2a62cae
--- /dev/null
+++ b/scripts/serve-isolated.mjs
@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Serves the static export (out/) with the same cross-origin isolation headers
+// as production (netlify.toml), so the multi-threaded FFmpeg core loads exactly
+// as it does on the live site. Used by the Playwright tests.
+//
+//   node scripts/serve-isolated.mjs [port]      (default 4173)
+//   ISOLATED=0 node scripts/serve-isolated.mjs  (no COOP/COEP: single-threaded)
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { extname, join, normalize, resolve } from "node:path";
+
+const root = resolve(process.cwd(), "out");
+const port = Number(process.argv[2] ?? process.env.PORT ?? 4173);
+const isolated = process.env.ISOLATED !== "0";
+
+const TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".woff2": "font/woff2",
+  ".wasm": "application/wasm",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json",
+};
+
+async function resolveFile(urlPath) {
+  const clean = normalize(decodeURIComponent(urlPath.split("?")[0])).replace(/^(\.\.[/\\])+/, "");
+  const base = join(root, clean);
+  if (!base.startsWith(root)) return null;
+  for (const candidate of [base, `${base}.html`, join(base, "index.html")]) {
+    try {
+      if ((await stat(candidate)).isFile()) return candidate;
+    } catch {
+      // try the next candidate
+    }
+  }
+  return null;
+}
+
+createServer(async (req, res) => {
+  const headers = { "X-Content-Type-Options": "nosniff" };
+  if (isolated) {
+    headers["Cross-Origin-Opener-Policy"] = "same-origin";
+    headers["Cross-Origin-Embedder-Policy"] = "require-corp";
+  }
+  const file = await resolveFile(req.url ?? "/");
+  if (!file) {
+    const notFound = await resolveFile("/404");
+    res.writeHead(404, { ...headers, "Content-Type": TYPES[".html"] });
+    res.end(notFound ? await readFile(notFound) : "Not found");
+    return;
+  }
+  res.writeHead(200, { ...headers, "Content-Type": TYPES[extname(file)] ?? "application/octet-stream" });
+  res.end(await readFile(file));
+}).listen(port, "127.0.0.1", () => {
+  console.log(`Serving out/ on http://127.0.0.1:${port} (cross-origin isolated: ${isolated})`);
+});
diff --git a/src/hooks/tests/exportTelemetry.hook.test.ts b/src/hooks/tests/exportTelemetry.hook.test.ts
index 891b96a0d..7a9c0257a 100644
--- a/src/hooks/tests/exportTelemetry.hook.test.ts
+++ b/src/hooks/tests/exportTelemetry.hook.test.ts
@@ -125,6 +125,42 @@ describe("export reliability telemetry in the editor", () => {
     expect(lifecycle()[1]!.ctx).toMatchObject({ stage: "encode" });
   });
 
+  it("a cancel after a minute without progress is reported as stuck", async () => {
+    const { result } = await editorWithFile();
+    let onProgress!: (p: number) => void;
+    vi.mocked(exportVideo).mockImplementationOnce((_f, _r, progress) => {
+      onProgress = progress;
+      return new Promise(() => {});
+    });
+    act(() => {
+      void result.current.handleExport();
+    });
+    await waitFor(() => expect(result.current.status).toBe("exporting"));
+    act(() => onProgress(100));
+    // Only the cancel happens "a minute later"; waitFor above uses real time.
+    const later = Date.now() + 61_000;
+    const now = vi.spyOn(Date, "now").mockReturnValue(later);
+    act(() => result.current.cancelExport());
+    now.mockRestore();
+    expect(lifecycle().at(-1)).toMatchObject({ name: "export_cancelled", ctx: { stuck: true } });
+  });
+
+  it("a cancel while progress is moving is not stuck", async () => {
+    const { result } = await editorWithFile();
+    let onProgress!: (p: number) => void;
+    vi.mocked(exportVideo).mockImplementationOnce((_f, _r, progress) => {
+      onProgress = progress;
+      return new Promise(() => {});
+    });
+    act(() => {
+      void result.current.handleExport();
+    });
+    await waitFor(() => expect(result.current.status).toBe("exporting"));
+    act(() => onProgress(40));
+    act(() => result.current.cancelExport());
+    expect(lifecycle().at(-1)).toMatchObject({ name: "export_cancelled", ctx: { stuck: false } });
+  });
+
   it("cancelling while the engine loads is reported at the engine stage", async () => {
     const { result } = await editorWithFile();
     vi.mocked(loadFFmpeg).mockImplementationOnce(() => new Promise(() => {}));
diff --git a/src/hooks/tests/useVideoEditor.test.ts b/src/hooks/tests/useVideoEditor.test.ts
index 8e164d314..e8465d046 100644
--- a/src/hooks/tests/useVideoEditor.test.ts
+++ b/src/hooks/tests/useVideoEditor.test.ts
@@ -10,6 +10,7 @@ vi.mock("@/lib/ffmpeg", () => ({
   terminateFFmpeg: vi.fn(),
   getEngineMode: vi.fn(() => null),
   FFmpegLoadError: class extends Error {},
+  ExportStalledError: class extends Error {},
 }));
 
 vi.mock("@/lib/sessionDB", () => ({
diff --git a/src/hooks/tests/useVideoEditorProject.test.ts b/src/hooks/tests/useVideoEditorProject.test.ts
index c0b2c0e9a..c3edea682 100644
--- a/src/hooks/tests/useVideoEditorProject.test.ts
+++ b/src/hooks/tests/useVideoEditorProject.test.ts
@@ -20,6 +20,7 @@ vi.mock("@/lib/ffmpeg", () => ({
   getEngineMode: vi.fn(() => "multi"),
   formatBytes: (n: number) => `${n} B`,
   FFmpegLoadError: class extends Error {},
+  ExportStalledError: class extends Error {},
 }));
 
 vi.mock("@/lib/sessionDB", () => ({
diff --git a/src/hooks/useVideoEditor.ts b/src/hooks/useVideoEditor.ts
index 8594bf189..a423431a6 100644
--- a/src/hooks/useVideoEditor.ts
+++ b/src/hooks/useVideoEditor.ts
@@ -30,7 +30,14 @@ import {
 } from "@/lib/project";
 import { DEFAULT_RECIPE, SPEED_STEPS } from "@/lib/constants";
 import { getPresetById } from "@/lib/presets";
-import { loadFFmpeg, exportVideo, terminateFFmpeg, getEngineMode, FFmpegLoadError } from "@/lib/ffmpeg";
+import {
+  loadFFmpeg,
+  exportVideo,
+  terminateFFmpeg,
+  getEngineMode,
+  FFmpegLoadError,
+  ExportStalledError,
+} from "@/lib/ffmpeg";
 import {
   addTelemetryRedaction,
   durationBucket,
@@ -62,9 +69,15 @@ import {
   EDITOR_STATE_KEY,
 } from "@/lib/editorPersistence";
 import { saveSessionFile, loadSessionFile, clearSessionFile } from "@/lib/sessionDB";
+import { resolveDuration } from "@/lib/mediaDuration";
 
 const DEFAULT_TITLE = "Reframe — Resize, trim, and export videos in your browser";
 const PROJECT_SAVE_DELAY_MS = 500;
+/**
+ * A cancel after this long without the progress percentage changing is
+ * reported as stuck (export_cancelled.stuck): the user gave up on a hang.
+ */
+const STUCK_CANCEL_MS = 60_000;
 
 /** A saved project whose source video has to be chosen again. */
 export interface PendingRecovery {
@@ -130,12 +143,14 @@ export function extractMetadata(
     }, 5000);
 
     video.preload = "metadata";
-    video.onloadedmetadata = () => {
+    video.onloadedmetadata = async () => {
       clearTimeout(timeout);
+      // Screen recordings report an Infinity duration until read to the end.
+      const duration = await resolveDuration(video);
       resolve({
         width: video.videoWidth,
         height: video.videoHeight,
-        duration: isFinite(video.duration) ? video.duration : 0,
+        duration,
       });
       URL.revokeObjectURL(url);
     };
@@ -318,6 +333,16 @@ export function useVideoEditor() {
   const [exportNotice, setExportNotice] = useState<string | null>(null);
   const exportAbortControllerRef = useRef<AbortController | null>(null);
   const exportCancelledRef = useRef(false);
+  /** When the export progress percentage last changed (see STUCK_CANCEL_MS). */
+  const lastProgressAtRef = useRef(0);
+  const lastProgressRef = useRef(-1);
+  const trackProgress = useCallback((percent: number) => {
+    if (percent !== lastProgressRef.current) {
+      lastProgressRef.current = percent;
+      lastProgressAtRef.current = Date.now();
+    }
+    setProgress(percent);
+  }, []);
   /** The export attempt in progress, which reports its single outcome. */
   const exportAttemptRef = useRef<ExportAttempt | null>(null);
   // Category of the last failed export for this source, so the next attempt
@@ -726,14 +751,14 @@ export function useVideoEditor() {
 
     try {
       setStatus("loading-engine");
-      setProgress(0);
+      trackProgress(0);
       setExportNotice(null);
       setError(null);
       setExportStartedAt(null);
       if (result?.blobUrl) URL.revokeObjectURL(result.blobUrl);
       setResult(null);
 
-      await loadFFmpeg(abortController.signal, setProgress);
+      await loadFFmpeg(abortController.signal, trackProgress);
       if (exportCancelledRef.current) return;
 
       const startedAt = Date.now();
@@ -744,7 +769,7 @@ export function useVideoEditor() {
       const exportResult = await exportVideo(
         file,
         recipe,
-        setProgress,
+        trackProgress,
         abortController.signal,
         {
           file: musicFile,
@@ -784,7 +809,8 @@ export function useVideoEditor() {
       // Reported above as export_failed; the prefix keeps RUM's automatic
       // console-error collection from reporting it a second time.
       console.error(`${HANDLED_ERROR_PREFIX} export failed:`, err);
-      if (err instanceof FFmpegLoadError) {
+      if (err instanceof FFmpegLoadError || err instanceof ExportStalledError) {
+        // Both messages say what happened and what to do next.
         setError(err.message);
       } else if (err instanceof Error && err.message.includes("network")) {
         setError("Network error. Check your internet connection and try again.");
@@ -804,6 +830,7 @@ export function useVideoEditor() {
       }
     }
   }, [
+    trackProgress,
     duration,
     file,
     loopMusic,
@@ -926,7 +953,8 @@ export function useVideoEditor() {
   }, [file, musicFile, overlayFile, recovery, recipe.textOverlays]);
 
   const cancelExport = useCallback(() => {
-    exportAttemptRef.current?.cancelled();
+    const stuck = Date.now() - lastProgressAtRef.current >= STUCK_CANCEL_MS;
+    exportAttemptRef.current?.cancelled(stuck);
     exportAttemptRef.current = null;
     exportCancelledRef.current = true;
     exportAbortControllerRef.current?.abort();
diff --git a/src/lib/exportTelemetry.ts b/src/lib/exportTelemetry.ts
index 2076e8fff..332006003 100644
--- a/src/lib/exportTelemetry.ts
+++ b/src/lib/exportTelemetry.ts
@@ -20,10 +20,14 @@ export type ExportFailureCategory =
   | "out_of_memory"
   | "encoder_crash"
   | "network"
-  | "encode_error";
+  | "encode_error"
+  // The browser couldn't tell how long the clip is, and the export then
+  // stalled or failed. Usually a live recording with no duration header.
+  | "unknown_duration";
 
 /** Which watchdog rule stopped a stalled export (see ExportStalledError). */
 export type StallReason = "no_activity" | "no_progress" | "overrun";
+const STALL_REASONS: readonly StallReason[] = ["no_activity", "no_progress", "overrun"];
 
 export type EngineLoadFailureCategory = "network" | "integrity" | "wasm" | "worker_script" | "unknown";
 
@@ -161,16 +165,35 @@ export class ExportAttempt {
       return null;
     }
     this.outcome = "failed";
-    const category = exportFailureCategory(err, this.stage);
-    trackAction("export_failed", { ...this.common(), stage: this.stage, category });
+    let category = exportFailureCategory(err, this.stage);
+    if (
+      this.context.clip_length === "unknown" &&
+      this.stage === "encode" &&
+      (category === "timeout" || category === "encode_error")
+    ) {
+      category = "unknown_duration";
+    }
+    const reason = (err as { reason?: unknown } | null)?.reason;
+    const stallReason = STALL_REASONS.find((r) => r === reason);
+    trackAction("export_failed", {
+      ...this.common(),
+      stage: this.stage,
+      category,
+      ...(stallReason ? { stall_reason: stallReason } : {}),
+    });
     return category;
   }
 
-  /** Returns false if this attempt already had an outcome. */
-  cancelled(): boolean {
+  /**
+   * Returns false if this attempt already had an outcome. `stuck`: progress
+   * hadn't moved for a while when the user cancelled, so this cancellation is
+   * probably a hang the watchdog hadn't caught yet, and monitors count it as
+   * a failure.
+   */
+  cancelled(stuck = false): boolean {
     if (this.settled) return false;
     this.outcome = "cancelled";
-    trackAction("export_cancelled", { ...this.common(), stage: this.stage });
+    trackAction("export_cancelled", { ...this.common(), stage: this.stage, stuck });
     return true;
   }
 }
diff --git a/src/lib/ffmpeg.ts b/src/lib/ffmpeg.ts
index c347cba01..c64dcc8ca 100644
--- a/src/lib/ffmpeg.ts
+++ b/src/lib/ffmpeg.ts
@@ -1,7 +1,8 @@
 import { EditRecipe, ExportResult, BackgroundMusicOptions, ImageOverlayOptions, MAX_FILE_SIZE } from "./types";
 import { trackTiming } from "./telemetry";
 import { startEngineLoad, type StallReason } from "./exportTelemetry";
-import type { EngineMode } from "./ffmpegArgs";
+import { expectedOutputSeconds, isUsableDuration, type EngineMode } from "./ffmpegArgs";
+import { resolveDuration } from "./mediaDuration";
 
 // The command line itself is built in ffmpegArgs.ts and run by the worker.
 export { buildVideoFilter, buildAudioFilter } from "./ffmpegArgs";
@@ -14,6 +15,20 @@ export class FFmpegLoadError extends Error {
   }
 }
 
+/**
+ * Why the watchdog gave up on an export:
+ *   - no_activity: the engine went silent (the multi-threaded deadlock);
+ *   - no_progress: FFmpeg kept logging but encoded nothing new;
+ *   - overrun: it encoded well past the length the export should have.
+ */
+export type { StallReason };
+
+const STALL_MESSAGES: Record<StallReason, string> = {
+  no_activity: "The export stopped responding.",
+  no_progress: "The export stopped making progress.",
+  overrun: "The export kept running past the end of the video.",
+};
+
 /** The watchdog stopped an export that wasn't going to finish. */
 export class ExportStalledError extends Error {
   name = "ExportStalledError";
@@ -22,9 +37,10 @@ export class ExportStalledError extends Error {
     readonly reason: StallReason = "no_activity"
   ) {
     super(
-      mode === "multi"
-        ? "The export stopped responding. Press Retry to try again with the single-threaded engine, which is slower but more reliable."
-        : "The export stopped responding. Press Retry to try again, or try a shorter clip or a lower resolution."
+      `${STALL_MESSAGES[reason]} ` +
+        (mode === "multi"
+          ? "Press Retry to try again with the single-threaded engine, which is slower but more reliable."
+          : "Press Retry to try again, or try a shorter clip or a lower resolution.")
     );
   }
 }
@@ -37,6 +53,19 @@ export class ExportStalledError extends Error {
  */
 export const STALL_TIMEOUT_MS = 60_000;
 
+/**
+ * FFmpeg can keep printing log lines while encoding nothing (for example a
+ * filter that never gets input). Two minutes without a new encoded second
+ * means it won't finish. Long enough for the slowest legitimate gap: the GIF
+ * palette pass and muxing a large file at the end.
+ */
+export const NO_PROGRESS_TIMEOUT_MS = 120_000;
+
+/** How far past the expected length encoding may run before it's an overrun. */
+export function overrunLimitSeconds(expectedSeconds: number): number {
+  return expectedSeconds * 1.25 + 15;
+}
+
 
 type SerializedFile = {
   name: string;
@@ -58,7 +87,7 @@ type WorkerExportRequest = {
 
 type WorkerLoadResponse = { type: "ready"; mode: EngineMode };
 type WorkerHeartbeatResponse = { type: "heartbeat" };
-type WorkerProgressResponse = { type: "progress"; percent: number };
+type WorkerProgressResponse = { type: "progress"; percent: number; outputSeconds?: number };
 type WorkerResultResponse = {
   type: "result";
   id: string;
@@ -90,8 +119,11 @@ let pendingExport: {
   reject: (reason: unknown) => void;
 } | null = null;
 let pendingProgress: ((percent: number) => void) | null = null;
-/** Called on any sign of life from the worker during an export. */
-let pendingActivity: (() => void) | null = null;
+/**
+ * Called on any sign of life from the worker during an export, with the
+ * encoded output time when the worker reports it.
+ */
+let pendingActivity: ((outputSeconds?: number) => void) | null = null;
 /** The core the current worker loaded, once it is ready. */
 let engineMode: EngineMode | null = null;
 /**
@@ -180,7 +212,7 @@ function handleWorkerMessage(event: MessageEvent<WorkerResponse>) {
   }
 
   if (data.type === "progress") {
-    pendingActivity?.();
+    pendingActivity?.(data.outputSeconds);
     pendingProgress?.(data.percent);
     return;
   }
@@ -411,18 +443,39 @@ async function exportOnce(
   };
   signal?.addEventListener("abort", onAbort, { once: true });
 
+  const videoDuration = isUsableDuration(knownDuration) ? knownDuration : await getVideoDuration(file);
+  const expectedSeconds = expectedOutputSeconds(recipe, videoDuration);
+
   const mode = engineMode ?? "single";
   let lastActivity = Date.now();
-  pendingActivity = () => {
-    lastActivity = Date.now();
+  let lastAdvance = Date.now();
+  let encodedSeconds = -1;
+  let overrun = false;
+  pendingActivity = (outputSeconds) => {
+    const now = Date.now();
+    lastActivity = now;
+    if (outputSeconds === undefined || outputSeconds === encodedSeconds) return;
+    // Any change counts: the GIF export restarts its clock for the second pass.
+    encodedSeconds = outputSeconds;
+    lastAdvance = now;
+    if (expectedSeconds !== null && outputSeconds > overrunLimitSeconds(expectedSeconds)) overrun = true;
   };
   const watchdog = setInterval(() => {
-    if (Date.now() - lastActivity < STALL_TIMEOUT_MS) return;
+    const now = Date.now();
+    const reason: StallReason | null = overrun
+      ? "overrun"
+      : now - lastActivity >= STALL_TIMEOUT_MS
+        ? "no_activity"
+        : // Only once the worker reports encoded time; without it, activity is all we know.
+          encodedSeconds >= 0 && now - lastAdvance >= NO_PROGRESS_TIMEOUT_MS
+          ? "no_progress"
+          : null;
+    if (!reason) return;
     clearInterval(watchdog);
     if (mode === "multi") preferSingleThread = true;
-    const stalled = new ExportStalledError(mode);
-    cancelPendingExport(stalled);
-    // The worker is wedged and can't be told to stop; discard it.
+    cancelPendingExport(new ExportStalledError(mode, reason));
+    // A wedged worker can't be told to stop; discard it (this also frees its
+    // memory, including the files in FFmpeg's virtual filesystem).
     resetWorker();
   }, 5_000);
 
@@ -436,10 +489,7 @@ async function exportOnce(
       id: sessionId,
       file: filePayload,
       recipe,
-      videoDuration:
-        knownDuration && Number.isFinite(knownDuration) && knownDuration > 0
-          ? knownDuration
-          : await getVideoDuration(file),
+      videoDuration,
       musicFile: musicFilePayload,
       musicOptions: sanitizedMusicOptions,
       overlayFile: overlayFilePayload,
@@ -470,7 +520,11 @@ async function getVideoDuration(file: File): Promise<number> {
     // 0 makes the worker omit -t, so a stalled metadata read degrades safely.
     const timer = setTimeout(() => finish(0), 5000);
     video.preload = "metadata";
-    video.onloadedmetadata = () => finish(video.duration);
+    video.onloadedmetadata = () => {
+      clearTimeout(timer);
+      // Live-recorded files need a seek before the browser knows their length.
+      void resolveDuration(video).then(finish);
+    };
     video.onerror = () => finish(0);
     video.src = url;
   });
diff --git a/src/lib/ffmpeg.worker.ts b/src/lib/ffmpeg.worker.ts
index 72ed5ee5e..cd32fe559 100644
--- a/src/lib/ffmpeg.worker.ts
+++ b/src/lib/ffmpeg.worker.ts
@@ -2,7 +2,13 @@ import { FFmpeg } from "@ffmpeg/ffmpeg";
 import { toBlobURL } from "@ffmpeg/util";
 import { EditRecipe, BackgroundMusicOptions, ImageOverlayOptions } from "./types";
 import { getPresetById } from "./presets";
-import { buildArguments, buildGifArguments, resolveThreadCount, type EngineMode } from "./ffmpegArgs";
+import {
+  buildArguments,
+  buildGifArguments,
+  expectedOutputSeconds,
+  resolveThreadCount,
+  type EngineMode,
+} from "./ffmpegArgs";
 
 const CORE_BASE_URL = "https://cdn.jsdelivr.net/npm/@ffmpeg/core@0.12.10/dist/umd";
 // MT core aligned to the same version and distribution format as CORE_BASE_URL.
@@ -58,7 +64,11 @@ type TerminateRequest = { type: "terminate" };
 
 type WorkerCommand = LoadRequest | ExportRequest | CancelRequest | TerminateRequest;
 
-type ProgressPayload = { type: "progress"; percent: number };
+/**
+ * `outputSeconds`: how much output has been encoded, so the client can tell an
+ * export that is advancing from one that is stuck or running past its end.
+ */
+type ProgressPayload = { type: "progress"; percent: number; outputSeconds?: number };
 
 type ReadyPayload = { type: "ready"; mode: EngineMode };
 
@@ -238,16 +248,30 @@ async function runExport(request: ExportRequest): Promise<ResultPayload> {
   const threads = resolveThreadCount(engineMode, self.navigator?.hardwareConcurrency);
   const signal = activeExportAbortController?.signal;
 
-  // FFmpeg emits progress per frame; post only when the whole percentage
-  // changes so the main thread isn't flooded with identical updates.
+  // FFmpeg's own `progress` divides by the duration in the file header, which
+  // live-recorded files (MediaRecorder) don't have. Prefer encoded time over
+  // the length we expect, which also accounts for trim and speed.
+  const expectedSeconds = expectedOutputSeconds(recipe, videoDuration);
+  // FFmpeg emits progress per frame; post only when the whole percentage or
+  // the encoded second changes so the main thread isn't flooded.
   let lastPercent = -1;
-  const handleProgress = ({ progress }: { progress: number }) => {
+  let lastSecond = -1;
+  const handleProgress = ({ progress, time }: { progress: number; time?: number }) => {
     if (activeExportId !== sessionId) return;
     heartbeat();
-    const percent = Math.max(0, Math.min(99, Math.round(progress * 100)));
-    if (percent === lastPercent) return;
+    const outputSeconds = typeof time === "number" && Number.isFinite(time) && time > 0 ? time / 1e6 : undefined;
+    const fraction =
+      expectedSeconds !== null && outputSeconds !== undefined
+        ? outputSeconds / expectedSeconds
+        : Number.isFinite(progress)
+          ? progress
+          : 0;
+    const percent = Math.max(0, Math.min(99, Math.round(fraction * 100)));
+    const second = outputSeconds === undefined ? -1 : Math.floor(outputSeconds);
+    if (percent === lastPercent && second === lastSecond) return;
     lastPercent = percent;
-    postMessage({ type: "progress", percent });
+    lastSecond = second;
+    postMessage({ type: "progress", percent, outputSeconds });
   };
 
   // FFmpeg prints a stats line about twice a second while it works, so log
diff --git a/src/lib/ffmpegArgs.ts b/src/lib/ffmpegArgs.ts
index 2a0499c14..2c678e7c0 100644
--- a/src/lib/ffmpegArgs.ts
+++ b/src/lib/ffmpegArgs.ts
@@ -55,16 +55,62 @@ function outputThreadArgs(threads: number, hasFilterComplex: boolean): string[]
 /**
  * Explicit output duration. Stops encoder flush overshoot and, with looped
  * background music (`-stream_loop -1`) on a silent video, an export that
- * never ends. Omitted when the duration is unknown (metadata read failed):
- * `-t 0` would produce an empty file.
+ * never ends. Omitted when the duration is unknown (metadata read failed, or
+ * a live-recorded file whose header has none): `-t 0` would produce an empty
+ * file, and `-t Infinity` / `-t NaN` are invalid.
  */
 export function outputDurationArgs(recipe: EditRecipe, videoDuration: number): string[] {
-  const sourceDuration = (recipe.trimEnd ?? videoDuration) - recipe.trimStart;
-  if (!(sourceDuration > 0) || !(recipe.speed > 0)) return [];
-  return ["-t", (sourceDuration / recipe.speed).toFixed(6)];
+  const seconds = expectedOutputSeconds(recipe, videoDuration);
+  return seconds === null ? [] : ["-t", seconds.toFixed(6)];
 }
 
-export function buildVideoFilter(recipe: EditRecipe, targetW: number, targetH: number): string {
+/** A usable duration in seconds: finite and positive. */
+export function isUsableDuration(seconds: unknown): seconds is number {
+  return typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0;
+}
+
+/**
+ * Length of the exported video in seconds, or null when it can't be known
+ * (no usable source duration and no trim end, or an invalid speed).
+ */
+export function expectedOutputSeconds(recipe: EditRecipe, videoDuration: number): number | null {
+  if (!isUsableDuration(recipe.speed)) return null;
+  const end = recipe.trimEnd ?? videoDuration;
+  if (!isUsableDuration(end)) return null;
+  const start = Number.isFinite(recipe.trimStart) && recipe.trimStart > 0 ? recipe.trimStart : 0;
+  const seconds = (end - start) / recipe.speed;
+  return isUsableDuration(seconds) ? seconds : null;
+}
+
+/**
+ * The recipe with every time value FFmpeg will see made valid: a non-finite
+ * or negative trim start becomes 0, a trim end that isn't finite or isn't
+ * after the start becomes "to the end of the stream", and an unusable speed
+ * becomes 1. The editor shouldn't produce these, but a bad value would
+ * otherwise reach FFmpeg as "Infinity" or "NaN".
+ */
+export function withSafeTimes(recipe: EditRecipe): EditRecipe {
+  const trimStart = Number.isFinite(recipe.trimStart) && recipe.trimStart > 0 ? recipe.trimStart : 0;
+  const trimEnd =
+    recipe.trimEnd !== null && Number.isFinite(recipe.trimEnd) && recipe.trimEnd > trimStart
+      ? recipe.trimEnd
+      : null;
+  const speed = isUsableDuration(recipe.speed) ? recipe.speed : 1;
+  if (trimStart === recipe.trimStart && trimEnd === recipe.trimEnd && speed === recipe.speed) return recipe;
+  return { ...recipe, trimStart, trimEnd, speed };
+}
+
+/** Throws if any argument carries a non-finite number. Last line of defence. */
+export function assertFiniteArgs(args: string[]): string[] {
+  const bad = args.find((arg) => /(^|[^a-z])(-?Infinity|NaN)([^a-z]|$)/.test(arg));
+  if (bad !== undefined) {
+    throw new Error(`Invalid export settings: a time value is not a number (${bad.slice(0, 80)})`);
+  }
+  return args;
+}
+
+export function buildVideoFilter(input: EditRecipe, targetW: number, targetH: number): string {
+  const recipe = withSafeTimes(input);
   const filters: string[] = [];
 
   if (recipe.trimStart > 0 || recipe.trimEnd !== null) {
@@ -138,8 +184,8 @@ export function buildVideoFilter(recipe: EditRecipe, targetW: number, targetH: n
   return filters.join(",");
 }
 
-export function buildAudioFilter(recipe: EditRecipe): string {
-  if (recipe.speed <= 0) return "";
+export function buildAudioFilter(input: EditRecipe): string {
+  const recipe = withSafeTimes(input);
   const filters: string[] = [];
 
   let remaining = recipe.speed;
@@ -166,7 +212,8 @@ export function buildAudioFilter(recipe: EditRecipe): string {
   return filters.join(",");
 }
 
-export function buildAudioTrimFilter(recipe: EditRecipe): string {
+export function buildAudioTrimFilter(input: EditRecipe): string {
+  const recipe = withSafeTimes(input);
   if (recipe.trimStart === 0 && recipe.trimEnd === null) return "";
   let trimFilter = `atrim=start=${recipe.trimStart}`;
   if (recipe.trimEnd !== null) {
@@ -198,7 +245,7 @@ export interface ExportArgsOptions {
 }
 
 export function buildArguments({
-  recipe,
+  recipe: input,
   format,
   inputName,
   outputName,
@@ -210,6 +257,7 @@ export function buildArguments({
   overlay,
   threads,
 }: ExportArgsOptions): string[] {
+  const recipe = withSafeTimes(input);
   const vf = buildVideoFilter(recipe, targetW, targetH);
   const audioTrim = hasOriginalAudio ? buildAudioTrimFilter(recipe) : "";
   const audioSpeed = hasOriginalAudio ? buildAudioFilter(recipe) : "";
@@ -319,9 +367,13 @@ export function buildArguments({
   }
 
   args.push(...outputThreadArgs(threads, usesFilterComplex));
-  args.push(...outputDurationArgs(recipe, videoDuration));
+  const durationArgs = outputDurationArgs(recipe, videoDuration);
+  args.push(...durationArgs);
+  // Without -t, looped music (-stream_loop -1) never ends: stop at the end
+  // of the shortest stream, which is the video.
+  if (durationArgs.length === 0 && music?.options.loopMusic) args.push("-shortest");
   args.push(outputName);
-  return args;
+  return assertFiniteArgs(args);
 }
 
 export interface GifArgsOptions {
@@ -337,7 +389,7 @@ export interface GifArgsOptions {
 
 /** Two-pass GIF: palettegen, then paletteuse. */
 export function buildGifArguments({
-  recipe,
+  recipe: input,
   inputName,
   paletteName,
   outputName,
@@ -346,6 +398,7 @@ export function buildGifArguments({
   videoDuration,
   threads,
 }: GifArgsOptions): { palette: string[]; render: string[] } {
+  const recipe = withSafeTimes(input);
   const vf = buildVideoFilter(recipe, targetW, targetH);
   const vfWithPalette = vf ? `${vf},palettegen` : "palettegen";
   const vfWithPaletteUse = vf ? `[0:v]${vf}[x];[x][1:v]paletteuse` : "[0:v][1:v]paletteuse";
@@ -354,17 +407,17 @@ export function buildGifArguments({
   const durationArgs = recipe.speed !== 1 ? outputDurationArgs(recipe, videoDuration) : [];
 
   return {
-    palette: [
+    palette: assertFiniteArgs([
       ...inputThreadArgs(threads), "-i", inputName,
       "-vf", vfWithPalette,
       ...durationArgs, ...outputThreadArgs(threads, false),
       "-y", paletteName,
-    ],
-    render: [
+    ]),
+    render: assertFiniteArgs([
       ...inputThreadArgs(threads), "-i", inputName, "-i", paletteName,
       "-lavfi", vfWithPaletteUse,
       ...durationArgs, ...outputThreadArgs(threads, true),
       "-y", outputName,
-    ],
+    ]),
   };
 }
diff --git a/src/lib/mediaDuration.ts b/src/lib/mediaDuration.ts
new file mode 100644
index 000000000..557f6d000
--- /dev/null
+++ b/src/lib/mediaDuration.ts
@@ -0,0 +1,45 @@
+import { isUsableDuration } from "./ffmpegArgs";
+
+/**
+ * The duration of a video element whose metadata has loaded, in seconds, or 0
+ * when it can't be found.
+ *
+ * Files recorded live (MediaRecorder, so most browser screen recordings) have
+ * no duration in their header, and the browser reports Infinity until it has
+ * read to the end. Seeking far past the end makes it find the real duration.
+ * The element is left at time 0.
+ */
+export function resolveDuration(video: HTMLVideoElement, timeoutMs = 4000): Promise<number> {
+  if (isUsableDuration(video.duration)) return Promise.resolve(video.duration);
+  if (video.duration !== Infinity) return Promise.resolve(0);
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value: number) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      video.removeEventListener("durationchange", check);
+      video.removeEventListener("timeupdate", check);
+      video.removeEventListener("seeked", check);
+      try {
+        video.currentTime = 0;
+      } catch {
+        // the element may already be detached
+      }
+      resolve(value);
+    };
+    const check = () => {
+      if (isUsableDuration(video.duration)) finish(video.duration);
+    };
+    const timer = setTimeout(() => finish(0), timeoutMs);
+    video.addEventListener("durationchange", check);
+    video.addEventListener("timeupdate", check);
+    video.addEventListener("seeked", check);
+    try {
+      video.currentTime = Number.MAX_SAFE_INTEGER;
+    } catch {
+      finish(0);
+    }
+  });
+}
diff --git a/src/lib/tests/exportTelemetry.test.ts b/src/lib/tests/exportTelemetry.test.ts
index fa7f9ab0b..99e6db16b 100644
--- a/src/lib/tests/exportTelemetry.test.ts
+++ b/src/lib/tests/exportTelemetry.test.ts
@@ -8,15 +8,7 @@ import {
   type ExportContext,
 } from "../exportTelemetry";
 import { HANDLED_ERROR_PREFIX, registerRum, resetTelemetryForTests, sanitizeRumEvent } from "../telemetry";
-import { FFmpegLoadError } from "../ffmpeg";
-
-// main has no stall watchdog yet; an error with its name must still map to "timeout".
-class ExportStalledError extends Error {
-  name = "ExportStalledError";
-  constructor(readonly mode: "multi" | "single") {
-    super("Export stopped responding");
-  }
-}
+import { ExportStalledError, FFmpegLoadError } from "../ffmpeg";
 import type { DatadogRum } from "@datadog/browser-rum";
 
 const context: ExportContext = {
@@ -47,6 +39,7 @@ const ALLOWED_KEYS = new Set([
   "from",
   "to",
   "stall_reason",
+  "stuck",
 ]);
 
 let rum: { addAction: ReturnType<typeof vi.fn>; addDurationVital: ReturnType<typeof vi.fn> };
@@ -110,6 +103,31 @@ describe("export attempt outcomes", () => {
     expect(events()[1]!.ctx).toMatchObject({ stage: "encode", category: "encode_error" });
   });
 
+  it("reports which watchdog rule stopped a stalled export", () => {
+    const attempt = new ExportAttempt(context);
+    attempt.encoding("multi");
+    expect(attempt.failed(new ExportStalledError("multi", "no_progress"))).toBe("timeout");
+    expect(events()[1]!.ctx).toMatchObject({ category: "timeout", stall_reason: "no_progress" });
+  });
+
+  it("a clip of unknown length that stalls or fails is reported as unknown_duration", () => {
+    const unknown = { ...context, clip_length: "unknown" };
+    const stalled = new ExportAttempt(unknown);
+    stalled.encoding("multi");
+    expect(stalled.failed(new ExportStalledError("multi", "overrun"))).toBe("unknown_duration");
+    expect(events()[1]!.ctx).toMatchObject({ category: "unknown_duration", stall_reason: "overrun" });
+
+    const failed = new ExportAttempt(unknown);
+    failed.encoding("single");
+    expect(failed.failed(new Error("ffmpeg exited with code 1"))).toBe("unknown_duration");
+
+    // Failures with a clearer cause keep it, and the engine stage is never this.
+    const oom = new ExportAttempt(unknown);
+    oom.encoding("single");
+    expect(oom.failed(new RangeError("Array buffer allocation failed"))).toBe("out_of_memory");
+    expect(new ExportAttempt(unknown).failed(new FFmpegLoadError("Failed to fetch"))).toBe("engine_load");
+  });
+
   it("marks retries, and whether the retry recovered", () => {
     new ExportAttempt(context, "timeout").succeeded("<25MB");
     expect(events()[0]!.ctx).toMatchObject({ is_retry: true, retry_after: "timeout" });
diff --git a/src/lib/tests/ffmpegArgs.test.ts b/src/lib/tests/ffmpegArgs.test.ts
index 2e4665057..4b367abf1 100644
--- a/src/lib/tests/ffmpegArgs.test.ts
+++ b/src/lib/tests/ffmpegArgs.test.ts
@@ -3,6 +3,10 @@ import {
   buildArguments,
   buildGifArguments,
   outputDurationArgs,
+  expectedOutputSeconds,
+  withSafeTimes,
+  assertFiniteArgs,
+  buildAudioFilter,
   resolveThreadCount,
   MT_THREAD_CAP,
   UNKNOWN_CORES_THREADS,
@@ -170,3 +174,90 @@ describe("outputDurationArgs", () => {
     expect(outputDurationArgs(recipe({ speed: 0 }), 6)).toEqual([]);
   });
 });
+
+describe("time values never reach FFmpeg as Infinity or NaN", () => {
+  const BAD = [Infinity, -Infinity, NaN];
+  const music = {
+    inputName: "music.mp3",
+    options: { file: null, musicVolume: 50, originalAudioVolume: 100, loopMusic: true },
+  } as unknown as ExportArgsOptions["music"];
+
+  it("expectedOutputSeconds only returns finite, positive lengths", () => {
+    expect(expectedOutputSeconds(recipe(), 10)).toBe(10);
+    expect(expectedOutputSeconds(recipe({ trimStart: 2, trimEnd: 8, speed: 2 }), 10)).toBe(3);
+    for (const bad of [...BAD, 0, -5]) {
+      expect(expectedOutputSeconds(recipe(), bad)).toBeNull();
+      expect(expectedOutputSeconds(recipe({ speed: bad }), 10)).toBeNull();
+    }
+    // A trim end still bounds the clip when the file's own duration is unknown.
+    expect(expectedOutputSeconds(recipe({ trimEnd: 4 }), Infinity)).toBe(4);
+  });
+
+  it("omits -t when the duration is unknown, at any speed", () => {
+    for (const bad of [...BAD, 0]) {
+      for (const speed of [0.5, 1, 2]) {
+        expect(outputDurationArgs(recipe({ speed }), bad)).toEqual([]);
+        expect(buildArguments(opts({ recipe: recipe({ speed }), videoDuration: bad }))).not.toContain("-t");
+      }
+    }
+  });
+
+  it("stops looped music at the end of the video when there's no -t", () => {
+    const args = buildArguments(opts({ videoDuration: Infinity, music }));
+    expect(args).toContain("-stream_loop");
+    expect(args).toContain("-shortest");
+    expect(args).not.toContain("-t");
+    // With a known length, -t bounds it instead.
+    expect(buildArguments(opts({ videoDuration: 6, music }))).not.toContain("-shortest");
+  });
+
+  it("repairs invalid trim and speed values instead of passing them on", () => {
+    const fixed = withSafeTimes(recipe({ trimStart: NaN, trimEnd: Infinity, speed: Infinity }));
+    expect(fixed).toMatchObject({ trimStart: 0, trimEnd: null, speed: 1 });
+    expect(withSafeTimes(recipe({ trimStart: 5, trimEnd: 3 })).trimEnd).toBeNull();
+    const ok = recipe({ trimStart: 1, trimEnd: 4, speed: 1.5 });
+    expect(withSafeTimes(ok)).toBe(ok);
+  });
+
+  it("an infinite speed doesn't hang the audio filter builder", () => {
+    expect(buildAudioFilter(recipe({ speed: Infinity }))).not.toMatch(/Infinity|NaN/);
+    expect(buildAudioFilter(recipe({ speed: NaN }))).not.toMatch(/Infinity|NaN/);
+  });
+
+  it("no combination of bad values produces a non-finite argument", () => {
+    const values = [...BAD, 0, -1, 2.5];
+    const failures: string[] = [];
+    for (const trimStart of values)
+      for (const trimEnd of [...values, null])
+        for (const speed of values)
+          for (const videoDuration of values) {
+            const r = recipe({ trimStart, trimEnd, speed });
+            const all = [
+              ...buildArguments(opts({ recipe: r, videoDuration })),
+              ...buildArguments(opts({ recipe: r, videoDuration, format: "webm", music })),
+              ...Object.values(
+                buildGifArguments({
+                  recipe: r,
+                  inputName: "in.mp4",
+                  paletteName: "p.png",
+                  outputName: "out.gif",
+                  targetW: 480,
+                  targetH: 270,
+                  videoDuration,
+                  threads: 4,
+                })
+              ).flat(),
+            ];
+            const bad = all.find((arg) => /Infinity|NaN/.test(arg));
+            if (bad) failures.push(`${JSON.stringify({ trimStart, trimEnd, speed, videoDuration })}: ${bad}`);
+          }
+    expect(failures).toEqual([]);
+  });
+
+  it("assertFiniteArgs rejects a non-finite argument with a clear error", () => {
+    expect(() => assertFiniteArgs(["-t", "Infinity"])).toThrow(/time value is not a number/);
+    expect(() => assertFiniteArgs(["-vf", "trim=start=NaN"])).toThrow();
+    // Words that merely contain the letters are fine.
+    expect(assertFiniteArgs(["-i", "Nanaimo.mp4", "-metadata", "title=Infinityband"])).toHaveLength(4);
+  });
+});
diff --git a/src/lib/tests/ffmpegClient.test.ts b/src/lib/tests/ffmpegClient.test.ts
index 7054b38d7..6bb09d4f7 100644
--- a/src/lib/tests/ffmpegClient.test.ts
+++ b/src/lib/tests/ffmpegClient.test.ts
@@ -10,6 +10,8 @@ import {
   FFmpegLoadError,
   ExportStalledError,
   STALL_TIMEOUT_MS,
+  NO_PROGRESS_TIMEOUT_MS,
+  overrunLimitSeconds,
 } from "../ffmpeg";
 import { DEFAULT_RECIPE } from "../constants";
 
@@ -265,5 +267,103 @@ describe("FFmpeg client lifecycle", () => {
     expect(onFallback).not.toHaveBeenCalled();
     expect(workers).toHaveLength(1);
   });
+
+  it("a stall's message says what happened and to press Retry", async () => {
+    vi.useFakeTimers();
+    // Single-threaded: a multi-threaded stall would be retried automatically.
+    script.onExport = () => {};
+    const pending = run();
+    const assertion = expect(pending).rejects.toMatchObject({
+      reason: "no_activity",
+      message: expect.stringMatching(/stopped responding\. Press Retry/),
+    });
+    await vi.advanceTimersByTimeAsync(STALL_TIMEOUT_MS + 5_000);
+    await assertion;
+  });
+
+  it("fails an export that keeps logging but encodes nothing new (stuck at 100%)", async () => {
+    vi.useFakeTimers();
+    let worker!: FakeWorker;
+    script.onExport = (w) => {
+      worker = w;
+      w.emit({ type: "progress", percent: 99, outputSeconds: 5.9 });
+    };
+    const pending = run();
+    const assertion = expect(pending).rejects.toMatchObject({ name: "ExportStalledError", reason: "no_progress" });
+    for (let t = 0; t <= NO_PROGRESS_TIMEOUT_MS; t += 10_000) {
+      await vi.advanceTimersByTimeAsync(10_000);
+      worker?.emit({ type: "heartbeat" });
+      worker?.emit({ type: "progress", percent: 99, outputSeconds: 5.9 });
+    }
+    await assertion;
+    expect(workers[0]!.terminated).toBe(true);
+  });
+
+  it("keeps a long export alive while encoded time keeps advancing", async () => {
+    vi.useFakeTimers();
+    let worker!: FakeWorker;
+    let jobId = "";
+    script.onExport = (w, id) => {
+      worker = w;
+      jobId = id;
+    };
+    const pending = exportVideo(file(), { ...DEFAULT_RECIPE }, vi.fn(), undefined, undefined, undefined, 600);
+    for (let t = 1; t <= 30; t++) {
+      await vi.advanceTimersByTimeAsync(10_000);
+      worker?.emit({ type: "progress", percent: Math.round((t * 10 * 100) / 600), outputSeconds: t * 10 });
+    }
+    worker.emit(result(jobId));
+    await expect(pending).resolves.toMatchObject({ size: 8 });
+  });
+
+  it("without encoded-time reports, only silence counts as a stall", async () => {
+    vi.useFakeTimers();
+    let worker!: FakeWorker;
+    let jobId = "";
+    script.onExport = (w, id) => {
+      worker = w;
+      jobId = id;
+    };
+    const pending = run();
+    for (let t = 0; t < NO_PROGRESS_TIMEOUT_MS * 2; t += 10_000) {
+      await vi.advanceTimersByTimeAsync(10_000);
+      worker?.emit({ type: "progress", percent: 0 });
+    }
+    worker.emit(result(jobId));
+    await expect(pending).resolves.toMatchObject({ size: 8 });
+  });
+
+  it("fails an export that runs far past the clip's length", async () => {
+    vi.useFakeTimers();
+    script.onExport = (w) => {
+      // A 6 s clip; looped music without -t would keep going like this.
+      [3, 6, 12, 30].forEach((outputSeconds) => w.emit({ type: "progress", percent: 99, outputSeconds }));
+    };
+    const pending = run();
+    const assertion = expect(pending).rejects.toMatchObject({ reason: "overrun" });
+    await vi.advanceTimersByTimeAsync(5_000);
+    await assertion;
+  });
+
+  it("never posts a non-finite duration to the worker", async () => {
+    // jsdom never loads media, so the fallback metadata read times out (5 s).
+    vi.useFakeTimers();
+    script.onExport = (w, id) => w.emit(result(id));
+    for (const knownDuration of [Infinity, NaN, -1, 0]) {
+      const pending = exportVideo(file(), { ...DEFAULT_RECIPE }, vi.fn(), undefined, undefined, undefined, knownDuration);
+      await vi.advanceTimersByTimeAsync(6_000);
+      await pending;
+    }
+    const durations = workers.flatMap((w) => w.posted).filter((m) => m.type === "export").map((m) => (m as { videoDuration?: number }).videoDuration);
+    expect(durations).toHaveLength(4);
+    for (const d of durations) expect(Number.isFinite(d)).toBe(true);
+  });
+});
+
+describe("overrunLimitSeconds", () => {
+  it("allows a margin over the expected length", () => {
+    expect(overrunLimitSeconds(6)).toBeGreaterThan(6);
+    expect(overrunLimitSeconds(600)).toBeGreaterThan(700);
+  });
 });
 
diff --git a/src/lib/tests/mediaDuration.test.ts b/src/lib/tests/mediaDuration.test.ts
new file mode 100644
index 000000000..8caeb8a3e
--- /dev/null
+++ b/src/lib/tests/mediaDuration.test.ts
@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { resolveDuration } from "../mediaDuration";
+
+/** A video element whose duration becomes known once it is seeked to `revealAt`. */
+function fakeVideo(initial: number, reveal?: { duration: number; on: "durationchange" | "seeked" }) {
+  const target = new EventTarget() as EventTarget & { duration: number; currentTime: number };
+  let duration = initial;
+  let time = 0;
+  Object.defineProperty(target, "duration", { get: () => duration });
+  Object.defineProperty(target, "currentTime", {
+    get: () => time,
+    set(value: number) {
+      time = value;
+      if (reveal && value > 1e6) {
+        queueMicrotask(() => {
+          duration = reveal.duration;
+          target.dispatchEvent(new Event(reveal.on));
+        });
+      }
+    },
+  });
+  return target as unknown as HTMLVideoElement;
+}
+
+afterEach(() => vi.useRealTimers());
+
+describe("resolveDuration", () => {
+  it("returns a known duration straight away", async () => {
+    await expect(resolveDuration(fakeVideo(12.5))).resolves.toBe(12.5);
+  });
+
+  it("finds the real length of a live recording (Infinity) by seeking past the end", async () => {
+    const video = fakeVideo(Infinity, { duration: 6, on: "durationchange" });
+    await expect(resolveDuration(video)).resolves.toBe(6);
+    expect(video.currentTime).toBe(0);
+  });
+
+  it("also accepts the length reported on seeked", async () => {
+    await expect(resolveDuration(fakeVideo(Infinity, { duration: 9, on: "seeked" }))).resolves.toBe(9);
+  });
+
+  it("gives up with 0 when the browser never finds it", async () => {
+    vi.useFakeTimers();
+    const pending = resolveDuration(fakeVideo(Infinity), 4000);
+    await vi.advanceTimersByTimeAsync(4000);
+    await expect(pending).resolves.toBe(0);
+  });
+
+  it("treats NaN and non-positive durations as unknown", async () => {
+    await expect(resolveDuration(fakeVideo(NaN))).resolves.toBe(0);
+    await expect(resolveDuration(fakeVideo(0))).resolves.toBe(0);
+  });
+});
diff --git a/test/e2e/export.spec.ts b/test/e2e/export.spec.ts
new file mode 100644
index 000000000..d29de6c96
--- /dev/null
+++ b/test/e2e/export.spec.ts
@@ -0,0 +1,135 @@
+import { test, expect, type Page } from "@playwright/test";
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+// Fixtures come from scripts/make-fixtures.sh (test/fixtures/, gitignored).
+const FIXTURES = join(__dirname, "..", "fixtures");
+
+interface Fixture {
+  file: string;
+  hasAudio: boolean;
+  /** Only with E2E_LARGE=1: slow, and needs a lot of memory. */
+  large?: boolean;
+}
+
+const fixtures: Fixture[] = [
+  { file: "normal.mp4", hasAudio: true },
+  // No duration in the container, like a browser screen recording.
+  { file: "no-duration.webm", hasAudio: true },
+  { file: "portrait.mp4", hasAudio: true },
+  { file: "no-audio.mp4", hasAudio: false },
+  { file: "large.mp4", hasAudio: true, large: true },
+];
+
+interface Probe {
+  width: number;
+  height: number;
+  duration: number;
+  audioStreams: number;
+}
+
+function probe(path: string): Probe {
+  const out = execFileSync(
+    "ffprobe",
+    ["-v", "error", "-show_entries", "stream=codec_type,width,height:format=duration", "-of", "json", path],
+    { encoding: "utf8" }
+  );
+  const json = JSON.parse(out) as {
+    streams: { codec_type: string; width?: number; height?: number }[];
+    format: { duration?: string };
+  };
+  const video = json.streams.find((s) => s.codec_type === "video");
+  return {
+    width: video?.width ?? 0,
+    height: video?.height ?? 0,
+    duration: Number(json.format.duration ?? NaN),
+    audioStreams: json.streams.filter((s) => s.codec_type === "audio").length,
+  };
+}
+
+async function openSection(page: Page, name: RegExp) {
+  const toggle = page.getByRole("button", { name }).first();
+  if ((await toggle.getAttribute("aria-expanded")) === "false") await toggle.click();
+}
+
+async function loadEditor(page: Page, fixture: string) {
+  // Skip the onboarding tour, which covers the controls.
+  await page.addInitScript(() => localStorage.setItem("reframe_onboarding_complete", "1"));
+  await page.goto("/");
+  await page.locator('input[type=file][accept="video/*"]').setInputFiles(join(FIXTURES, fixture));
+  await expect(page.getByRole("button", { name: "Export video" }).first()).toBeVisible();
+}
+
+async function exportAndDownload(page: Page, savePath: string) {
+  await page.getByRole("button", { name: "Export video" }).first().click();
+  const download = page.getByRole("link", { name: /^Download (MP4|WEBM|MKV|GIF)$/ });
+  const failure = page.getByText(/^Export failed|stopped (responding|making progress)/).first();
+  await expect(download.or(failure)).toBeVisible({ timeout: 180_000 });
+  await expect(failure, "the export reported an error").toHaveCount(0);
+  const [file] = await Promise.all([page.waitForEvent("download"), download.click()]);
+  await file.saveAs(savePath);
+}
+
+test.describe("export", () => {
+  test.beforeAll(() => {
+    const missing = fixtures.filter((f) => !f.large && !existsSync(join(FIXTURES, f.file)));
+    if (missing.length) throw new Error(`Missing fixtures (${missing.map((f) => f.file).join(", ")}): run scripts/make-fixtures.sh`);
+  });
+
+  for (const fixture of fixtures) {
+    test(`${fixture.file}: trim, rotate and speed up, then export a valid file`, async ({ page }, testInfo) => {
+      test.skip(!!fixture.large && !process.env.E2E_LARGE, "set E2E_LARGE=1 to run the ~300 MB fixture");
+
+      await loadEditor(page, fixture.file);
+      const isolated = await page.evaluate(() => crossOriginIsolated);
+      expect(isolated).toBe(testInfo.project.name === "multi-threaded");
+
+      // 1:1 output, so the expected size doesn't depend on the input's shape.
+      await page.getByRole("button", { name: "1 is to 1 output ratio" }).click();
+
+      await openSection(page, /^Trim$/i);
+      await page.getByLabel("Trim start time in seconds").fill("1");
+      await page.getByLabel("Trim end time in seconds").fill("5");
+
+      await openSection(page, /^Rotation$/i);
+      await page.getByRole("button", { name: "Rotate video to 90 degrees" }).click();
+
+      await openSection(page, /Audio & Speed/i);
+      await page.getByRole("button", { name: "Set speed to 2x" }).click();
+
+      const out = testInfo.outputPath(`${fixture.file}.mp4`);
+      await exportAndDownload(page, out);
+
+      const result = probe(out);
+      expect(result.width).toBe(1080);
+      expect(result.height).toBe(1080);
+      // 4 s of source (1 s → 5 s) at 2× speed.
+      expect(result.duration).toBeGreaterThan(1.7);
+      expect(result.duration).toBeLessThan(2.4);
+      expect(result.audioStreams).toBe(fixture.hasAudio ? 1 : 0);
+    });
+  }
+
+  test("no-duration.webm: the editor finds the real length", async ({ page }) => {
+    await loadEditor(page, "no-duration.webm");
+    await openSection(page, /^Trim$/i);
+    // The end field's placeholder and limit are the clip's length (6 s), not
+    // empty, 0 or Infinity, so trimming works on screen recordings.
+    const end = page.getByLabel("Trim end time in seconds");
+    await expect(end).toHaveAttribute("placeholder", "6.0");
+    expect(Number(await end.getAttribute("max"))).toBeCloseTo(6, 1);
+    await expect(page.getByText("Duration: 0:06")).toBeVisible();
+  });
+
+  test("no-duration.webm at 2× speed without a trim exports the whole clip", async ({ page }, testInfo) => {
+    await loadEditor(page, "no-duration.webm");
+    await openSection(page, /Audio & Speed/i);
+    await page.getByRole("button", { name: "Set speed to 2x" }).click();
+    const out = testInfo.outputPath("no-duration-2x.mp4");
+    await exportAndDownload(page, out);
+    const result = probe(out);
+    expect(result.duration).toBeGreaterThan(2.6);
+    expect(result.duration).toBeLessThan(3.4);
+  });
+});
diff --git a/vitest.config.ts b/vitest.config.ts
index 968b89566..3cd79a0ad 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -16,5 +16,7 @@ export default defineConfig({
     environment: 'jsdom',
     globals: true,
     setupFiles: './vitest.setup.ts',
+    // Playwright specs (test/e2e) run with `bunx playwright test`, not Vitest.
+    exclude: ['**/node_modules/**', 'test/e2e/**'],
   },
 })