@1agh/maude 0.58.2 → 0.59.0

package/apps/studio/test/cloud-endpoints.test.ts

@@ -12,6 +12,7 @@ import { join } from 'node:path';
 import {
   connectOutcomeNote,
   isDisplayableUrl,
+  isLinkedProjectRow,
   localIdentityHint,
   parseDeepLink,
   shareViewUrl,
@@ -187,6 +188,101 @@ describe('status — names the LOCAL half so a deep link can be read', () => {
   });
 });
 
+describe('isLinkedProjectRow — Connected is a state only a credentialed link earns (fix 7)', () => {
+  const CLOUD = 'https://cloud.maude.sh';
+  const row = (over = {}) =>
+    isLinkedProjectRow({
+      projectUrl: 'https://alligators.cloud.maude.sh',
+      linkedHubUrl: 'https://alligators.cloud.maude.sh',
+      linkedHubCredentialed: true,
+      cloudUrl: CLOUD,
+      ...over,
+    });
+
+  test('linked + credentialed → the row is Connected', () => {
+    expect(row()).toBe(true);
+  });
+  test('linked but UNCREDENTIALED still offers Connect — config.json travels with the repo (B2)', () => {
+    expect(row({ linkedHubCredentialed: false })).toBe(false);
+  });
+  test('an unrelated project keeps its Connect button', () => {
+    expect(row({ projectUrl: 'https://dugmate.cloud.maude.sh' })).toBe(false);
+  });
+  test('unlinked folder: no row is Connected', () => {
+    expect(row({ linkedHubUrl: null, linkedHubCredentialed: false })).toBe(false);
+  });
+  test('self-host addresses carry no project label — exact origin decides', () => {
+    expect(
+      row({
+        projectUrl: 'http://127.0.0.1:8788',
+        linkedHubUrl: 'http://127.0.0.1:8788',
+        cloudUrl: 'http://127.0.0.1:8788',
+      })
+    ).toBe(true);
+    // Two stubs on different ports are two different workspaces.
+    expect(
+      row({
+        projectUrl: 'http://127.0.0.1:8788',
+        linkedHubUrl: 'http://127.0.0.1:9999',
+        cloudUrl: 'http://127.0.0.1:8788',
+      })
+    ).toBe(false);
+  });
+  test('a label on one side and none on the other never matches', () => {
+    expect(row({ projectUrl: 'http://127.0.0.1:8788' })).toBe(false);
+  });
+});
+
+describe('detach — the in-app unlink (fix 7 Disconnect)', () => {
+  test('drops linkedHub + the hub credential, cycles the runtime to solo; idempotent', async () => {
+    const { createCloudEndpoints } = await import('../cloud/endpoints.ts');
+    const { mkdirSync, existsSync } = await import('node:fs');
+    const repoRoot = join(scratch, 'detach-me');
+    const designRoot = join(repoRoot, '.design');
+    mkdirSync(designRoot, { recursive: true });
+    const hubUrl = 'https://alligators.cloud.maude.sh';
+    writeFileSync(
+      join(designRoot, 'config.json'),
+      JSON.stringify({ designRoot: '.design', linkedHub: { url: hubUrl, linkedAt: 1 } })
+    );
+    writeFileSync(
+      join(scratch, 'hubs.json'),
+      JSON.stringify({ hubs: { [hubUrl]: { token: 'mau_x', linkedAt: 1 } }, trusted: [hubUrl] })
+    );
+
+    const restarts: unknown[] = [];
+    const api = createCloudEndpoints({
+      paths: { repoRoot, designRoot },
+      syncControl: {
+        restart: async (linkedHub) => {
+          restarts.push(linkedHub);
+          return { syncing: false, canvases: 0, reason: 'unlinked' };
+        },
+      },
+    });
+
+    const r = await api.detach();
+    expect(r.status).toBe(200);
+    expect((r.json as { detached?: boolean }).detached).toBe(true);
+    // The committed half is gone, the rest of config.json survives.
+    const cfg = JSON.parse(readFileSync(join(designRoot, 'config.json'), 'utf8'));
+    expect(cfg.linkedHub).toBeUndefined();
+    expect(cfg.designRoot).toBe('.design');
+    // The credential + trust entry are gone too (the CLI unlink default).
+    const hubs = JSON.parse(readFileSync(join(scratch, 'hubs.json'), 'utf8'));
+    expect(hubs.hubs[hubUrl]).toBeUndefined();
+    expect(hubs.trusted).not.toContain(hubUrl);
+    // The runtime was cycled with the explicit unlink sentinel, not undefined.
+    expect(restarts).toEqual([null]);
+    expect(existsSync(join(designRoot, 'config.json'))).toBe(true);
+
+    // Second detach: still ok, nothing to do.
+    const again = await api.detach();
+    expect(again.status).toBe(200);
+    expect((again.json as { detached?: boolean }).detached).toBe(false);
+  });
+});
+
 describe('localIdentityHint — only an exact, corroborated agreement is silent', () => {
   const CLOUD = 'https://cloud.maude.sh';
 

package/apps/studio/test/cloud-renew.test.ts

@@ -0,0 +1,205 @@
+// Silent hub-credential renewal (cloud/renew.ts) — the lane that keeps a
+// cloud link alive past the 12 h cell-session cap without a person pressing
+// Connect again. Every network hop is injected; nothing here talks to a real
+// host.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { renewHubCredential } from '../cloud/renew.ts';
+
+const HUB_URL = 'https://alligators.cloud.test';
+
+let dir: string;
+let envBackup: Record<string, string | undefined>;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'maude-renew-'));
+  envBackup = {
+    MAUDE_CLOUD_CONFIG: process.env.MAUDE_CLOUD_CONFIG,
+    HUBS_CONFIG_PATH: process.env.HUBS_CONFIG_PATH,
+    MAUDE_CLOUD_URL: process.env.MAUDE_CLOUD_URL,
+  };
+  process.env.MAUDE_CLOUD_CONFIG = join(dir, 'cloud.json');
+  process.env.HUBS_CONFIG_PATH = join(dir, 'hubs.json');
+  process.env.MAUDE_CLOUD_URL = 'https://cloud.test';
+});
+
+afterEach(() => {
+  for (const [k, v] of Object.entries(envBackup)) {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  }
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function signIn(token = 'mpt_account'): void {
+  writeFileSync(
+    join(dir, 'cloud.json'),
+    JSON.stringify({ url: 'https://cloud.test', token, connectedAt: 1 })
+  );
+}
+
+function writeHubRecord(record: Record<string, unknown>): void {
+  writeFileSync(join(dir, 'hubs.json'), JSON.stringify({ hubs: { [HUB_URL]: record } }));
+}
+
+function readHubRecord(): Record<string, unknown> | undefined {
+  try {
+    return JSON.parse(readFileSync(join(dir, 'hubs.json'), 'utf8')).hubs[HUB_URL];
+  } catch {
+    return undefined;
+  }
+}
+
+/** Route-keyed fetch stub; records every URL it was asked for. */
+function fakeFetch(routes: Record<string, { status: number; body: unknown }>) {
+  const calls: string[] = [];
+  const doFetch = (async (input: string | URL | Request) => {
+    const url = String(input);
+    calls.push(url);
+    for (const [prefix, r] of Object.entries(routes)) {
+      if (url.startsWith(prefix)) {
+        return new Response(JSON.stringify(r.body), { status: r.status });
+      }
+    }
+    return new Response('{}', { status: 404 });
+  }) as typeof fetch;
+  return { doFetch, calls };
+}
+
+const HAPPY_ROUTES = {
+  'https://cloud.test/api/projects': {
+    status: 200,
+    body: { projects: [{ id: 'alligators', url: HUB_URL, role: 'owner' }] },
+  },
+  'https://cloud.test/projects/open': {
+    status: 200,
+    body: { token: 'proj_tok', url: HUB_URL, role: 'owner', expiresAt: 111 },
+  },
+  [`${HUB_URL}/auth/login`]: {
+    status: 200,
+    body: { token: 'mau_new', expiresAt: 12345, user: { email: 'm@x.cz', role: 'member' } },
+  },
+};
+
+describe('renewHubCredential', () => {
+  test('signed out → not-signed-in, and no network is touched', async () => {
+    const { doFetch, calls } = fakeFetch(HAPPY_ROUTES);
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: false, reason: 'not-signed-in' });
+    expect(calls).toHaveLength(0);
+  });
+
+  test('happy path: projects → open → cell login → hubs.json updated, role preserved', async () => {
+    signIn();
+    writeHubRecord({ token: 'mau_stale', linkedAt: 1, role: 'member', expiresAt: 2 });
+    const { doFetch, calls } = fakeFetch(HAPPY_ROUTES);
+
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: true, token: 'mau_new', expiresAt: 12345 });
+
+    const stored = readHubRecord();
+    expect(stored?.token).toBe('mau_new');
+    expect(stored?.expiresAt).toBe(12345);
+    // The upsert replaces the record — the vouched role must survive renewal.
+    expect(stored?.role).toBe('member');
+
+    // The cell login went to the STORED hub address, not anything the cloud named.
+    expect(calls[2]).toBe(`${HUB_URL}/auth/login`);
+  });
+
+  test('F5: the FRESH role from the cell login wins over the stale stored one', async () => {
+    signIn();
+    writeHubRecord({ token: 'mau_stale', linkedAt: 1, role: 'member' });
+    const { doFetch } = fakeFetch({
+      ...HAPPY_ROUTES,
+      [`${HUB_URL}/auth/login`]: {
+        status: 200,
+        body: { token: 'mau_new', expiresAt: 12345, user: { email: 'm@x.cz', role: 'owner' } },
+      },
+    });
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r.ok).toBe(true);
+    expect(readHubRecord()?.role).toBe('owner'); // not the stale 'member'
+  });
+
+  test('F5: an older cell that omits the role falls back to the stored one', async () => {
+    signIn();
+    writeHubRecord({ token: 'mau_stale', linkedAt: 1, role: 'member' });
+    const { doFetch } = fakeFetch({
+      ...HAPPY_ROUTES,
+      [`${HUB_URL}/auth/login`]: { status: 200, body: { token: 'mau_new', expiresAt: 12345 } },
+    });
+    await renewHubCredential(HUB_URL, doFetch);
+    expect(readHubRecord()?.role).toBe('member');
+  });
+
+  test('claim-a: an embedded-credential hubUrl is refused, no network touched', async () => {
+    signIn();
+    const { doFetch, calls } = fakeFetch(HAPPY_ROUTES);
+    const r = await renewHubCredential('https://evil@alligators.cloud.test', doFetch);
+    expect(r).toEqual({ ok: false, reason: 'no-matching-project' });
+    expect(calls).toHaveLength(0);
+  });
+
+  test('account token revoked (401 on projects) → account-revoked, store untouched', async () => {
+    signIn();
+    writeHubRecord({ token: 'mau_stale', linkedAt: 1 });
+    const { doFetch } = fakeFetch({
+      'https://cloud.test/api/projects': { status: 401, body: {} },
+    });
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: false, reason: 'account-revoked' });
+    expect(readHubRecord()?.token).toBe('mau_stale');
+  });
+
+  test('hub not among the account projects → no-matching-project', async () => {
+    signIn();
+    const { doFetch } = fakeFetch({
+      'https://cloud.test/api/projects': {
+        status: 200,
+        body: { projects: [{ id: 'other', url: 'https://other.cloud.test', role: 'owner' }] },
+      },
+    });
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: false, reason: 'no-matching-project' });
+  });
+
+  test('a viewer role never renews an editor credential', async () => {
+    signIn();
+    const { doFetch } = fakeFetch({
+      'https://cloud.test/api/projects': {
+        status: 200,
+        body: { projects: [{ id: 'alligators', url: HUB_URL, role: 'viewer' }] },
+      },
+    });
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: false, reason: 'no-matching-project' });
+  });
+
+  test('removed member: /projects/open refuses → open-refused (the right place to die)', async () => {
+    signIn();
+    const { doFetch } = fakeFetch({
+      'https://cloud.test/api/projects': HAPPY_ROUTES['https://cloud.test/api/projects'],
+      'https://cloud.test/projects/open': { status: 404, body: {} },
+    });
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: false, reason: 'open-refused' });
+  });
+
+  test('cell refuses the exchange → cell-refused, store untouched', async () => {
+    signIn();
+    writeHubRecord({ token: 'mau_stale', linkedAt: 1 });
+    const { doFetch } = fakeFetch({
+      'https://cloud.test/api/projects': HAPPY_ROUTES['https://cloud.test/api/projects'],
+      'https://cloud.test/projects/open': HAPPY_ROUTES['https://cloud.test/projects/open'],
+      [`${HUB_URL}/auth/login`]: { status: 401, body: {} },
+    });
+    const r = await renewHubCredential(HUB_URL, doFetch);
+    expect(r).toEqual({ ok: false, reason: 'cell-refused' });
+    expect(readHubRecord()?.token).toBe('mau_stale');
+  });
+});

package/apps/studio/test/cloud-shell-surfaces.test.ts

@@ -36,11 +36,20 @@ const APP = readFileSync(join(STUDIO, 'client', 'app.jsx'), 'utf8');
 const SETTINGS = readFileSync(join(STUDIO, 'client', 'panels', 'SettingsPanel.jsx'), 'utf8');
 
 describe('the cloud shell offers nothing it cannot honour', () => {
-  test('the local-machine settings tabs are flagged, and only those three', () => {
+  test('the local-machine settings tabs are flagged — and the list is exact', () => {
+    // An exact list, not a `toContain`: the failure this guards is a tab that
+    // configures machine-local state shipping to the cloud shell UNFLAGGED,
+    // where its routes are refused by design (DDR-209 D1) and it renders as a
+    // wall of 404s. A new tab has to be classified deliberately, which means
+    // this assertion is SUPPOSED to fail when one is added.
+    //
+    // `figma` (DDR-216) is local-machine for the same reason `ai-generation`
+    // is: the credential lives in `~/.config/maude/keys.json` on this machine,
+    // and the import writes into this machine's design root.
     const flagged = [
       ...SETTINGS.matchAll(/\{ id: '([a-z-]+)', label: '[^']+', local: true \}/g),
     ].map((m) => m[1]);
-    expect(flagged.sort()).toEqual(['ai-generation', 'subtitles', 'video']);
+    expect(flagged.sort()).toEqual(['ai-generation', 'figma', 'subtitles', 'video']);
   });
 
   test('the tab rail renders the FILTERED list, not the raw table', () => {

package/apps/studio/test/exporters/degraded-propagation.test.ts

@@ -0,0 +1,123 @@
+// RCA issue-mp4-audio-export-html5audio-silent-degrade — the silence gate.
+//
+// The bug was not that the export degraded; degrading to a video-only capture
+// when the audio renderer refuses is DDR-157's deliberate design. The bug was
+// that the degradation reached nothing a human or an agent reads: `video.ts`
+// parsed the shim's `{degraded, audioDropped, fallbackReason}` summary, wrote ONE
+// console.error, and returned an ExportResult without it — so the job said
+// `done`, `_export-history.json` looked clean, `GET /_api/export-jobs` had no
+// field for it, and the Exports panel showed a success row. The user shipped a
+// muted file four times before anyone dug through the desktop app's stderr.
+//
+// The real regression gate for the artifact itself is an integration test that
+// exports a fixture comp and asserts an audio stream exists (RCA Testing
+// Requirements). That one needs a browser, and CI has none — so, matching the
+// house style of `export-shim-multi-capture.test.ts`, the propagation CHAIN is
+// guarded at the source-shape level here, plus a real unit test of the one piece
+// that is pure.
+
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { hasAudioStream, remedyFor } from '../../exporters/degraded.ts';
+
+const STUDIO = join(import.meta.dir, '..', '..');
+const read = (rel: string) => readFileSync(join(STUDIO, rel), 'utf8');
+
+describe('remedyFor — a fixable cause must carry its one-line fix', () => {
+  test('names @remotion/media for the Html5Audio rejection', () => {
+    const reason =
+      'page.evaluate: Error: <Html5Audio> is not supported in @remotion/web-renderer. ' +
+      'Use <Audio> from @remotion/media instead.';
+    const remedy = remedyFor(reason);
+    expect(remedy).toBeDefined();
+    expect(remedy).toContain('@remotion/media');
+    // The remedy has to say what to STOP doing too, or it reads as advice
+    // rather than a diagnosis of this file.
+    expect(remedy).toContain('remotion');
+  });
+
+  test('names the Video swap for the OffthreadVideo rejection', () => {
+    const remedy = remedyFor('<OffthreadVideo> is not supported in @remotion/web-renderer');
+    expect(remedy).toBeDefined();
+    expect(remedy).toContain('@remotion/media');
+  });
+
+  test('returns nothing for a cause the author cannot fix by hand', () => {
+    // The DDR-157 recursion overflow is data-dependent and has no one-liner —
+    // inventing a remedy for it would be worse than silence.
+    expect(remedyFor('RangeError: Maximum call stack size exceeded')).toBeUndefined();
+  });
+});
+
+describe('hasAudioStream — the artifact has the last word', () => {
+  const bytes = (s: string) => new TextEncoder().encode(s);
+
+  test('mp4 with a `soun` handler counts as having audio', () => {
+    expect(hasAudioStream(bytes('....hdlrsoun....'), 'mp4')).toBe(true);
+  });
+
+  test('mp4 with only a video handler does not', () => {
+    expect(hasAudioStream(bytes('....hdlrvide....'), 'mp4')).toBe(false);
+  });
+
+  test('webm is recognised by its audio CodecID', () => {
+    expect(hasAudioStream(bytes('\x00\x00A_OPUS\x00'), 'webm')).toBe(true);
+    expect(hasAudioStream(bytes('\x00\x00V_VP9\x00'), 'webm')).toBe(false);
+  });
+
+  test('an unrecognised container is assumed fine — never invent a degradation', () => {
+    expect(hasAudioStream(bytes('anything'), 'mov')).toBe(true);
+  });
+
+  test('an empty body does not crash the check', () => {
+    expect(hasAudioStream(new Uint8Array(0), 'mp4')).toBe(false);
+  });
+});
+
+describe('degraded propagation chain (source-shape — the browser half runs manually)', () => {
+  test('video.ts returns the degradation instead of only logging it', () => {
+    const src = read('exporters/video.ts');
+    // The precise regression: a console.error with no accompanying assignment.
+    expect(src).toContain('degraded = {');
+    expect(src).toMatch(/audioDropped:/);
+    expect(src).toMatch(/return\s*{[\s\S]*?degraded,[\s\S]*?}/);
+  });
+
+  test('ExportResult carries a degraded field', () => {
+    const src = read('exporters/index.ts');
+    expect(src).toContain('ExportDegradation');
+    expect(src).toMatch(/degraded\?:\s*ExportDegradation/);
+  });
+
+  test('the job record, the WS emit and the history entry all carry it', () => {
+    const src = read('exporters/jobs.ts');
+    // Job type + assignment on the done path.
+    expect(src).toMatch(/degraded\?:\s*ExportDegradation/);
+    expect(src).toContain('if (res.degraded) job.degraded = res.degraded;');
+    // deriveHistory() writes `_export-history.json` — the ledger a later
+    // session reads back. It must not look clean either.
+    expect(src).toMatch(/degraded:\s*j\.degraded/);
+    // The WS emit spreads the whole job, which is how `degraded` reaches
+    // subscribers — assert the spread rather than a field list that could drift.
+    expect(src).toContain("bus.emit('export:job', { ...job })");
+  });
+
+  test('status stays `done` — the file is real, the flag is what differs', () => {
+    const src = read('exporters/jobs.ts');
+    expect(src).toContain("job.status = 'done';");
+  });
+
+  test('the panel and the toast both surface it', () => {
+    const src = read('client/export-center.jsx');
+    expect(src).toContain('DegradedNote');
+    expect(src).toContain('export-degraded-note');
+    // The pill must not read "Ready" on a muted file.
+    expect(src).toContain('Ready · no audio');
+    // Both surfaces, because the toast is what the user sees without opening
+    // the panel, and the panel is what they revisit afterwards.
+    const noteUses = src.match(/<DegradedNote/g) ?? [];
+    expect(noteUses.length).toBeGreaterThanOrEqual(2);
+  });
+});

package/apps/studio/test/exporters/unsupported-media.test.ts

@@ -0,0 +1,123 @@
+// RCA issue-mp4-audio-export-html5audio-silent-degrade — the pre-flight scanner.
+//
+// The cases here are the ones the RCA's Testing Requirements name, and the
+// barrel case is the one that matters most: the reproducer does NOT import
+// `Audio` from 'remotion' in the canvas file. It imports it from `_broadcast`,
+// which re-exports it. A scanner that reads only the canvas sees a clean local
+// import and waves the export through — which is exactly how this shipped.
+
+import { describe, expect, test } from 'bun:test';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { audioRefusalMessage, scanUnsupportedMedia } from '../../exporters/unsupported-media.ts';
+
+function sandbox(files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), 'maude-unsupported-'));
+  for (const [name, body] of Object.entries(files)) {
+    writeFileSync(join(dir, name), body);
+  }
+  return dir;
+}
+
+describe('scanUnsupportedMedia', () => {
+  test('flags a direct <Audio> import from remotion', () => {
+    const dir = sandbox({
+      'c.tsx': `import { AbsoluteFill, Audio } from 'remotion';
+        export const C = () => <AbsoluteFill><Audio src="x.mp3" /></AbsoluteFill>;`,
+    });
+    const found = scanUnsupportedMedia(join(dir, 'c.tsx'));
+    expect(found).toHaveLength(1);
+    expect(found[0].element).toBe('Audio');
+    expect(found[0].viaBarrel).toBe(false);
+  });
+
+  test('flags it in a multi-binding import alongside supported names', () => {
+    const dir = sandbox({
+      'c.tsx': `import { AbsoluteFill, OffthreadVideo, Audio } from 'remotion';
+        export const C = () => <><Audio src="a" /><OffthreadVideo src="v" /></>;`,
+    });
+    const els = scanUnsupportedMedia(join(dir, 'c.tsx')).map((f) => f.element);
+    expect(els).toContain('Audio');
+    expect(els).toContain('OffthreadVideo');
+  });
+
+  test('sees through a re-export barrel one hop away — the actual shape of the bug', () => {
+    const dir = sandbox({
+      '_broadcast.tsx': `export { Audio } from 'remotion';
+        export const Brand = () => null;`,
+      'c.tsx': `import { Audio, Brand } from './_broadcast';
+        export const C = () => <><Brand /><Audio src="sax.mp3" /></>;`,
+    });
+    const found = scanUnsupportedMedia(join(dir, 'c.tsx'));
+    expect(found).toHaveLength(1);
+    expect(found[0].element).toBe('Audio');
+    expect(found[0].viaBarrel).toBe(true);
+    expect(found[0].sourceFile).toContain('_broadcast');
+  });
+
+  test('does NOT flag the supported @remotion/media import', () => {
+    const dir = sandbox({
+      'c.tsx': `import { Audio, Video } from '@remotion/media';
+        export const C = () => <><Audio src="a" /><Video src="v" /></>;`,
+    });
+    expect(scanUnsupportedMedia(join(dir, 'c.tsx'))).toHaveLength(0);
+  });
+
+  test('does not flag a sibling package whose name merely starts with remotion', () => {
+    const dir = sandbox({
+      'c.tsx': `import { TransitionSeries } from '@remotion/transitions';
+        import { Audio } from '@remotion/media';
+        export const C = () => <Audio src="a" />;`,
+    });
+    expect(scanUnsupportedMedia(join(dir, 'c.tsx'))).toHaveLength(0);
+  });
+
+  test('ignores an unused import — not worth refusing an export over', () => {
+    const dir = sandbox({
+      'c.tsx': `import { AbsoluteFill, Audio } from 'remotion';
+        export const C = () => <AbsoluteFill>silent</AbsoluteFill>;`,
+    });
+    expect(scanUnsupportedMedia(join(dir, 'c.tsx'))).toHaveLength(0);
+  });
+
+  test('catches an aliased import mounted under its alias', () => {
+    const dir = sandbox({
+      'c.tsx': `import { Audio as Sound } from 'remotion';
+        export const C = () => <Sound src="a" />;`,
+    });
+    const found = scanUnsupportedMedia(join(dir, 'c.tsx'));
+    expect(found).toHaveLength(1);
+    // Reported as the element it IS, but matched on the name it renders under.
+    expect(found[0].element).toBe('Audio');
+    expect(found[0].localName).toBe('Sound');
+  });
+
+  test('an aliased-but-unused import is still not worth refusing over', () => {
+    const dir = sandbox({
+      'c.tsx': `import { Audio as Sound } from 'remotion';
+        export const C = () => <div>silent</div>;`,
+    });
+    expect(scanUnsupportedMedia(join(dir, 'c.tsx'))).toHaveLength(0);
+  });
+
+  test('an unreadable canvas is not this check’s business to report', () => {
+    expect(scanUnsupportedMedia('/definitely/not/here.tsx')).toEqual([]);
+  });
+});
+
+describe('audioRefusalMessage', () => {
+  test('states the cause, the cost, and the one-word fix', () => {
+    const msg = audioRefusalMessage(
+      { element: 'Audio', sourceFile: '/x/_broadcast.tsx', viaBarrel: true, localName: 'Audio' },
+      'ui/social/Krpole.tsx'
+    );
+    expect(msg).toContain('Html5Audio');
+    expect(msg).toContain('@remotion/media');
+    expect(msg).toContain('_broadcast.tsx');
+    // The escape hatch must be discoverable from the refusal itself, or a user
+    // who genuinely wants a muted export is stuck.
+    expect(msg).toContain('allowUnsupportedMedia');
+  });
+});