diff --git a/backend/src/handlers/admin.rs b/backend/src/handlers/admin.rs
index d001c4d..3233268 100644
--- a/backend/src/handlers/admin.rs
+++ b/backend/src/handlers/admin.rs
@@ -197,6 +197,23 @@ pub async fn patch_config(
                     "Wert für {key} liegt außerhalb des zulässigen Bereichs ({min}–{max})."
                 )));
             }
+            // Zero is in range and catastrophic. `quota_tolerance` is the multiplier in
+            // `free_disk * tolerance / active_uploaders`, so 0 makes every per-user limit 0 and
+            // refuses EVERY upload — mid-event, with "Du hast dein Upload-Limit für dieses Event
+            // erreicht", an error naming the wrong cause entirely. `storage_quota_enabled` is the
+            // intended off-switch.
+            //
+            // Rejecting the value rather than raising the floor: very small tolerances are
+            // legitimate (they are how a large disk is throttled down to a sensible per-guest
+            // ceiling, and how the e2e quota tests steer it — around 1e-5 on a 174 GB volume), so
+            // a floor of, say, 0.01 would forbid real configurations to prevent one typo.
+            if key_str == "quota_tolerance" && n == 0.0 {
+                return Err(AppError::BadRequest(
+                    "quota_tolerance = 0 würde jeden Upload blockieren. Zum Abschalten der \
+                     Speicher-Quote stattdessen „Speicher-Quote aktiv“ ausschalten."
+                        .into(),
+                ));
+            }
         } else if BOOL_KEYS.contains(&key_str) {
             match value.trim().to_ascii_lowercase().as_str() {
                 "true" | "false" | "1" | "0" | "yes" | "no" | "on" | "off" => {}
diff --git a/backend/src/services/export.rs b/backend/src/services/export.rs
index f754c80..d23423b 100644
--- a/backend/src/services/export.rs
+++ b/backend/src/services/export.rs
@@ -580,7 +580,7 @@ async fn run_zip_export_inner(
             };
             let entry_name = format!("{folder}/{date}_{name_safe}_{}.{ext}", row.id);
 
-            let builder = ZipEntryBuilder::new(entry_name.into(), Compression::Stored);
+            let builder = keepsake_entry(entry_name, Compression::Stored);
 
             // Open BEFORE writing the entry header. A missing source is skipped (the media file
             // was deleted, or its processing failed) — but it must be skipped without aborting the
@@ -973,7 +973,7 @@ async fn run_html_export_inner(
 
         // Write data.json
         {
-            let builder = ZipEntryBuilder::new("data.json".into(), Compression::Deflate);
+            let builder = keepsake_entry("data.json".into(), Compression::Deflate);
             let mut entry = zip.write_entry_stream(builder).await?;
             let mut cursor = AllowStdIo::new(std::io::Cursor::new(data_json.as_bytes()));
             fcopy(&mut cursor, &mut entry).await?;
@@ -982,7 +982,7 @@ async fn run_html_export_inner(
 
         // Write README.txt
         {
-            let builder = ZipEntryBuilder::new("README.txt".into(), Compression::Deflate);
+            let builder = keepsake_entry("README.txt".into(), Compression::Deflate);
             let mut entry = zip.write_entry_stream(builder).await?;
             let mut cursor = AllowStdIo::new(std::io::Cursor::new(README_TEXT.as_bytes()));
             fcopy(&mut cursor, &mut entry).await?;
@@ -1015,7 +1015,7 @@ async fn run_html_export_inner(
             };
 
             let entry_name = format!("media/{name}");
-            let builder = ZipEntryBuilder::new(entry_name.into(), Compression::Stored);
+            let builder = keepsake_entry(entry_name, Compression::Stored);
             let mut zip_entry = zip.write_entry_stream(builder).await?;
             let mut f = src_file.compat();
             fcopy(&mut f, &mut zip_entry).await?;
@@ -1552,6 +1552,36 @@ async fn maybe_broadcast_complete(
 /// double-clicking `index.html` (file://), where browsers block a cross-origin
 /// `fetch()` of a sibling `data.json` — so the data is inlined into the page.
 /// (`data.json` is still written separately for the http-served case.)
+/// Permissions stamped on every entry in both archives: `rw-r--r--`.
+///
+/// `ZipEntryBuilder::new` leaves the external file attribute at zero, and the host compatibility
+/// defaults to Unix — so every entry was written with a stored mode of **0000**. Windows Explorer
+/// ignores Unix modes and was fine, which is exactly why this survived: on Linux and macOS
+/// `unzip` faithfully applies what the archive asks for, and the guest gets a directory of files
+/// none of which they can open. `?---------` on every line of `unzip -Z`.
+///
+/// That is the keepsake — the artifact the whole event exists to produce — arriving unreadable,
+/// after distribution, with no server-side symptom at all.
+/// `S_IFREG | 0644`. The type bits are included because the mode is written whole into the high
+/// half of the external file attribute: without them extractors see a file of type "unknown"
+/// (`unzip -Z` renders `?rw-r--r--`), which works but is not what the archive means to say.
+const KEEPSAKE_ENTRY_MODE: u16 = 0o100_644;
+
+/// Build a ZIP entry for the keepsake. ALL entries in both archives go through here so the mode
+/// can't be forgotten at one of the six call sites.
+fn keepsake_entry(name: String, compression: Compression) -> ZipEntryBuilder {
+    ZipEntryBuilder::new(name.into(), compression).unix_permissions(KEEPSAKE_ENTRY_MODE)
+}
+
+/// Escape a JSON payload for inlining inside a `<script>` element.
+///
+/// See the call site in [`write_viewer_with_data`] for why this is every `<` and not just `</`.
+/// Kept separate so the property that matters — no `<` survives, and the value still decodes to
+/// the original — can be asserted without building a ZIP.
+fn escape_json_for_script(data_json: &str) -> String {
+    data_json.replace('<', "\\u003c")
+}
+
 async fn write_viewer_with_data(
     dir: &include_dir::Dir<'_>,
     zip: &mut ZipFileWriter<tokio::fs::File>,
@@ -1563,8 +1593,31 @@ async fn write_viewer_with_data(
         if path == "index.html" {
             let html = std::str::from_utf8(file.contents())
                 .context("export-viewer index.html is not valid UTF-8")?;
-            // Escape `</` so a caption containing `</script>` can't break out of the tag.
-            let safe = data_json.replace("</", "<\\/");
+            // Escape EVERY `<`, not just `</`.
+            //
+            // `</` -> `<\/` stops the obvious break-out (`</script><img onerror=…>`) and is inert
+            // against XSS. It does not stop the caption steering the HTML TOKENIZER. A caption
+            // containing `<!--<script` with no later `-->` puts the parser into
+            // script-data-double-escaped state; from there the template's own `</script>` only
+            // steps back to script-data-escaped instead of closing the element, and the rest of the
+            // document — including the viewer bundle — is swallowed as script data. Nothing
+            // executes and nothing leaks; `window.__EXPORT_DATA__` is simply never assigned and the
+            // keepsake opens blank.
+            //
+            // That failure is silent and POST-DISTRIBUTION: the export succeeds, the ZIP is
+            // well-formed, the job writes `done`, /export/status is green, and the host hands out a
+            // file that only fails when a guest double-clicks index.html — in every copy, with no
+            // way to fix it after the fact. Reachable from any guest-authored caption or comment,
+            // since both are embedded in the viewer.
+            //
+            // `<` never appears in JSON structural syntax — only inside string values — so a global
+            // replace is sound, and `<` is valid in both JSON and a JS string literal. One
+            // rule covers `</script`, `<!--` and `<script` together, which is the point: the
+            // previous escape was named for the single case it did handle.
+            //
+            // NOTE this is deliberately only for the INLINED copy. `data.json` is written
+            // separately, in no HTML context, and must stay literal.
+            let safe = escape_json_for_script(data_json);
             // Match the live app's colour theme: inject the same `:root:root{…}` override
             // the app builds at runtime so a rose/sage/custom event exports a rose/sage
             // keepsake (not the embedded default gold). The CSS is generated purely from
@@ -1578,13 +1631,13 @@ async fn write_viewer_with_data(
                 Some(idx) => format!("{}{}{}", &html[..idx], head_inject, &html[idx..]),
                 None => format!("{head_inject}{html}"),
             };
-            let builder = ZipEntryBuilder::new(path.into(), Compression::Deflate);
+            let builder = keepsake_entry(path, Compression::Deflate);
             let mut entry = zip.write_entry_stream(builder).await?;
             let mut cursor = AllowStdIo::new(std::io::Cursor::new(injected.as_bytes()));
             fcopy(&mut cursor, &mut entry).await?;
             entry.close().await?;
         } else {
-            let builder = ZipEntryBuilder::new(path.into(), Compression::Deflate);
+            let builder = keepsake_entry(path, Compression::Deflate);
             let mut entry = zip.write_entry_stream(builder).await?;
             let mut cursor = AllowStdIo::new(std::io::Cursor::new(file.contents()));
             fcopy(&mut cursor, &mut entry).await?;
@@ -1815,6 +1868,62 @@ mod tests {
         }
     }
 
+    /// Every `<` is escaped, whatever it is part of.
+    ///
+    /// PREVENTS the regression to `</` -> `<\\/`, which is named for the one case it handles.
+    /// `<!--<script` with no later `-->` drives the HTML tokenizer into
+    /// script-data-double-escaped state, where the template's own `</script>` no longer closes
+    /// the element — the viewer bundle is swallowed as script data, `__EXPORT_DATA__` is never
+    /// assigned, and the keepsake opens blank in every copy the host has already handed out.
+    #[test]
+    fn no_left_angle_bracket_survives_inlining() {
+        for payload in [
+            r#"{"caption":"<!--<script"}"#,
+            r#"{"caption":"</script><img src=x onerror=alert(1)>"}"#,
+            r#"{"caption":"<!--"}"#,
+            r#"{"caption":"<script>"}"#,
+            r#"{"caption":"a < b"}"#,
+        ] {
+            let escaped = escape_json_for_script(payload);
+            assert!(
+                !escaped.contains('<'),
+                "a surviving `<` can still steer the tokenizer: {escaped}"
+            );
+        }
+    }
+
+    /// The escape must not change what the viewer READS — it is a transport encoding, not a
+    /// sanitiser. A caption is guest-authored text that has to render back exactly.
+    #[test]
+    fn the_payload_still_decodes_to_the_original_value() {
+        // `<` appears only inside JSON string values, never in structural syntax, so a global
+        // replace is sound — this is the assertion that says so.
+        for caption in [
+            "<!--<script",
+            "</script><img src=x onerror=alert(1)>",
+            "a < b und c > d",
+            "ganz normale Bildunterschrift",
+            "Herz <3",
+        ] {
+            let json = serde_json::json!({ "posts": [{ "caption": caption }] }).to_string();
+            let escaped = escape_json_for_script(&json);
+            let back: serde_json::Value =
+                serde_json::from_str(&escaped).expect("the escaped form must still be valid JSON");
+            assert_eq!(
+                back["posts"][0]["caption"].as_str(),
+                Some(caption),
+                "the caption must survive the round trip unchanged"
+            );
+        }
+    }
+
+    /// Nothing else in the document is touched.
+    #[test]
+    fn a_payload_with_no_angle_brackets_is_unchanged() {
+        let json = r#"{"posts":[{"caption":"schönes Foto"}]}"#;
+        assert_eq!(escape_json_for_script(json), json);
+    }
+
     #[test]
     fn a_lone_armed_job_reserves_for_one_archive() {
         // A ViewerOnly regeneration re-arms only the HTML half — reserving for two would refuse
diff --git a/e2e/specs/05-admin/config.spec.ts b/e2e/specs/05-admin/config.spec.ts
index 4119c7e..dca1005 100644
--- a/e2e/specs/05-admin/config.spec.ts
+++ b/e2e/specs/05-admin/config.spec.ts
@@ -68,6 +68,40 @@ test.describe('Admin — config API', () => {
     expect(cfg.privacy_note).toBe(note);
     await api.patchConfig(adminToken, { privacy_note: '' });
   });
+  test('quota_tolerance = 0 is rejected, with a pointer to the real off-switch', async ({
+    api,
+    adminToken,
+  }) => {
+    // Zero is inside the documented 0–1 range and catastrophic: the per-user limit is
+    // `free_disk * tolerance / active_uploaders`, so 0 refuses EVERY upload — mid-event, with
+    // "Du hast dein Upload-Limit für dieses Event erreicht", which names the wrong cause
+    // entirely. `storage_quota_enabled` is what an admin reaching for an off-switch wants.
+    const res = await fetch(
+      (process.env.E2E_FRONTEND_URL ?? 'http://localhost:3101') + '/api/v1/admin/config',
+      {
+        method: 'PATCH',
+        headers: { Authorization: `Bearer ${adminToken}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ quota_tolerance: '0' }),
+      }
+    );
+    expect(res.status).toBe(400);
+    expect(
+      (await res.text()).toLowerCase(),
+      'the error must name the switch the admin actually wanted'
+    ).toContain('speicher-quote');
+
+    // The value is untouched — validation fully precedes any write.
+    expect((await api.getConfig(adminToken)).quota_tolerance).toBe('0.75');
+  });
+
+  test('a very small quota_tolerance is still accepted', async ({ api, adminToken }) => {
+    // The mirror. Rejecting 0 must not become a floor: small tolerances are how a large disk is
+    // throttled to a sensible per-guest ceiling, and how the quota specs steer it (~1e-5 on a
+    // 174 GB volume). A floor of 0.01 would forbid real configurations to prevent one typo.
+    await api.patchConfig(adminToken, { quota_tolerance: '0.00001' });
+    expect((await api.getConfig(adminToken)).quota_tolerance).toBe('0.00001');
+    await api.patchConfig(adminToken, { quota_tolerance: '0.75' });
+  });
 });
 
 test.describe('Admin — stats', () => {
diff --git a/e2e/specs/06-export/archive-permissions.spec.ts b/e2e/specs/06-export/archive-permissions.spec.ts
new file mode 100644
index 0000000..557b1c0
--- /dev/null
+++ b/e2e/specs/06-export/archive-permissions.spec.ts
@@ -0,0 +1,103 @@
+/**
+ * Regression guard — the keepsake extracts to files a guest can actually open.
+ *
+ * `ZipEntryBuilder::new` leaves the external file attribute at zero, and async_zip's host
+ * compatibility defaults to Unix — so every entry in BOTH archives was written with a stored mode
+ * of 0000. `unzip -Z` showed `?---------` on every line.
+ *
+ * Windows Explorer ignores Unix modes, which is exactly why this survived. On Linux and macOS,
+ * `unzip` faithfully applies what the archive asks for, and the guest gets a folder of photos none
+ * of which they can open — plus an index.html the browser refuses with ERR_ACCESS_DENIED.
+ *
+ * Unconditional: it affected every keepsake ever produced, no hostile input required. And it is
+ * invisible server-side — the export succeeds, the ZIP is well-formed, the job writes `done`,
+ * /export/status is green. The only way to see it is to extract the real artifact and try to read
+ * it, which is what this does.
+ *
+ * Found while chasing an unrelated ERR_ACCESS_DENIED that looked like a Playwright quirk.
+ */
+import { test, expect } from '../../fixtures/test';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync, readFileSync, statSync, readdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { seedUpload } from '../../helpers/seed';
+import { BASE } from '../../helpers/env';
+
+/** Walk every file under `dir`, ignoring the archives we dropped there ourselves. */
+function walk(dir: string, skip: string[] = []): string[] {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) return walk(p, skip);
+    return skip.includes(e.name) ? [] : [p];
+  });
+}
+
+test.describe('Export — the archives extract to readable files', () => {
+  test('every entry in both keepsake archives is owner-readable', async ({ host, guest, db }) => {
+    test.setTimeout(120_000);
+    const bearer = { Authorization: `Bearer ${host.jwt}` };
+
+    const g = await guest('Archivist');
+    const id = await seedUpload(g.jwt, { caption: 'ein Foto' });
+    await expect.poll(() => db.compressionStatus(id), { timeout: 30_000 }).toBe('done');
+
+    expect(
+      (await fetch(`${BASE}/api/v1/host/gallery/release`, { method: 'POST', headers: bearer }))
+        .status
+    ).toBe(204);
+
+    await expect
+      .poll(
+        async () => {
+          const res = await fetch(`${BASE}/api/v1/export/status`, { headers: bearer });
+          const s = await res.json();
+          return s.zip?.status === 'done' && s.html?.status === 'done';
+        },
+        { timeout: 90_000, intervals: [500] }
+      )
+      .toBe(true);
+
+    for (const kind of ['zip', 'html'] as const) {
+      const ticketRes = await fetch(`${BASE}/api/v1/export/ticket`, {
+        method: 'POST',
+        headers: bearer,
+      });
+      const { ticket } = (await ticketRes.json()) as { ticket: string };
+      const dl = await fetch(`${BASE}/api/v1/export/${kind}?ticket=${encodeURIComponent(ticket)}`);
+      expect(dl.status, `downloading the ${kind} archive`).toBe(200);
+
+      const dir = mkdtempSync(join(tmpdir(), `eventsnap-perms-${kind}-`));
+      try {
+        const zipPath = join(dir, 'archive.zip');
+        writeFileSync(zipPath, Buffer.from(await dl.arrayBuffer()));
+
+        // The mode as STORED in the archive — this is what a guest's unzip will apply. Reading it
+        // from the central directory catches the defect even on a filesystem that would mask it.
+        const listing = execFileSync('unzip', ['-Z', zipPath], { encoding: 'utf8' });
+        const modes = listing
+          .split('\n')
+          .filter((l) => /^[?d-][rwx-]{9}\s/.test(l))
+          .map((l) => l.slice(0, 10));
+        expect(modes.length, `${kind}: no entries listed`).toBeGreaterThan(0);
+        for (const m of modes) {
+          expect(m, `${kind}: an entry is stored mode ${m} — the guest cannot open it`).toMatch(
+            /^.r[w-]-/
+          );
+        }
+
+        // And extraction really does produce readable files.
+        execFileSync('unzip', ['-qo', zipPath, '-d', dir]);
+        const files = walk(dir, ['archive.zip']);
+        expect(files.length, `${kind}: nothing extracted`).toBeGreaterThan(0);
+        for (const f of files) {
+          expect(statSync(f).mode & 0o400, `${f} is not owner-readable`).toBeTruthy();
+          // The assertion that matters to a guest: the bytes actually come out.
+          expect(() => readFileSync(f)).not.toThrow();
+        }
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  });
+});
diff --git a/e2e/specs/06-export/viewer-caption-injection.spec.ts b/e2e/specs/06-export/viewer-caption-injection.spec.ts
new file mode 100644
index 0000000..9beabb7
--- /dev/null
+++ b/e2e/specs/06-export/viewer-caption-injection.spec.ts
@@ -0,0 +1,125 @@
+/**
+ * Regression guard — a guest-authored caption cannot brick the offline keepsake.
+ *
+ * The viewer's data is inlined as `<script>window.__EXPORT_DATA__={…};</script>` (it must be:
+ * guests open index.html over file://, where a cross-origin fetch of a sibling data.json is
+ * blocked). Captions and comments are guest text and land in that payload.
+ *
+ * The escape used to be `</` → `<\/`. Against XSS that holds — `</script><img src=x onerror=…>`
+ * round-trips inert. It does NOT stop the caption steering the HTML TOKENIZER: `<!--<script` with
+ * no later `-->` drives the parser into script-data-double-escaped state, where the template's own
+ * `</script>` steps back to script-data-escaped instead of closing the element. Everything after —
+ * including the viewer bundle — is swallowed as script data. Nothing executes and nothing leaks;
+ * `__EXPORT_DATA__` is never assigned and the keepsake renders blank.
+ *
+ * What makes it worth a browser-level test rather than a unit test alone: the failure is SILENT and
+ * POST-DISTRIBUTION. The export succeeds, the ZIP is well-formed, the job writes `done`,
+ * /export/status is green, and the host hands out a file that only fails when a guest
+ * double-clicks it — in every copy, unfixably. It is not visible by reading the escape. It is only
+ * visible by running a real parser over the real artifact, which is what this does: release, pull
+ * the actual Memories.zip, extract index.html, open it over file:// in Chromium, and assert the
+ * viewer actually booted.
+ *
+ * The near-miss worth recording: `<!--<script>alert(1)</script>-->` comes back CLEAN, because the
+ * trailing `-->` returns the parser to script-data state. A probe using the terminated form
+ * quietly repairs the very thing it is testing for. Only the unterminated variant exposes it.
+ */
+import { test, expect } from '../../fixtures/test';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { seedUpload } from '../../helpers/seed';
+import { BASE } from '../../helpers/env';
+
+/** Unterminated on purpose — see the header. The terminated form self-repairs. */
+const TOKENIZER_PAYLOAD = '<!--<script';
+/** The classic break-out. Already handled, kept so the fix can never regress on it. */
+const BREAKOUT_PAYLOAD = '</script><img src=x onerror=window.__XSS__=1>';
+
+test.describe('Export — a caption cannot brick the keepsake viewer', () => {
+  test('the exported viewer boots with a tokenizer-hostile caption in it', async ({
+    page,
+    host,
+    guest,
+    db,
+  }) => {
+    test.setTimeout(120_000);
+    const bearer = { Authorization: `Bearer ${host.jwt}` };
+
+    const g = await guest('Trickster');
+    const a = await seedUpload(g.jwt, { caption: TOKENIZER_PAYLOAD });
+    const b = await seedUpload(g.jwt, { caption: BREAKOUT_PAYLOAD });
+    for (const id of [a, b]) {
+      await expect.poll(() => db.compressionStatus(id), { timeout: 30_000 }).toBe('done');
+    }
+
+    expect(
+      (await fetch(`${BASE}/api/v1/host/gallery/release`, { method: 'POST', headers: bearer }))
+        .status
+    ).toBe(204);
+
+    await expect
+      .poll(
+        async () => {
+          const res = await fetch(`${BASE}/api/v1/export/status`, { headers: bearer });
+          return (await res.json()).html?.status;
+        },
+        { timeout: 90_000, intervals: [500] }
+      )
+      .toBe('done');
+
+    const ticketRes = await fetch(`${BASE}/api/v1/export/ticket`, {
+      method: 'POST',
+      headers: bearer,
+    });
+    const { ticket } = (await ticketRes.json()) as { ticket: string };
+    const dl = await fetch(`${BASE}/api/v1/export/html?ticket=${encodeURIComponent(ticket)}`);
+    expect(dl.status).toBe(200);
+
+    const dir = mkdtempSync(join(tmpdir(), 'eventsnap-viewer-'));
+    try {
+      const zipPath = join(dir, 'Memories.zip');
+      writeFileSync(zipPath, Buffer.from(await dl.arrayBuffer()));
+      // Extract the WHOLE archive: index.html pulls in the viewer's own JS/CSS, and the point of
+      // this test is that those later resources are still reachable by the parser.
+      execFileSync('unzip', ['-qo', zipPath, '-d', dir]);
+
+      // file://, not http://. That is how a guest actually opens the keepsake, and it is the
+      // whole reason the data is inlined rather than fetched from a sibling data.json.
+      let xss = false;
+      page.on('dialog', (d) => {
+        xss = true;
+        void d.dismiss();
+      });
+      await page.goto('file://' + join(dir, 'index.html'));
+
+      // 1. The payload was assigned at all. This is the assertion that fails on the old escape —
+      //    the second script block is never reached, so the global stays undefined.
+      const captions = await page.evaluate(() => {
+        const d = (window as unknown as { __EXPORT_DATA__?: { posts?: { caption?: string }[] } })
+          .__EXPORT_DATA__;
+        return d?.posts?.map((p) => p.caption ?? '') ?? null;
+      });
+      expect(captions, '__EXPORT_DATA__ was never assigned — the viewer is bricked').not.toBeNull();
+
+      // 2. The captions survived verbatim. The escape is a transport encoding, not a sanitiser:
+      //    a guest's text has to come back exactly, or we have silently rewritten their words.
+      expect(captions).toContain(TOKENIZER_PAYLOAD);
+      expect(captions).toContain(BREAKOUT_PAYLOAD);
+
+      // 3. And nothing executed.
+      expect(
+        await page.evaluate(() => (window as unknown as { __XSS__?: number }).__XSS__ === 1),
+        'the caption must be inert, not merely non-fatal'
+      ).toBe(false);
+      expect(xss).toBe(false);
+
+      // 4. The viewer actually rendered — the whole document parsed, not just the head. If the
+      //    tokenizer had swallowed the bundle, the body would be empty of viewer output.
+      await expect(page.locator('body')).not.toBeEmpty();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});