diff --git a/examples/aws-lambda/template.yaml b/examples/aws-lambda/template.yaml
index 4aaad5b38b..7ae0b7f6f8 100644
--- a/examples/aws-lambda/template.yaml
+++ b/examples/aws-lambda/template.yaml
@@ -265,6 +265,8 @@ Resources:
                   - PlanProtocolUnsupportedError
                   - VIDEO_SOURCE_UNRENDERABLE
                   - INVALID_VIDEO_METADATA
+                  - NOT_MEDIA_PAYLOAD
+                  - NotMediaPayloadError
                   - PLAN_ARTIFACT_DIGEST_MISMATCH
                   - FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
                 MaxAttempts: 0
@@ -309,6 +311,8 @@ Resources:
                   - PLAN_V2_INTEGRITY_UNRECOVERABLE
                   - VIDEO_SOURCE_UNRENDERABLE
                   - INVALID_VIDEO_METADATA
+                  - NOT_MEDIA_PAYLOAD
+                  - NotMediaPayloadError
                   - PlanV2IntegrityError
                   - PLAN_ARTIFACT_DIGEST_MISMATCH
                   - FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
diff --git a/packages/aws-lambda/src/cdk/HyperframesRenderStack.snapshot.test.ts b/packages/aws-lambda/src/cdk/HyperframesRenderStack.snapshot.test.ts
index 1f528294dc..c7f27f503b 100644
--- a/packages/aws-lambda/src/cdk/HyperframesRenderStack.snapshot.test.ts
+++ b/packages/aws-lambda/src/cdk/HyperframesRenderStack.snapshot.test.ts
@@ -78,6 +78,8 @@ const EXPECTED_NON_RETRYABLE_ERRORS = new Set([
   "PLAN_V2_INTEGRITY_UNRECOVERABLE",
   "VIDEO_SOURCE_UNRENDERABLE",
   "INVALID_VIDEO_METADATA",
+  "NOT_MEDIA_PAYLOAD",
+  "NotMediaPayloadError",
   "PlanV2IntegrityError",
   "PLAN_ARTIFACT_DIGEST_MISMATCH",
   "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED",
diff --git a/packages/aws-lambda/src/cdk/HyperframesRenderStack.ts b/packages/aws-lambda/src/cdk/HyperframesRenderStack.ts
index 1c371de246..baa7bd6b17 100644
--- a/packages/aws-lambda/src/cdk/HyperframesRenderStack.ts
+++ b/packages/aws-lambda/src/cdk/HyperframesRenderStack.ts
@@ -206,6 +206,8 @@ export class HyperframesRenderStack extends Construct {
       "PLAN_V2_INTEGRITY_UNRECOVERABLE",
       "VIDEO_SOURCE_UNRENDERABLE",
       "INVALID_VIDEO_METADATA",
+      "NOT_MEDIA_PAYLOAD",
+      "NotMediaPayloadError",
       "PlanV2IntegrityError",
       "PLAN_ARTIFACT_DIGEST_MISMATCH",
       "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED",
diff --git a/packages/aws-lambda/src/handler.ts b/packages/aws-lambda/src/handler.ts
index e224fde6e0..bd10c12c20 100644
--- a/packages/aws-lambda/src/handler.ts
+++ b/packages/aws-lambda/src/handler.ts
@@ -152,6 +152,7 @@ function normalizeTerminalErrorName(error: unknown): void {
     candidate.code === "PLAN_V2_INTEGRITY_UNRECOVERABLE" ||
     candidate.code === "FONT_FETCH_FAILED" ||
     candidate.code === "FONT_FETCH_UNAVAILABLE" ||
+    candidate.code === "NOT_MEDIA_PAYLOAD" ||
     candidate.code === "VIDEO_SOURCE_UNRENDERABLE" ||
     candidate.code === "VIDEO_EXTRACTION_FAILED" ||
     candidate.code === "INVALID_VIDEO_METADATA"
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 7a16306591..5b5f71f7fb 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -273,6 +273,14 @@ export {
   type KeyframeAnalysis,
 } from "./utils/ffprobe.js";
 
+export {
+  NOT_MEDIA_PAYLOAD,
+  NotMediaPayloadError,
+  assertMediaPayload,
+  fingerprintElementId,
+  isNotMediaPayload,
+} from "./utils/notMediaPayload.js";
+
 export { assertPublicHttpsUrl, downloadToTemp, isHttpUrl } from "./utils/urlDownloader.js";
 export {
   runFfmpeg,
diff --git a/packages/engine/src/services/audioMixer.test.ts b/packages/engine/src/services/audioMixer.test.ts
index bc49a149ed..96f5a66069 100644
--- a/packages/engine/src/services/audioMixer.test.ts
+++ b/packages/engine/src/services/audioMixer.test.ts
@@ -115,6 +115,50 @@ describe("processCompositionAudio", () => {
     ]);
   });
 
+  // STUDIO-5433: an audio src that resolved to an HTML/XML page (an unresolved
+  // nested-composition preview URL, or a 403/404 body served as a 200) skips the
+  // probe entirely when the element carries an authored duration, and used to
+  // surface as `prepare/ffmpeg_failed` with owner "system" — an authoring bug
+  // paged as a platform fault, after every frame had already been captured.
+  it("classifies a document audio source as a user-owned invalid media source", async () => {
+    const baseDir = mkdtempSync(join(tmpdir(), "hf-audio-base-"));
+    const workDir = mkdtempSync(join(tmpdir(), "hf-audio-work-"));
+    tempDirs.push(baseDir, workDir);
+    writeFileSync(join(baseDir, "bgm.mp3"), "<!DOCTYPE html><html><body>not audio</body></html>");
+
+    const result = await processCompositionAudio(
+      [
+        {
+          id: "bgm",
+          src: "bgm.mp3",
+          // Authored duration + loop is the shape that bypasses every probe.
+          start: 0,
+          end: 30,
+          mediaStart: 0,
+          layer: 0,
+          volume: 1,
+          type: "audio",
+        },
+      ],
+      baseDir,
+      workDir,
+      join(baseDir, "out.m4a"),
+      30,
+    );
+
+    expect(result.failures).toEqual([
+      expect.objectContaining({
+        stage: "source",
+        reason: "invalid_media",
+        owner: "user",
+        retryable: false,
+        elementId: "bgm",
+      }),
+    ]);
+    // Never reached ffmpeg: the whole point is failing before the work.
+    expect(runFfmpegMock).not.toHaveBeenCalled();
+  });
+
   it("preserves muted tracks and uses unity master gain by default", async () => {
     const baseDir = mkdtempSync(join(tmpdir(), "hf-audio-base-"));
     const workDir = mkdtempSync(join(tmpdir(), "hf-audio-work-"));
diff --git a/packages/engine/src/services/audioMixer.ts b/packages/engine/src/services/audioMixer.ts
index 1b063f3fd5..f27a9eabbb 100644
--- a/packages/engine/src/services/audioMixer.ts
+++ b/packages/engine/src/services/audioMixer.ts
@@ -9,6 +9,7 @@ import { closeSync, existsSync, mkdirSync, mkdtempSync, openSync, rmSync, writeF
 import { join, dirname } from "path";
 import { parseHTML } from "linkedom";
 import { extractAudioMetadata } from "../utils/ffprobe.js";
+import { isNotMediaPayload } from "../utils/notMediaPayload.js";
 import { downloadToTemp, isHttpUrl } from "../utils/urlDownloader.js";
 import { DEFAULT_CONFIG, type EngineConfig } from "../config.js";
 import { formatFfmpegError, runFfmpeg, type RunFfmpegResult } from "../utils/runFfmpeg.js";
@@ -733,6 +734,26 @@ export async function processCompositionAudio(
           return;
         }
 
+        // STUDIO-5433: an audio src that resolved to a text document (an
+        // unresolved nested-composition preview URL, or a 403/404 body served
+        // with a 200) never reaches the probe below when the element carries an
+        // authored duration or `loop`. It then fails inside ffmpeg as
+        // `prepare/ffmpeg_failed` with owner "system" — an authoring bug paged
+        // as a platform fault, after every frame has already been captured.
+        if (await isNotMediaPayload(srcPath)) {
+          failures.push({
+            stage: "source",
+            reason: "invalid_media",
+            owner: "user",
+            retryable: false,
+            elementId: element.id,
+            detail: boundedDetail(
+              `Audio element ${element.id} source is a text document (HTML/XML/JSON), not media`,
+            ),
+          });
+          return;
+        }
+
         // Fallback: if no duration was specified, probe the actual file
         if (element.end - element.start <= 0) {
           let metadata;
diff --git a/packages/engine/src/utils/notMediaPayload.test.ts b/packages/engine/src/utils/notMediaPayload.test.ts
new file mode 100644
index 0000000000..bdfdb844a9
--- /dev/null
+++ b/packages/engine/src/utils/notMediaPayload.test.ts
@@ -0,0 +1,177 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  assertMediaPayload,
+  fingerprintElementId,
+  isNotMediaPayload,
+  NotMediaPayloadError,
+} from "./notMediaPayload.js";
+
+function writeFixture(name: string, contents: string | Buffer): string {
+  const dir = mkdtempSync(join(tmpdir(), "hf-markup-sniff-"));
+  const filePath = join(dir, name);
+  writeFileSync(filePath, contents);
+  return filePath;
+}
+
+describe("isNotMediaPayload", () => {
+  it.each([
+    ["doctype", "<!DOCTYPE html>\n<html><body></body></html>"],
+    ["bare html tag, uppercase", "<HTML><body>hi</body></HTML>"],
+    [
+      "xml prolog",
+      '<?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg"/>',
+    ],
+    // The prolog-less form is the common minified SVG shape, and the one a
+    // `<!doctype|<html|<?xml` prefix allowlist misses.
+    ["prolog-less svg", '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"/>'],
+    // How a media URL most often downloads as XML in production: an expired
+    // signed URL or an ACL change, served as a 200 with an S3 error body.
+    ["s3 error document", '<?xml version="1.0"?><Error><Code>AccessDenied</Code></Error>'],
+    ["comment first", "<!-- generated -->\n<!DOCTYPE html>"],
+    // Replicate answers a dead asset this way, and a gateway in front of it can
+    // relay the body with a 200 — the shape a `<` -only check misses.
+    ["json object error body", '{"detail": "requested file not found"}'],
+    ["json array body", '[{"error": "gone"}]'],
+  ])("detects %s", async (_label, contents) => {
+    expect(await isNotMediaPayload(writeFixture("payload", contents))).toBe(true);
+  });
+
+  it("detects a document behind a UTF-8 BOM and leading whitespace", async () => {
+    const filePath = writeFixture(
+      "bom.html",
+      Buffer.concat([
+        Buffer.from([0xef, 0xbb, 0xbf]),
+        Buffer.from("\n  \t<!doctype html><html></html>"),
+      ]),
+    );
+    expect(await isNotMediaPayload(filePath)).toBe(true);
+  });
+
+  it("detects a document behind a leading NUL run", async () => {
+    const filePath = writeFixture(
+      "nul.html",
+      Buffer.concat([Buffer.from([0x00, 0x00, 0x00]), Buffer.from("<html>x</html>")]),
+    );
+    expect(await isNotMediaPayload(filePath)).toBe(true);
+  });
+
+  it.each([
+    ["little-endian", [0xff, 0xfe]],
+    ["big-endian", [0xfe, 0xff]],
+  ])("detects UTF-16 %s markup", async (_label, bom) => {
+    // UTF-16 interleaves NULs between ASCII bytes, so a utf8-decoded prefix
+    // comparison sees replacement characters and misses it entirely.
+    const body = Buffer.from("<html>", "utf16le");
+    const bytes = _label === "little-endian" ? body : body.swap16();
+    const filePath = writeFixture("utf16.html", Buffer.concat([Buffer.from(bom), bytes]));
+    expect(await isNotMediaPayload(filePath)).toBe(true);
+  });
+
+  it("detects nothing when padding overruns the sniff window", async () => {
+    const filePath = writeFixture("padded.html", `${" ".repeat(600)}<!doctype html>`);
+    // 600 bytes of padding overruns the 512-byte sniff window, so the verdict
+    // has to be "unknown" (false) rather than a misread — asserted here so the
+    // window size is a deliberate, visible bound rather than an accident.
+    expect(await isNotMediaPayload(filePath)).toBe(false);
+  });
+
+  it.each([
+    ["mp4 / ftypmp42", [0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x6d, 0x70, 0x34, 0x32]],
+    ["matroska / webm EBML", [0x1a, 0x45, 0xdf, 0xa3, 0x9f, 0x42, 0x86, 0x81, 0x01]],
+    ["ogg", [0x4f, 0x67, 0x67, 0x53, 0x00, 0x02]],
+    ["riff / wav", [0x52, 0x49, 0x46, 0x46, 0x24, 0x08]],
+    ["mpeg-ts", [0x47, 0x40, 0x00, 0x10]],
+    ["flac", [0x66, 0x4c, 0x61, 0x43, 0x00]],
+    ["mp3 / ID3", [0x49, 0x44, 0x33, 0x03, 0x00]],
+    ["adts aac", [0xff, 0xf1, 0x50, 0x80]],
+    ["mpeg-ps", [0x00, 0x00, 0x01, 0xba]],
+  ])("does not flag a %s container", async (_label, bytes) => {
+    expect(await isNotMediaPayload(writeFixture("clip.bin", Buffer.from(bytes)))).toBe(false);
+  });
+
+  it("does not flag a container that merely contains a document byte further in", async () => {
+    const filePath = writeFixture(
+      "not-html.bin",
+      Buffer.concat([Buffer.from([0x00, 0x00, 0x01, 0xba]), Buffer.from("<html later on")]),
+    );
+    expect(await isNotMediaPayload(filePath)).toBe(false);
+  });
+
+  it("does not flag an empty file", async () => {
+    expect(await isNotMediaPayload(writeFixture("empty.bin", ""))).toBe(false);
+  });
+
+  it("reports not-a-document instead of throwing when the path is a directory", async () => {
+    // `existsSync` passes for a directory, so callers reach the sniff with one.
+    // The read fails EISDIR; classifying rather than propagating keeps the real
+    // probe's own error as the one the caller sees.
+    const dir = mkdtempSync(join(tmpdir(), "hf-markup-sniff-dir-"));
+    mkdirSync(join(dir, "assets"));
+    expect(await isNotMediaPayload(join(dir, "assets"))).toBe(false);
+  });
+
+  it("reports not-a-document instead of throwing when the file is missing", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "hf-markup-sniff-gone-"));
+    expect(await isNotMediaPayload(join(dir, "evicted.mp4"))).toBe(false);
+  });
+});
+
+describe("assertMediaPayload", () => {
+  it("throws NotMediaPayloadError carrying routing metadata and a hashed element key", async () => {
+    const filePath = writeFixture("nested.html", "<!DOCTYPE html><html></html>");
+
+    let caught: unknown;
+    try {
+      await assertMediaPayload(filePath, "aroll-scene-3");
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(NotMediaPayloadError);
+    const error = caught as NotMediaPayloadError;
+    expect(error.code).toBe("NOT_MEDIA_PAYLOAD");
+    expect(error.owner).toBe("user");
+    expect(error.retryable).toBe(false);
+    expect(error.elementFingerprints).toEqual([fingerprintElementId("aroll-scene-3")]);
+    expect(error.message).toContain(fingerprintElementId("aroll-scene-3"));
+  });
+
+  it("names both possible causes and leaks neither the src nor the payload bytes", async () => {
+    // `error.message` is forwarded to API clients over SSE/JSON, so a
+    // per-tenant CDN path or a token in the payload's first bytes must not
+    // reach it — and an on-call engineer must not be pointed at the authoring
+    // bug when a 403 error page is the actual cause.
+    const filePath = writeFixture(
+      "interstitial.html",
+      '<!DOCTYPE html><html data-request-token="tok_9fA3xQ7pLz">',
+    );
+
+    const error = await assertMediaPayload(
+      filePath,
+      "https://cdn.example.com/tenants/acme-corp/projects/secret-q4/streamed-preview.html",
+    ).catch((caught: unknown) => caught as NotMediaPayloadError);
+
+    expect(error.message).not.toContain("acme-corp");
+    expect(error.message).not.toContain("secret-q4");
+    expect(error.message).not.toContain("cdn.example.com");
+    expect(error.message).not.toContain("tok_9fA3xQ7pLz");
+    expect(error.message).toContain("unresolved");
+    expect(error.message).toContain("success status");
+  });
+
+  it("resolves for a real container", async () => {
+    const filePath = writeFixture("clip.mp4", Buffer.from([0x00, 0x00, 0x00, 0x18, 0x66, 0x74]));
+    await expect(assertMediaPayload(filePath, "v1")).resolves.toBeUndefined();
+  });
+
+  it("caps the fingerprint list so the message stays bounded", async () => {
+    const error = new NotMediaPayloadError(
+      Array.from({ length: 12 }, (_unused, index) => fingerprintElementId(`el-${index}`)),
+    );
+    expect(error.message).toContain("+4");
+    expect(error.message.length).toBeLessThan(500);
+  });
+});
diff --git a/packages/engine/src/utils/notMediaPayload.ts b/packages/engine/src/utils/notMediaPayload.ts
new file mode 100644
index 0000000000..446e37ad09
--- /dev/null
+++ b/packages/engine/src/utils/notMediaPayload.ts
@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import { open as openFile } from "node:fs/promises";
+
+export const NOT_MEDIA_PAYLOAD = "NOT_MEDIA_PAYLOAD" as const;
+
+/** Cap the joined fingerprint list so the message stays bounded. */
+const MAX_LISTED_FINGERPRINTS = 8;
+
+/**
+ * Thrown when a file behind a `<video>`/`<audio>` src is a text document
+ * (HTML, XML, SVG, JSON) rather than a media container.
+ *
+ * Motivating incident: STUDIO-5433 — an authoring bug produced an a-roll
+ * element whose src pointed at a `streamed-preview.html` URL that downloaded
+ * to a legitimate 6.5 KB `<!DOCTYPE html>` page instead of the expected MP4.
+ * ffprobe's `[mov,mp4,m4a,3gp,3g2,mj2 @ ...] moov atom not found` masked the
+ * cause (the `mov,mp4,…` prefix is ffprobe's demuxer probe order, not the
+ * file's true format), so the alert routed as an ffmpeg/codec bug.
+ *
+ * Only a 2xx response reaches this classifier. `downloadToTemp` rejects a
+ * 404/410 as `http_not_found` before writing a byte (urlDownloader.ts
+ * `classifyHttpFailure`), and every ffprobe input is local — an http src is
+ * downloaded first. So the shapes that land here are a soft-404 or
+ * interstitial HTML body, an S3/CloudFront error document, or a JSON API error
+ * body, each served with a success status.
+ *
+ * Deliberately says nothing about *why* the payload is a document: an
+ * unresolved nested-composition URL and a CDN error page served with a 200
+ * both land here, and naming only the first sends on-call after the wrong
+ * cause.
+ *
+ * Message discipline mirrors `AssetMediaTypeMismatchError`: bounded text with
+ * hashed element correlation keys, never the authored src or the payload's own
+ * bytes — producer forwards `error.message` to API clients.
+ */
+export class NotMediaPayloadError extends Error {
+  readonly code = NOT_MEDIA_PAYLOAD;
+  readonly owner = "user" as const;
+  readonly retryable = false as const;
+  readonly elementFingerprints: readonly string[];
+
+  constructor(elementFingerprints: readonly string[]) {
+    const listed = elementFingerprints.slice(0, MAX_LISTED_FINGERPRINTS).join(",");
+    const elided = elementFingerprints.length - MAX_LISTED_FINGERPRINTS;
+    super(
+      `${elementFingerprints.length} media source(s) are text documents ` +
+        `(HTML/XML/JSON), not media containers ` +
+        `[elements=${listed}${elided > 0 ? `,+${elided}` : ""}]. Either an unresolved ` +
+        "nested-composition preview URL was authored as a media src, or the source answered with " +
+        "an error page or API error body carrying a success status.",
+    );
+    this.name = "NotMediaPayloadError";
+    this.elementFingerprints = elementFingerprints;
+  }
+}
+
+/** Stable, bounded correlation key. Never the raw element id or source. */
+export function fingerprintElementId(elementId: string): string {
+  return createHash("sha256").update(elementId).digest("hex").slice(0, 16);
+}
+
+const SNIFF_BYTES = 512;
+// `<` opens HTML/XML/SVG and an S3 `<Error>` body; `{` and `[` open a JSON API
+// error body, which some gateways return with a 200.
+const DOCUMENT_OPENING_BYTES = new Set([0x3c, 0x7b, 0x5b]);
+// NUL is skippable so UTF-16-encoded text (`3C 00 68 00 …`) is caught, and so
+// is a payload padded with NULs. No supported container is defeated by this:
+// mp4/mov open with a box size whose first non-NUL byte is the size itself, and
+// MPEG-PS `00 00 01 BA` stops at 0x01.
+const SKIPPABLE_LEADING_BYTES = new Set([0x00, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20]);
+const BYTE_ORDER_MARKS = [
+  Buffer.from([0xef, 0xbb, 0xbf]), // UTF-8
+  Buffer.from([0xff, 0xfe]), // UTF-16 LE
+  Buffer.from([0xfe, 0xff]), // UTF-16 BE
+];
+
+function byteOrderMarkLength(head: Buffer): number {
+  for (const mark of BYTE_ORDER_MARKS) {
+    if (head.length >= mark.length && head.subarray(0, mark.length).equals(mark)) {
+      return mark.length;
+    }
+  }
+  return 0;
+}
+
+/** Read up to {@link SNIFF_BYTES} from the front of the file. */
+async function readHead(filePath: string): Promise<Buffer> {
+  const fh = await openFile(filePath, "r");
+  try {
+    const buf = Buffer.alloc(SNIFF_BYTES);
+    let filled = 0;
+    // Looped because a single read can come back short on NFS/FUSE and on
+    // FIFOs, which would truncate the window mid-prefix.
+    while (filled < buf.length) {
+      const { bytesRead } = await fh.read(buf, filled, buf.length - filled, filled);
+      if (bytesRead === 0) break;
+      filled += bytesRead;
+    }
+    return buf.subarray(0, filled);
+  } finally {
+    await fh.close().catch(() => {});
+  }
+}
+
+function startsWithDocumentByte(head: Buffer): boolean {
+  for (let index = byteOrderMarkLength(head); index < head.length; index++) {
+    const byte = head[index];
+    if (byte === undefined) break;
+    if (SKIPPABLE_LEADING_BYTES.has(byte)) continue;
+    return DOCUMENT_OPENING_BYTES.has(byte);
+  }
+  // Empty or all-whitespace: not this classifier's call.
+  return false;
+}
+
+/**
+ * True when the file's first meaningful byte opens a text document (`<`, `{`,
+ * `[`) rather than a media container. BOM- and whitespace-tolerant.
+ *
+ * Three bytes replace an allowlist of document shapes: `<!doctype`, `<html`,
+ * `<?xml`, a prolog-less `<svg`, an S3 `<Error>` body, and a JSON
+ * `{"detail": "requested file not found"}` all start with one of them, and no
+ * container this pipeline supports does — mp4/mov start with a box size,
+ * Matroska/WebM `1A 45 DF A3`, Ogg `OggS`, RIFF `RIFF`, MPEG-TS `0x47`, FLAC
+ * `fLaC`, ADTS `FF Fx`, MP3 `ID3`. An allowlist would need a new entry every
+ * time a new payload shape shows up in production.
+ *
+ * Never throws: this is a classifier, not a gate. An unreadable file (EACCES,
+ * EISDIR, a temp file evicted between `existsSync` and here) reports "not a
+ * document" so the real probe still produces the real error, exactly as it did
+ * before the sniff existed.
+ */
+export async function isNotMediaPayload(filePath: string): Promise<boolean> {
+  try {
+    return startsWithDocumentByte(await readHead(filePath));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Throw {@link NotMediaPayloadError} if `filePath` is a text document.
+ *
+ * Only for sources whose element type can never legitimately be one —
+ * `<video>` and `<audio>`. An `<img>` src may be an SVG, which ffprobe reads
+ * through its `svg_pipe` demuxer, so image sources must not be sniffed.
+ */
+export async function assertMediaPayload(filePath: string, elementId: string): Promise<void> {
+  if (await isNotMediaPayload(filePath)) {
+    throw new NotMediaPayloadError([fingerprintElementId(elementId)]);
+  }
+}
diff --git a/packages/gcp-cloud-run/src/server.ts b/packages/gcp-cloud-run/src/server.ts
index 674a25e0ee..a7e8285724 100644
--- a/packages/gcp-cloud-run/src/server.ts
+++ b/packages/gcp-cloud-run/src/server.ts
@@ -906,11 +906,13 @@ const NON_RETRYABLE_ERROR_NAMES = new Set([
   "PLAN_V2_INTEGRITY_UNRECOVERABLE",
   "VIDEO_SOURCE_UNRENDERABLE",
   "INVALID_VIDEO_METADATA",
+  "NOT_MEDIA_PAYLOAD",
   // Producer error class names (`.name`) + their string code aliases — the
   // class sets `.name` to the class name but wraps a `code`; cover both so a
   // raw-code throw is caught too. Mirrors the AWS state machine's
   // non-retryable list.
   "FormatNotSupportedInDistributedError",
+  "NotMediaPayloadError",
   "PlanTooLargeError",
   "PlanProtocolUnsupportedError",
   "PlanV2IntegrityError",
diff --git a/packages/producer/src/server.notMediaErrorCode.test.ts b/packages/producer/src/server.notMediaErrorCode.test.ts
new file mode 100644
index 0000000000..cc524685f1
--- /dev/null
+++ b/packages/producer/src/server.notMediaErrorCode.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { NotMediaPayloadError } from "@hyperframes/engine";
+import { extractSafeRenderErrorMetadata } from "./server.js";
+
+// Kept out of server.errorCode.test.ts so that suite keeps exactly one typed
+// error class in scope: two same-shaped classes there defeat the dead-code
+// analyzer's member resolution and it reports the sibling's fields as unused.
+describe("extractSafeRenderErrorMetadata — non-media payloads", () => {
+  it("transports the code, owner, and retry policy", () => {
+    // Without the SAFE_RENDER_ERROR_CODES entry the API emits
+    // `errorCode: undefined` and the failure is indistinguishable from an
+    // untyped crash — as unroutable as the `moov atom not found` it replaces.
+    expect(extractSafeRenderErrorMetadata(new NotMediaPayloadError(["0123456789abcdef"]))).toEqual({
+      errorCode: "NOT_MEDIA_PAYLOAD",
+      errorOwner: "user",
+      retryable: false,
+    });
+  });
+});
diff --git a/packages/producer/src/server.ts b/packages/producer/src/server.ts
index e840da909f..268b3aa2a2 100644
--- a/packages/producer/src/server.ts
+++ b/packages/producer/src/server.ts
@@ -121,6 +121,7 @@ interface PreparedRenderInput {
 const DEFAULT_SERVER_FPS = { num: 30, den: 1 } as const;
 const SAFE_RENDER_ERROR_CODES = new Set<string>([
   "ASSET_MEDIA_TYPE_MISMATCH",
+  "NOT_MEDIA_PAYLOAD",
   "INVALID_VIDEO_METADATA",
   "VIDEO_SOURCE_UNRENDERABLE",
   "VIDEO_EXTRACTION_FAILED",
diff --git a/packages/producer/src/services/assetMediaType.test.ts b/packages/producer/src/services/assetMediaType.test.ts
index 6cd1a33510..8986762ff8 100644
--- a/packages/producer/src/services/assetMediaType.test.ts
+++ b/packages/producer/src/services/assetMediaType.test.ts
@@ -2,6 +2,7 @@ import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { copyFileSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { NOT_MEDIA_PAYLOAD, NotMediaPayloadError } from "@hyperframes/engine";
 import {
   ASSET_MEDIA_TYPE_MISMATCH,
   AssetMediaTypeMismatchError,
@@ -191,6 +192,64 @@ describe("preflightCompositionAssetMediaTypes", () => {
     await expect(run({ imageSrc: "corrupt-media" })).resolves.toBeUndefined();
   });
 
+  // STUDIO-5433. This preflight sees every local media src regardless of its
+  // authored timing, so it is the only place a document payload behind a
+  // `data-end` video or a `loop`ing audio is caught before frames are captured
+  // — for those elements the compiler never resolves a duration, so its own
+  // sniff never runs.
+  describe("non-media payloads", () => {
+    beforeAll(() => {
+      writeFileSync(
+        join(projectDir, "streamed-preview.html"),
+        "<!DOCTYPE html><html><body>not media</body></html>",
+      );
+      writeFileSync(
+        join(projectDir, "brand-mark.svg"),
+        '<svg xmlns="http://www.w3.org/2000/svg" width="8" height="8"><rect width="8" height="8"/></svg>',
+      );
+    });
+
+    it("rejects an HTML payload under a video element", async () => {
+      let caught: unknown;
+      try {
+        await run({ videoSrc: "streamed-preview.html" });
+      } catch (error) {
+        caught = error;
+      }
+      expect(caught).toBeInstanceOf(NotMediaPayloadError);
+      expect(caught).toMatchObject({
+        code: NOT_MEDIA_PAYLOAD,
+        owner: "user",
+        retryable: false,
+      });
+      const message = (caught as Error).message;
+      expect(message).not.toContain("streamed-preview.html");
+      expect(message).not.toContain(fixtureDir);
+    });
+
+    it("reports the document verdict ahead of the type mismatch the same file also produces", async () => {
+      // An HTML page under a <video> is both "not media" and "not video". The
+      // document verdict is the actionable one; the mismatch is a symptom of it.
+      await expect(run({ videoSrc: "streamed-preview.html" })).rejects.toBeInstanceOf(
+        NotMediaPayloadError,
+      );
+    });
+
+    it("leaves an audio source to the mixer's per-element classification", async () => {
+      // A bad audio source is non-fatal by existing policy: the render ships
+      // without the track and reports `audioError`. Aborting the whole compile
+      // here would turn renders that used to succeed into hard failures, so
+      // audioMixer classifies it as source/invalid_media/owner:user instead.
+      await expect(run({ audioSrc: "streamed-preview.html" })).resolves.toBeUndefined();
+    });
+
+    it("leaves an SVG image source alone", async () => {
+      // ffprobe reads SVG through its svg_pipe demuxer, so an XML body is a
+      // legitimate <img> payload and must not be swept up by the sniff.
+      await expect(run({ imageSrc: "brand-mark.svg" })).resolves.toBeUndefined();
+    });
+  });
+
   it("re-probes a path after its media contents are replaced", async () => {
     const mutablePath = join(projectDir, "mutable-media");
     const signal = new AbortController().signal;
diff --git a/packages/producer/src/services/assetMediaType.ts b/packages/producer/src/services/assetMediaType.ts
index cc410261a8..cc4f993722 100644
--- a/packages/producer/src/services/assetMediaType.ts
+++ b/packages/producer/src/services/assetMediaType.ts
@@ -1,6 +1,8 @@
-import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import {
+  fingerprintElementId,
+  isNotMediaPayload,
+  NotMediaPayloadError,
   probeMediaProfile,
   resolveProjectRelativeSrc,
   type AudioElement,
@@ -39,10 +41,6 @@ export class AssetMediaTypeMismatchError extends Error {
   }
 }
 
-function fingerprintElementId(elementId: string): string {
-  return createHash("sha256").update(elementId).digest("hex").slice(0, 16);
-}
-
 function detectedAssetMediaType(profile: MediaProbeProfile): DetectedAssetMediaType {
   if (profile.visualKind === "moving") return "video";
   if (profile.visualKind === "still") return "image";
@@ -133,10 +131,29 @@ export async function preflightCompositionAssetMediaTypes(input: {
   }
 
   const mismatches: AssetMediaTypeMismatch[] = [];
+  const notMediaFingerprints: string[] = [];
   const entries = [...byPath];
   await Promise.all(
     entries.map(([resolvedPath, pathReferences]) =>
       withMediaProbeSlot(async () => {
+        // STUDIO-5433. This preflight is the only place every local media src is
+        // seen regardless of its authored timing, so it is where a document
+        // payload behind a `data-end` video gets caught — the compiler's own
+        // sniff only runs for elements whose duration it has to resolve.
+        //
+        // Video only, deliberately. An `<img>` may legitimately be an SVG,
+        // which ffprobe reads through its `svg_pipe` demuxer. And a bad audio
+        // source is non-fatal by existing policy (audioStage ships the render
+        // without the track and reports `audioError`), so it is classified
+        // per-element in audioMixer instead of aborted here.
+        const sniffableReferences = pathReferences.filter((ref) => ref.expected === "video");
+        if (sniffableReferences.length > 0 && (await isNotMediaPayload(resolvedPath))) {
+          notMediaFingerprints.push(
+            ...sniffableReferences.map((ref) => fingerprintElementId(ref.id)),
+          );
+          return;
+        }
+
         let profile: MediaProbeProfile;
         try {
           profile = await probeMediaProfile(resolvedPath, { signal: input.signal });
@@ -156,5 +173,8 @@ export async function preflightCompositionAssetMediaTypes(input: {
     ),
   );
 
+  // Thrown ahead of the mismatch aggregate: "this file is an HTML page" is the
+  // actionable diagnosis, while the type mismatch it also produces is a symptom.
+  if (notMediaFingerprints.length > 0) throw new NotMediaPayloadError(notMediaFingerprints);
   if (mismatches.length > 0) throw new AssetMediaTypeMismatchError(mismatches);
 }
diff --git a/packages/producer/src/services/htmlCompiler.test.ts b/packages/producer/src/services/htmlCompiler.test.ts
index a69be7e02b..c555db1f9c 100644
--- a/packages/producer/src/services/htmlCompiler.test.ts
+++ b/packages/producer/src/services/htmlCompiler.test.ts
@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { parseHTML } from "linkedom";
 import { interpolateVolumeGain } from "@hyperframes/core/media-volume-envelope";
 import { defaultLogger } from "../logger.js";
+import { NotMediaPayloadError } from "@hyperframes/engine";
 import {
   collectExternalAssets,
   compileForRender,
@@ -2267,3 +2268,94 @@ describe("sub-composition variable injection (render path, #2064)", () => {
     expect(compiled.html).not.toMatch(/window\.__hfVariablesByComp\s*=\s*Object\.assign/);
   });
 });
+
+// ── Markup payload sniff (STUDIO-5433) ─────────────────────────────────────
+//
+// Producer's `resolveMediaDuration` is a two-step pipeline (download → probe)
+// that runs on every media element without an authored duration. Before this
+// defense, an authoring bug that handed a `.html` payload through as a video
+// src produced an opaque `[mov,mp4,m4a,3gp,3g2,mj2 @ ...] moov atom not found`
+// from ffprobe — the `mov,mp4,…` prefix is ffprobe's demuxer probe order, NOT
+// the file's true format, so every alert routed as a codec/ffmpeg bug. The
+// byte-level sniff itself is unit-tested in
+// `engine/src/utils/notMediaPayload.test.ts`; what is pinned here is the
+// compiler's handling of the verdict, which differs by element type.
+
+describe("compileForRender non-media payload sniff (STUDIO-5433)", () => {
+  function writeProject(mediaTag: string): string {
+    const projectDir = mkdtempSync(join(tmpdir(), "hf-payload-sniff-e2e-"));
+    mkdirSync(join(projectDir, "assets"));
+    writeFileSync(
+      join(projectDir, "assets", "nested.html"),
+      "<!DOCTYPE html>\n<html><head><title>streamed-preview</title></head><body></body></html>",
+    );
+    writeFileSync(
+      join(projectDir, "index.html"),
+      `<!DOCTYPE html>
+<html>
+  <body>
+    <div data-composition-id="root" data-width="640" data-height="360" data-start="0" data-duration="4">
+      ${mediaTag}
+    </div>
+    <script>
+      window.__timelines = window.__timelines || {};
+      window.__timelines["root"] = { duration: () => 4 };
+    </script>
+  </body>
+</html>`,
+    );
+    return projectDir;
+  }
+
+  it("aborts with NotMediaPayloadError before ffprobe when a <video> src is an HTML payload", async () => {
+    // Mimics STUDIO-5433: an a-roll element whose src points at a legitimate
+    // 6.5 KB `<!DOCTYPE html>` preview page instead of the rendered MP4.
+    const projectDir = writeProject(
+      '<video id="v1" src="assets/nested.html" data-start="0" muted></video>',
+    );
+
+    let caught: unknown;
+    try {
+      await compileForRender(projectDir, join(projectDir, "index.html"), projectDir);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(NotMediaPayloadError);
+    const err = caught as NotMediaPayloadError;
+    // Routing metadata, not just a readable string: these are what the server's
+    // SAFE_RENDER_ERROR_CODES allowlist and the distributed retry sets key off.
+    expect(err.code).toBe("NOT_MEDIA_PAYLOAD");
+    expect(err.owner).toBe("user");
+    expect(err.retryable).toBe(false);
+    // Correlation is the hashed element id — the authored src never reaches a
+    // message that producer forwards to API clients.
+    expect(err.elementFingerprints).toHaveLength(1);
+    expect(err.message).not.toContain("assets/nested.html");
+    // Also the ordering pin: this fixture is an input ffprobe rejects, so if
+    // the sniff ran after the probe the rejection would be ffprobe's untyped
+    // error and this assertion would fail.
+  });
+
+  it("drops an <audio> document payload to duration 0 and warns instead of failing the render", async () => {
+    // The audio/video split is the compiler's contract: an unprobeable audio
+    // src is excluded from the render, and only video surfaces its probe
+    // failure. A hard abort here would take down renders that used to succeed
+    // without the offending audio.
+    const projectDir = writeProject(
+      '<audio id="a1" src="assets/nested.html" data-start="0"></audio>',
+    );
+    const warnings: string[] = [];
+    const log = { ...defaultLogger, warn: (message: string) => warnings.push(message) };
+
+    const compiled = await compileForRender(
+      projectDir,
+      join(projectDir, "index.html"),
+      projectDir,
+      { log },
+    );
+
+    expect(compiled.html).not.toContain('id="a1" src="assets/nested.html" data-end');
+    expect(warnings.join("\n")).toContain("text document");
+    expect(warnings.join("\n")).toContain("a1");
+  });
+});
diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.ts
index f9c4e86a32..e4631fd0fc 100644
--- a/packages/producer/src/services/htmlCompiler.ts
+++ b/packages/producer/src/services/htmlCompiler.ts
@@ -51,6 +51,8 @@ import {
   type AudioVolumeKeyframe,
   type MediaProbeProfile,
   analyzeKeyframeIntervals,
+  assertMediaPayload,
+  NotMediaPayloadError,
   probeMediaProfile,
 } from "@hyperframes/engine";
 import { assertPublicHttpsUrl, downloadToTemp, isHttpUrl } from "../utils/urlDownloader.js";
@@ -413,6 +415,7 @@ async function resolveMediaDuration(
   downloadDir: string,
   tagName: string,
   elementIdentity: string,
+  log?: ProducerLogger,
 ): Promise<{ duration: number; resolvedPath: string }> {
   let filePath = src;
 
@@ -436,12 +439,30 @@ async function resolveMediaDuration(
   return withMediaProbeSlot(async () => {
     let profile: MediaProbeProfile;
     try {
+      // Payload sniff (STUDIO-5433): if an authoring bug hands us a text
+      // payload (e.g. an unresolved nested-composition preview URL), fail with
+      // a typed NotMediaPayloadError instead of letting ffprobe emit an opaque
+      // `[mov,mp4,...] moov atom not found` that routes as a codec bug.
+      // Deliberately inside this try: the audio/video split below is the
+      // contract, so a bad audio src must still degrade to duration 0 rather
+      // than take down the whole render.
+      await assertMediaPayload(filePath, elementIdentity);
       profile = await probeMediaProfile(filePath);
     } catch (error) {
       // Preserve the historical split: invalid video sources surface their
       // probe failure, while invalid/unreadable audio sources resolve to zero
       // duration and are excluded by the compiler.
-      if (tagName !== "video") return { duration: 0, resolvedPath: filePath };
+      if (tagName !== "video") {
+        if (error instanceof NotMediaPayloadError) {
+          // Dropping it silently is what let STUDIO-5433 resurface downstream
+          // as `prepare/ffmpeg_failed` with owner "system".
+          log?.warn(
+            `[compile] Audio "${elementIdentity}" (${src}) is a text document, not a media ` +
+              "file — the element is dropped from the render. Point it at a rendered media file.",
+          );
+        }
+        return { duration: 0, resolvedPath: filePath };
+      }
       throw error;
     }
     assertAssetMediaTypeProfile(tagName === "video" ? "video" : "audio", profile, elementIdentity);
@@ -489,9 +510,15 @@ async function compileHtmlFile(
   // Phase 1: Resolve missing durations (parallel ffprobe)
   const resolvedResults = await Promise.all(
     mediaUnresolved.map((el) =>
-      resolveMediaDuration(el.src!, el.mediaStart, baseDir, downloadDir, el.tagName, el.id).then(
-        ({ duration }) => ({ id: el.id, duration }),
-      ),
+      resolveMediaDuration(
+        el.src!,
+        el.mediaStart,
+        baseDir,
+        downloadDir,
+        el.tagName,
+        el.id,
+        log,
+      ).then(({ duration }) => ({ id: el.id, duration })),
     ),
   );
   const resolutions: ResolvedDuration[] = resolvedResults.filter((r) => r.duration > 0);
@@ -513,6 +540,7 @@ async function compileHtmlFile(
           downloadDir,
           el.tagName,
           el.id,
+          log,
         );
         return { id: el.id, tagName: el.tagName, duration: el.duration, maxDuration, src: el.src! };
       }),