@1agh/maude 0.41.0 → 0.43.0

package/apps/studio/test/read-annotations.test.ts

@@ -18,9 +18,11 @@ import { fileURLToPath } from 'node:url';
 import {
   type ArrowStroke,
   type EllipseStroke,
+  type ImageStroke,
   type PenStroke,
   type PolygonStroke,
   type RectStroke,
+  type SectionStroke,
   type StickyStroke,
   type Stroke,
   strokesToSvg,
@@ -50,6 +52,18 @@ interface Annotation {
     text: string;
   } | null;
   target?: { source: string; selector: { type: string; value: string }; geometry: unknown };
+  href?: string;
+  authorName?: string;
+  members?: Array<{
+    id: string;
+    tool: string;
+    order: number;
+    x: number | null;
+    y: number | null;
+    w: number | null;
+    h: number | null;
+    href?: string;
+  }>;
 }
 
 // Mirror api.ts fileSlug for the common (design-root-relative .tsx) case so the
@@ -171,6 +185,20 @@ describe('read-annotations / sticky', () => {
     const { annotations } = read(REL, strokesToSvg([multi]));
     expect(annotations[0]?.text).toBe('line one\nline two');
   });
+
+  test('authorName containing `>` round-trips intact and does not corrupt sibling geometry (DDR-155/escAttr regression)', () => {
+    const authored: StickyStroke = { ...sticky, authorName: 'Bob> data-x="evil' };
+    const { annotations } = read(REL, strokesToSvg([authored]));
+    const [a] = annotations;
+    expect(a?.authorName).toBe('Bob> data-x="evil');
+    // The injected `>`/`"` must not have shifted the element scan and eaten
+    // the sibling geometry/text attributes.
+    expect(a?.x).toBe(40);
+    expect(a?.y).toBe(50);
+    expect(a?.w).toBe(200);
+    expect(a?.h).toBe(160);
+    expect(a?.text).toBe('Step 1: email + password');
+  });
 });
 
 describe('read-annotations / position-only strokes carry text:null + a bbox', () => {
@@ -561,3 +589,139 @@ describe('read-annotations / --rects element-level context', () => {
     expect(a && 'element' in a).toBe(false);
   });
 });
+
+describe('read-annotations / section membership + reading order', () => {
+  test('members are ordered spatially (top-to-bottom, left-to-right), not by z/paint order', () => {
+    // Drawn out of visual order: B (top-right) first, A (top-left) second,
+    // C (bottom-left) third — so z = [B, A, C] but reading order must be
+    // [A, B, C].
+    const section: SectionStroke = {
+      id: 'sec1',
+      tool: 'section',
+      x: 0,
+      y: 0,
+      w: 400,
+      h: 400,
+      label: 'Board',
+      color: '#8884',
+    };
+    const stickyB: StickyStroke = {
+      id: 'stickyB',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 200,
+      y: 20,
+      w: 120,
+      h: 120,
+      text: 'B',
+      fontSize: 14,
+    };
+    const stickyA: StickyStroke = {
+      id: 'stickyA',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 20,
+      y: 20,
+      w: 120,
+      h: 120,
+      text: 'A',
+      fontSize: 14,
+    };
+    const stickyC: StickyStroke = {
+      id: 'stickyC',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 20,
+      y: 220,
+      w: 120,
+      h: 120,
+      text: 'C',
+      fontSize: 14,
+    };
+    const { annotations } = read(REL, strokesToSvg([section, stickyB, stickyA, stickyC]));
+    const sec = annotations.find((a) => a.id === 'sec1');
+    expect(sec?.members?.map((m) => m.id)).toEqual(['stickyA', 'stickyB', 'stickyC']);
+    expect(sec?.members?.map((m) => m.order)).toEqual([0, 1, 2]);
+  });
+
+  test('image members carry their resolvable asset href', () => {
+    const section: SectionStroke = {
+      id: 'sec1',
+      tool: 'section',
+      x: 0,
+      y: 0,
+      w: 400,
+      h: 400,
+      label: 'Board',
+      color: '#8884',
+    };
+    const img: ImageStroke = {
+      id: 'img1',
+      tool: 'image',
+      x: 20,
+      y: 20,
+      w: 120,
+      h: 120,
+      href: 'assets/deadbeef.png',
+    };
+    const { annotations } = read(REL, strokesToSvg([section, img]));
+    const sec = annotations.find((a) => a.id === 'sec1');
+    expect(sec?.members).toEqual([
+      {
+        id: 'img1',
+        tool: 'image',
+        order: 0,
+        x: 20,
+        y: 20,
+        w: 120,
+        h: 120,
+        href: 'assets/deadbeef.png',
+      },
+    ]);
+  });
+
+  test('a stroke outside the section rect is not a member; a section with nothing inside gets an empty array', () => {
+    const section: SectionStroke = {
+      id: 'sec1',
+      tool: 'section',
+      x: 0,
+      y: 0,
+      w: 100,
+      h: 100,
+      label: 'Board',
+      color: '#8884',
+    };
+    const outside: StickyStroke = {
+      id: 'outside',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 500,
+      y: 500,
+      w: 60,
+      h: 60,
+      text: 'far away',
+      fontSize: 14,
+    };
+    const { annotations } = read(REL, strokesToSvg([section, outside]));
+    const sec = annotations.find((a) => a.id === 'sec1');
+    expect(sec?.members).toEqual([]);
+    const other = annotations.find((a) => a.id === 'outside');
+    expect(other?.members).toBeUndefined();
+  });
+
+  test('a non-section stroke never gets a members field', () => {
+    const sticky: StickyStroke = {
+      id: 'lone',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 0,
+      y: 0,
+      w: 60,
+      h: 60,
+      text: 'no section here',
+      fontSize: 14,
+    };
+    const { annotations } = read(REL, strokesToSvg([sticky]));
+    expect(annotations[0] && 'members' in annotations[0]).toBe(false);
+  });
+});

package/apps/studio/test/shell-importmap.test.ts

@@ -0,0 +1,49 @@
+// shell-importmap.test.ts — regression guard for the bug that broke
+// PhotoBgRemoveHarness's first real run (feature-photo-editor, Task 18):
+// `@imgly/background-removal` was added to `RUNTIME_PACKAGES` (runtime-bundle.ts,
+// Task 7/11) and its `/_canvas-runtime/@imgly_background-removal.js` bundle was
+// built + floor-checked, but the hand-maintained `<script type="importmap">` in
+// `_shell.html` never got the matching entry — so any CANVAS-side code
+// (`import('@imgly/background-removal')`, only ever exercised by the shell's
+// OWN client bundle until this task) hit a browser-native "Failed to resolve
+// module specifier" the moment it actually ran inside a canvas iframe.
+//
+// The invariant: every entry in RUNTIME_PACKAGES must have a matching
+// `_shell.html` importmap key pointing at `/_canvas-runtime/<slugFor(pkg)>.js`.
+// canvas-build.ts externalises the WHOLE list unconditionally (`externalSpecifiers
+// = new Set(RUNTIME_PACKAGES)`), so a package added there without a matching
+// importmap entry silently ships a canvas-side dead import until something
+// actually calls it at runtime — this test catches it at build time instead.
+
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { DEV_SERVER_ROOT } from '../paths.ts';
+import { RUNTIME_PACKAGES, slugFor } from '../runtime-bundle.ts';
+
+const SHELL_HTML_PATH = join(
+  DEV_SERVER_ROOT,
+  '..',
+  '..',
+  'plugins',
+  'design',
+  'templates',
+  '_shell.html'
+);
+
+describe('_shell.html importmap agrees with RUNTIME_PACKAGES', () => {
+  const shellHtml = readFileSync(SHELL_HTML_PATH, 'utf8');
+  const importmapMatch = shellHtml.match(/<script type="importmap">([\s\S]*?)<\/script>/);
+  test('the importmap script block exists', () => {
+    expect(importmapMatch).not.toBeNull();
+  });
+  const importmap = JSON.parse(importmapMatch?.[1] ?? '{}') as { imports?: Record<string, string> };
+  const imports = importmap.imports ?? {};
+
+  for (const pkg of RUNTIME_PACKAGES) {
+    test(`"${pkg}" resolves to its /_canvas-runtime/ bundle`, () => {
+      expect(imports[pkg]).toBe(`/_canvas-runtime/${slugFor(pkg)}.js`);
+    });
+  }
+});

package/apps/studio/test/text-editability-stamp.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from 'bun:test';
+import { applyTextEdit } from '../canvas-edit.ts';
+import { transpileCanvasSource } from '../canvas-pipeline.ts';
+
+// Phase 6 (unified-text-editing) — the build-time `data-cd-editable="text"`
+// marker must agree EXACTLY with applyTextEdit's acceptance (canvas-edit.ts):
+// stamped ⇔ a commit would save. See isInlineEditableText in
+// canvas-pipeline.ts (the mirrored predicate).
+
+const FIXTURE = `export default function Fixture() {
+  return (
+    <div>
+      <h1>Maude desktop E2E</h1>
+      <p>
+        Deterministic, static canvas — proves the native shell booted the
+        sidecar, navigated the webview, and rendered a canvas.
+      </p>
+      <p>Total: {1 + 1} items</p>
+      <span>{title}</span>
+      <h2>{'Quoted title'}</h2>
+      <button>
+        Save
+      </button>
+      <section>
+        <em>nested</em>
+      </section>
+      <div />
+    </div>
+  );
+}
+const title = 'x';
+`;
+
+function stamped(withIds: string, tag: string): boolean {
+  const m = withIds.match(new RegExp(`<${tag}[^>]*>`));
+  if (!m) throw new Error(`tag <${tag}> not found in output`);
+  return m[0].includes('data-cd-editable="text"');
+}
+
+describe('data-cd-editable build-time stamp', () => {
+  const { withIds } = transpileCanvasSource('/virtual/Fixture.tsx', FIXTURE);
+
+  test('single static JSXText gets the marker', () => {
+    expect(stamped(withIds, 'h1')).toBe(true);
+    expect(stamped(withIds, 'button')).toBe(true); // whitespace-framed text
+  });
+
+  test('multi-line static JSXText gets the marker', () => {
+    expect(stamped(withIds, 'p')).toBe(true); // first <p> — static prose
+  });
+
+  test('mixed static+expression content does NOT get the marker', () => {
+    // <p>Total: {1 + 1} items</p> — renders as leaf-looking text nodes, but
+    // the source is mixed → applyTextEdit refuses → must not be offered.
+    const second = withIds.match(/<p[^>]*>Total:/);
+    if (!second) throw new Error('mixed <p> not found');
+    expect(second[0].includes('data-cd-editable')).toBe(false);
+  });
+
+  test('dynamic expression content does NOT get the marker', () => {
+    expect(stamped(withIds, 'span')).toBe(false); // {title}
+  });
+
+  test("{'string literal'} single child DOES get the marker (DDR-150 P1)", () => {
+    expect(stamped(withIds, 'h2')).toBe(true);
+  });
+
+  test('containers and empty elements do NOT get the marker', () => {
+    expect(stamped(withIds, 'section')).toBe(false); // element child
+    const selfClosed = withIds.match(/<div [^>]*\/>/);
+    if (!selfClosed) throw new Error('self-closed div not found');
+    expect(selfClosed[0].includes('data-cd-editable')).toBe(false);
+  });
+
+  test('marker agrees with applyTextEdit acceptance for every stamped element', () => {
+    // Every data-cd-id that carries the marker must be accepted by the
+    // engine; every one without it (that has text-ish content) refused.
+    const opens = withIds.match(/<[a-z][^>]*data-cd-id="[^"]+"[^>]*>/g) ?? [];
+    for (const open of opens) {
+      const id = /data-cd-id="([^"]+)"/.exec(open)?.[1];
+      if (!id) continue;
+      const kind = /data-cd-editable="(text|var)"/.exec(open)?.[1];
+      let accepted = true;
+      try {
+        applyTextEdit('/virtual/Fixture.tsx', withIds, id, 'replacement');
+      } catch {
+        accepted = false;
+      }
+      // `text` (literal) MUST be accepted with no runtime context. `var`
+      // (a {variable}) is traced back at commit and needs occurrence/before —
+      // its acceptance is covered by dynamic-text-edit.test.ts, so only assert
+      // it isn't offered where the engine would hard-refuse a literal edit.
+      // Unmarked text-ish elements MUST be refused (no dead-end editor).
+      if (kind === 'text') {
+        expect(`${open} accepted=${accepted}`).toBe(`${open} accepted=true`);
+      } else if (!kind) {
+        expect(`${open} accepted=${accepted}`).toBe(`${open} accepted=false`);
+      }
+    }
+  });
+});
+
+describe('applyTextEdit sibling integrity (Task 6.3)', () => {
+  test('editing the h1 leaves every sibling byte-identical', () => {
+    const { withIds } = transpileCanvasSource('/virtual/Fixture.tsx', FIXTURE);
+    const h1Id = /<h1[^>]*data-cd-id="([^"]+)"/.exec(withIds)?.[1];
+    if (!h1Id) throw new Error('no h1 id');
+    const { source: out } = applyTextEdit('/virtual/Fixture.tsx', withIds, h1Id, 'New title');
+    // The h1 text changed…
+    expect(out).toMatch(/<h1[^>]*data-cd-editable="text"/);
+    expect(out).toContain('New title');
+    expect(out).not.toContain('Maude desktop E2E');
+    // …and EVERYTHING ELSE is byte-identical: strip the h1 element line from
+    // both versions and compare the rest wholesale.
+    const strip = (s: string) => s.replace(/<h1[^>]*>[^<]*<\/h1>/, '<h1/>');
+    expect(strip(out)).toBe(strip(withIds));
+  });
+
+  test('editing the multi-line p preserves its own whitespace framing', () => {
+    const { withIds } = transpileCanvasSource('/virtual/Fixture.tsx', FIXTURE);
+    const pId = /<p[^>]*data-cd-id="([^"]+)"[^>]*>\s*\n\s*Deterministic/.exec(withIds)?.[1];
+    if (!pId) throw new Error('no p id');
+    const { source: out } = applyTextEdit('/virtual/Fixture.tsx', withIds, pId, 'Short.');
+    // Leading/trailing whitespace of the JSXText survives (JSX indentation).
+    expect(out).toMatch(/<p[^>]*>\s*\n\s*Short\.\s*\n\s*<\/p>/);
+    // Siblings untouched.
+    expect(out).toMatch(/<h1[^>]*data-cd-editable="text"/);
+    expect(out).toContain('Maude desktop E2E');
+    expect(out).toContain('Total: {1 + 1} items');
+  });
+});

package/apps/studio/test/timeline-parse.test.ts

@@ -124,4 +124,61 @@ export default function Canvas(){ return (<DesignCanvas>
     expect(reel.total).toBe(120);
     expect(reel.audio).toHaveLength(1);
   });
+
+  test('a clips array built via .flatMap() collapses to one generic row (documents the parser limit — see video-comp SKILL.md "Never build ... with .map()/.flatMap()")', () => {
+    const src = `
+const CLIP = 60; const XF = 15;
+const clips = ['assets/a.mp4', 'assets/b.mp4', 'assets/c.mp4', 'assets/d.mp4'];
+const TOTAL = clips.length * CLIP - (clips.length - 1) * XF;
+const ReelClip = ({ src }) => <AbsoluteFill/>;
+function Reel(){
+  return (<AbsoluteFill><TransitionSeries>
+    {clips.flatMap((src, i) => {
+      const seq = <TransitionSeries.Sequence key={\`s\${i}\`} durationInFrames={CLIP}><ReelClip src={src}/></TransitionSeries.Sequence>;
+      if (i === clips.length - 1) return [seq];
+      return [seq, <TransitionSeries.Transition key={\`t\${i}\`} presentation={fade()} timing={linearTiming({ durationInFrames: XF })}/>];
+    })}
+  </TransitionSeries></AbsoluteFill>);
+}
+`;
+    // Only ONE literal <TransitionSeries.Sequence> occurrence exists in the
+    // source text (written once inside the callback) — not the 4 clips that
+    // exist at runtime — and its durationInFrames={CLIP} is fine but the
+    // array-driven TOTAL isn't resolvable arithmetic, so scopedTotal falls
+    // back to the derived span.
+    const r = parseCompTimeline(src, 0);
+    expect(r.sequences).toHaveLength(1);
+    expect(r.sequences[0]).toMatchObject({ label: 'ReelClip', duration: 60 });
+  });
+
+  test('the corrected 4-literal-block worked example (video-comp SKILL.md) parses all 4 named clips + the literal-sum total', () => {
+    const src = `
+const XF = 15;
+const TOTAL = 60 + 60 + 60 + 60 - XF * 3;
+const Clip = ({ src, label }) => <AbsoluteFill/>;
+const Reel = () => (
+  <AbsoluteFill>
+    <TransitionSeries>
+      <TransitionSeries.Sequence name="clip-1" durationInFrames={60}><Clip src="assets/a.mp4" label="01" /></TransitionSeries.Sequence>
+      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
+      <TransitionSeries.Sequence name="clip-2" durationInFrames={60}><Clip src="assets/b.mp4" label="02" /></TransitionSeries.Sequence>
+      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
+      <TransitionSeries.Sequence name="clip-3" durationInFrames={60}><Clip src="assets/c.mp4" label="03" /></TransitionSeries.Sequence>
+      <TransitionSeries.Transition presentation={fade()} timing={linearTiming({ durationInFrames: XF })} />
+      <TransitionSeries.Sequence name="clip-4" durationInFrames={60}><Clip src="assets/d.mp4" label="04" /></TransitionSeries.Sequence>
+    </TransitionSeries>
+  </AbsoluteFill>
+);
+`;
+    const r = parseCompTimeline(src, 0);
+    expect(r.sequences).toHaveLength(4);
+    expect(r.sequences.map((s) => s.label)).toEqual(['clip-1', 'clip-2', 'clip-3', 'clip-4']);
+    expect(r.sequences.map((s) => s.duration)).toEqual([60, 60, 60, 60]);
+    // Sequence 1 at 0; each next clip starts durationInFrames - XF after the
+    // previous (the transition overlaps back), same crossfade math as the
+    // existing 2-clip test above.
+    expect(r.sequences.map((s) => s.from)).toEqual([0, 45, 90, 135]);
+    // 60*4 - 15*3 = 195, and it's a literal-arithmetic sum the parser resolves.
+    expect(r.total).toBe(195);
+  });
 });

package/apps/studio/test/tool-palette-insert-anchor.test.ts

@@ -2,7 +2,9 @@
 // "+ Element" affordance's anchor resolver: appends relative to the ACTIVE
 // artboard's last existing child (mirrors the context-menu's element-relative
 // insert, since an artboard's own `<article data-dc-screen>` carries no
-// `data-cd-id` of its own — DCArtboard doesn't forward it to the DOM).
+// `data-cd-id` of its own — DCArtboard doesn't forward it to the DOM), falling
+// back to the artboard's own `data-dc-screen` id (inside-end) when it has no
+// such child yet — the empty-artboard fix for the previously-silent no-op.
 //
 // Needs a live DOM (querySelector/:scope) — register happy-dom for this file
 // only, like canvas-hmr-runtime.test.tsx.
@@ -62,13 +64,13 @@ describe('tool-palette / resolveInsertAnchor', () => {
     expect(resolveInsertAnchor(document)).toEqual({ refId: '11111111', position: 'after' });
   });
 
-  test('returns null for an EMPTY artboard (no data-cd-id child to anchor on)', () => {
+  test('falls back to the artboard id (inside-end) for an EMPTY artboard — no longer a silent no-op', () => {
     document.body.innerHTML = `
       <article data-dc-screen="a1" aria-current="true">
         <div class="dc-artboard-body"></div>
       </article>
     `;
-    expect(resolveInsertAnchor(document)).toBeNull();
+    expect(resolveInsertAnchor(document)).toEqual({ artboardId: 'a1', position: 'inside-end' });
   });
 
   test('returns null when there is no artboard at all', () => {

package/apps/studio/test/undo-stack.test.ts

@@ -208,4 +208,37 @@ describe('cross-iframe persistence (loadStackState / saveStackState)', () => {
     expect(reloaded.past.length).toBe(2);
     expect(reloaded.future.length).toBe(1);
   });
+
+  test('survives a WINDOW-STORE WIPE via sessionStorage (split-origin iframe reload)', () => {
+    // Split-origin canvas: the store lives on the iframe window, which a full
+    // reload (the HMR reload a `.tsx` text edit triggers) destroys. The durable
+    // sessionStorage layer must restore it. Install a fake window + sessionStorage.
+    const backing = new Map<string, string>();
+    const fakeSS = {
+      getItem: (k: string) => backing.get(k) ?? null,
+      setItem: (k: string, v: string) => backing.set(k, v),
+      removeItem: (k: string) => backing.delete(k),
+      key: (i: number) => [...backing.keys()][i] ?? null,
+      clear: () => backing.clear(),
+      get length() {
+        return backing.size;
+      },
+    };
+    const g = globalThis as unknown as { window?: unknown };
+    const prev = g.window;
+    g.window = { sessionStorage: fakeSS }; // no `top` → store host = this window
+    try {
+      _clearStackStore();
+      saveStackState('ui/Split.tsx', { past: [rec('kept')], future: [] });
+      expect(backing.size).toBe(1); // mirrored to sessionStorage
+      // Simulate the iframe reload: the window's in-memory Map is gone.
+      (g.window as { __maude_undo_stacks?: unknown }).__maude_undo_stacks = new Map();
+      const restored = loadStackState('ui/Split.tsx');
+      expect(restored.past.length).toBe(1);
+      expect(restored.past[0]?.label).toBe('kept');
+    } finally {
+      _clearStackStore();
+      g.window = prev;
+    }
+  });
 });

package/apps/studio/test/video-asset.test.ts

@@ -5,14 +5,14 @@
 //       the stored type AND category (→ which cap applies); a header lie / SVG /
 //       script is caught here;
 //   (2) the streaming POST endpoint (boots a real server) — video/audio happy
-//       path, per-category cap (image 10 MB stays tight; video honors the
-//       MAUDE_ASSET_MAX_VIDEO_BYTES override), content-addressed dedupe.
+//       path, per-category cap (image stays tighter than video; video honors
+//       the MAUDE_ASSET_MAX_VIDEO_BYTES override), content-addressed dedupe.
 
 import { describe, expect, test } from 'bun:test';
 import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { assetCapForCategory, sniffAssetType } from '../api.ts';
+import { ASSET_MAX_BYTES, assetCapForCategory, sniffAssetType } from '../api.ts';
 import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
 
 // ── Minimal valid magic-byte headers (padded so the ≥12-byte sniff has data). ──
@@ -59,8 +59,8 @@ describe('video-asset / sniffAssetType (the widened type gate)', () => {
     expect(sniffAssetType(pad([...ascii('RIFF'), 0, 0, 0, 0, ...ascii('AVI ')]))).toBeNull();
   });
 
-  test('caps: image 10 MB tight, video/audio share the larger cap', () => {
-    expect(assetCapForCategory('image')).toBe(10 * 1024 * 1024);
+  test('caps: image stays tight, video/audio share the larger cap', () => {
+    expect(assetCapForCategory('image')).toBe(ASSET_MAX_BYTES);
     expect(assetCapForCategory('video')).toBeGreaterThan(assetCapForCategory('image'));
     expect(assetCapForCategory('audio')).toBe(assetCapForCategory('video'));
   });

package/apps/studio/test/video-render-bridge.test.ts

@@ -8,7 +8,12 @@
 // (DOM containment resolution) and the `__maude_render_video__` bridge's
 // routing contract — it must merge the registered comp's component/meta with
 // the caller's opts and delegate to the injected `__maudeRenderVideo__`, and
-// fail clearly when either the comp or the render-lib injection is missing.
+// fail clearly when either the comp or the render-lib injection is missing, and
+// PROPAGATE a renderer failure as a rejection (the contract the capture shim's
+// try/catch relies on to fall back to frame-step screenshots — RCA
+// issue-video-mp4-rendermediaonweb-stack-overflow). The shim-level fallback
+// itself (renderMediaOnWeb throws → frame-step, video-only, degraded=true) is
+// verified live against a deep-precompositing comp — see that RCA's repro.
 
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import { GlobalRegistrator } from '@happy-dom/global-registrator';
@@ -146,4 +151,21 @@ describe('__maude_render_video__ bridge', () => {
       /render-lib bundle not injected/i
     );
   });
+
+  test('propagates a renderer failure (e.g. stack overflow) as a rejection the shim can catch', async () => {
+    // The capture shim (_video-playwright.mjs) wraps the __maude_render_video__
+    // page.evaluate in try/catch and degrades to frame-step screenshots when it
+    // rejects. That only works if the bridge surfaces __maudeRenderVideo__'s
+    // throw as a rejection rather than swallowing it — the exact failure mode
+    // of the RCA (@remotion/web-renderer overflowing on deep precompositing).
+    const w = window as unknown as RenderWindow;
+    installMaudeSeekBridge();
+    registerComp('reel', { fps: 30, durationInFrames: 228, width: 960, height: 540 }, () => null);
+    w.__maudeRenderVideo__ = async () => {
+      throw new RangeError('Maximum call stack size exceeded');
+    };
+    await expect(w.__maude_render_video__?.('reel', { container: 'mp4' })).rejects.toThrow(
+      /Maximum call stack size exceeded/
+    );
+  });
 });