@1agh/maude 0.42.0 → 0.44.0

package/apps/studio/test/dynamic-text-edit.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, test } from 'bun:test';
+import { applyTextEdit } from '../canvas-edit.ts';
+import { transpileCanvasSource } from '../canvas-pipeline.ts';
+
+// unified-text-editing follow-up — editing text that comes from a `{variable}`
+// or `{item.prop}` by tracing it back to its source string (a local const or a
+// `.map()`ed array element). The safety contract: never rewrite the wrong item
+// — occurrence picks the `.map()` slot, `before` verifies/rescues it, and an
+// unresolvable expression still throws (routes to /design:edit).
+
+const CANVAS = '/virtual/Cards.tsx';
+const SRC = `const TOPICS = [
+  { key: "a", body: "Alpha body text." },
+  { key: "b", body: "Beta body text." },
+  { key: "c", body: "Gamma body text." },
+];
+const TAGS = ["first", "second", "third"];
+const HEADLINE = "The one headline";
+export default function Cards() {
+  return (
+    <div>
+      <h1>{HEADLINE}</h1>
+      <section>
+        {TOPICS.map((t) => (
+          <article key={t.key}>
+            <p>{t.body}</p>
+          </article>
+        ))}
+      </section>
+      <ul>
+        {TAGS.map((tag) => (
+          <li key={tag}>{tag}</li>
+        ))}
+      </ul>
+      <p>Total: {TOPICS.length} topics</p>
+      <span>{price.toFixed(2)}</span>
+    </div>
+  );
+}
+const price = 9;
+`;
+
+function ids(withIds: string, tag: string, inner: string): string {
+  // Grab the data-cd-id of the <tag …>inner… element.
+  const re = new RegExp(`<${tag}\\s+data-cd-id="([^"]+)"[^>]*>\\s*\\{?${inner}`);
+  const m = withIds.match(re);
+  if (!m) throw new Error(`no ${tag} matching ${inner}`);
+  return m[1] as string;
+}
+
+describe('dynamic text edit — resolveDynamicTextSpan via applyTextEdit', () => {
+  const { withIds } = transpileCanvasSource(CANVAS, SRC);
+
+  test('{item.prop} in a .map — occurrence picks the array item', () => {
+    const pId = ids(withIds, 'p', 't\\.body');
+    // occurrence 1 → TOPICS[1].body, verified by `before`.
+    const { source } = applyTextEdit(CANVAS, withIds, pId, 'Beta EDITED', {
+      occurrence: 1,
+      before: 'Beta body text.',
+    });
+    expect(source).toContain('body: "Beta EDITED"');
+    expect(source).toContain('body: "Alpha body text."'); // sibling untouched
+    expect(source).toContain('body: "Gamma body text."');
+  });
+
+  test('{item.prop} — index drift rescued by unique before-match', () => {
+    const pId = ids(withIds, 'p', 't\\.body');
+    // Wrong occurrence, but `before` uniquely identifies Gamma → rewrite it.
+    const { source } = applyTextEdit(CANVAS, withIds, pId, 'Gamma EDITED', {
+      occurrence: 0,
+      before: 'Gamma body text.',
+    });
+    expect(source).toContain('body: "Gamma EDITED"');
+    expect(source).toContain('body: "Alpha body text."');
+  });
+
+  test('{item} in a .map over a string array', () => {
+    const liId = ids(withIds, 'li', 'tag');
+    const { source } = applyTextEdit(CANVAS, withIds, liId, 'SECOND', {
+      occurrence: 1,
+      before: 'second',
+    });
+    expect(source).toContain('"first", "SECOND", "third"');
+  });
+
+  test('{localConst} — rewrites the const string', () => {
+    const h1Id = ids(withIds, 'h1', 'HEADLINE');
+    const { source } = applyTextEdit(CANVAS, withIds, h1Id, 'A new headline', {
+      before: 'The one headline',
+    });
+    expect(source).toContain('HEADLINE = "A new headline"');
+  });
+
+  test('{prop.field} — component fed BEATS[k] resolves to BEATS[k].field', () => {
+    // A reusable component whose `beat` prop is fed `BEATS[0..2]` at each usage
+    // (the Remotion-style pattern). Editing the 2nd usage's caption must hit
+    // BEATS[1].caption via occurrence, not card 0 or 2.
+    const SRC2 = `const BEATS = [
+  { n: "01", caption: "Beat one caption." },
+  { n: "02", caption: "Beat two caption." },
+  { n: "03", caption: "Beat three caption." },
+];
+function GuideBeat({ beat }: { beat: (typeof BEATS)[number] }) {
+  return <p>{beat.caption}</p>;
+}
+export default function Reel() {
+  return (
+    <div>
+      <GuideBeat beat={BEATS[0]} />
+      <GuideBeat beat={BEATS[1]} />
+      <GuideBeat beat={BEATS[2]} />
+    </div>
+  );
+}`;
+    const built = transpileCanvasSource(CANVAS, SRC2).withIds;
+    const pId = /<p\s+data-cd-id="([^"]+)"[^>]*>\s*\{beat\.caption\}/.exec(built)?.[1] as string;
+    const { source } = applyTextEdit(CANVAS, built, pId, 'Beat two EDITED', {
+      occurrence: 1,
+      before: 'Beat two caption.',
+    });
+    expect(source).toContain('caption: "Beat two EDITED"');
+    expect(source).toContain('caption: "Beat one caption."');
+    expect(source).toContain('caption: "Beat three caption."');
+  });
+
+  test('genuinely computed text still refuses (routes to /design:edit)', () => {
+    const spanId = ids(withIds, 'span', 'price\\.toFixed');
+    expect(() =>
+      applyTextEdit(CANVAS, withIds, spanId, 'nope', { occurrence: 0, before: '9.00' })
+    ).toThrow(/dynamic content/);
+  });
+
+  test('mixed literal+expression (Total: {n} topics) refuses', () => {
+    // This <p> has text + expression + text → mixed, never offered.
+    const m = withIds.match(/<p[^>]*data-cd-id="([^"]+)"[^>]*>Total:/);
+    expect(m).toBeTruthy();
+    expect(() => applyTextEdit(CANVAS, withIds, (m as RegExpMatchArray)[1] as string, 'x')).toThrow(
+      /mixed or expression/
+    );
+  });
+
+  test('no occurrence + no before on an ambiguous .map refuses (never guesses)', () => {
+    const pId = ids(withIds, 'p', 't\\.body');
+    // Without occurrence or before there is no way to know which card → refuse.
+    expect(() => applyTextEdit(CANVAS, withIds, pId, 'x')).toThrow(/dynamic content/);
+  });
+});
+
+describe('stamp marks var-editable text', () => {
+  const { withIds } = transpileCanvasSource(CANVAS, SRC);
+  test('{item.prop}, {item}, {const} get data-cd-editable="var"', () => {
+    expect(withIds).toMatch(/<p[^>]*data-cd-editable="var"[^>]*>\s*\{t\.body\}/);
+    expect(withIds).toMatch(/<li[^>]*data-cd-editable="var"[^>]*>\s*\{tag\}/);
+    expect(withIds).toMatch(/<h1[^>]*data-cd-editable="var"[^>]*>\s*\{HEADLINE\}/);
+  });
+  test('computed + mixed text are NOT marked', () => {
+    const span = withIds.match(/<span[^>]*>\{price\.toFixed/);
+    expect((span as RegExpMatchArray)[0].includes('data-cd-editable')).toBe(false);
+    const p = withIds.match(/<p[^>]*>Total:/);
+    expect((p as RegExpMatchArray)[0].includes('data-cd-editable')).toBe(false);
+  });
+});

package/apps/studio/test/edit-source-command.test.ts

@@ -30,9 +30,32 @@ describe('createEditSourceCommand', () => {
       id: 'cd-1',
       key: 'color',
       value: 'blue',
+      // do() writes `after` over `before`, so `from` = before; css has no occurrence.
+      from: 'red',
+      occurrence: undefined,
     });
   });
 
+  test('do()/undo() carry occurrence + from for a text edit (variable re-target)', async () => {
+    const applyFn = mock(() => {});
+    const textEdit: EditSourcePayload = {
+      op: 'text',
+      canvas: '.design/ui/Foo.tsx',
+      id: 'cd-9',
+      key: '',
+      before: 'Old',
+      after: 'New',
+      occurrence: 2,
+    };
+    const cmd = createEditSourceCommand({ payload: textEdit, applyFn });
+    await cmd.do();
+    // redo/do: write New over Old → from = Old.
+    expect(applyFn.mock.calls[0]?.[0]).toMatchObject({ value: 'New', from: 'Old', occurrence: 2 });
+    await cmd.undo();
+    // undo: write Old over New → from = New.
+    expect(applyFn.mock.calls[1]?.[0]).toMatchObject({ value: 'Old', from: 'New', occurrence: 2 });
+  });
+
   test('undo() applies the BEFORE value', async () => {
     const applyFn = mock(() => {});
     const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });

package/apps/studio/test/element-structural-edit.test.ts

@@ -10,7 +10,10 @@ import {
   applyDeleteElement,
   applyInsertArtboard,
   applyInsertElement,
+  applyInsertElementIntoArtboard,
   applyResizeArtboard,
+  applySetArtboardHug,
+  applySetArtboardStyle,
   CanvasEditError,
 } from '../canvas-edit.ts';
 import { transpileCanvasSource } from '../canvas-pipeline.ts';
@@ -153,6 +156,51 @@ describe('canvas-edit / applyInsertElement', () => {
   });
 });
 
+describe('canvas-edit / applyInsertElementIntoArtboard (empty-artboard fallback)', () => {
+  const emptyCanvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test("inserts a div as the artboard's only child (inside-end)", () => {
+    const out = applyInsertElementIntoArtboard(CANVAS, emptyCanvas, 'home', 'inside-end', 'div');
+    expect(out.source).toMatch(
+      /<DCArtboard id="home"[^>]*>[\s\S]*var\(--bg-2\)[\s\S]*<\/DCArtboard>/
+    );
+    expect(parses(out.source)).toBe(true);
+    expect(out.newId).toMatch(/^[0-9a-f]{8}$/);
+  });
+
+  test('inside-start lands the new element right after the opening tag', () => {
+    const out = applyInsertElementIntoArtboard(CANVAS, emptyCanvas, 'home', 'inside-start', 'text');
+    expect(out.source).toContain('<p style={{ margin: 0 }}>Text</p>');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('image insert requires a contained asset src', () => {
+    expect(() =>
+      applyInsertElementIntoArtboard(CANVAS, emptyCanvas, 'home', 'inside-end', 'image')
+    ).toThrow(CanvasEditError);
+    const ok = applyInsertElementIntoArtboard(CANVAS, emptyCanvas, 'home', 'inside-end', 'image', {
+      src: 'assets/ab12cd34.png',
+    });
+    expect(ok.source).toContain('src="assets/ab12cd34.png"');
+    expect(parses(ok.source)).toBe(true);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() =>
+      applyInsertElementIntoArtboard(CANVAS, emptyCanvas, 'nope', 'inside-end', 'div')
+    ).toThrow(CanvasEditError);
+  });
+});
+
 describe('canvas-edit / applyResizeArtboard (D4)', () => {
   const canvas = [
     'export default function Demo() {',
@@ -185,6 +233,112 @@ describe('canvas-edit / applyResizeArtboard (D4)', () => {
   });
 });
 
+describe('canvas-edit / applySetArtboardHug (Hug ⇄ Fixed toggle)', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('fixed=true adds the bare boolean prop, no string/expr value', () => {
+    const out = applySetArtboardHug(CANVAS, canvas, 'home', true);
+    expect(out.source).toMatch(/<DCArtboard\b[^>]*\bfixed\b(?!=)[^>]*>/);
+    expect(out.source).not.toContain('fixed={true}');
+    expect(out.source).not.toContain('fixed="true"');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('fixed=true with freezeHeight also pins height (numeric prop)', () => {
+    const out = applySetArtboardHug(CANVAS, canvas, 'home', true, 777);
+    expect(out.source).toContain('fixed');
+    expect(out.source).toContain('height={777}');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('fixed=true is idempotent — no duplicate attr on a board already pinned', () => {
+    const once = applySetArtboardHug(CANVAS, canvas, 'home', true);
+    const twice = applySetArtboardHug(CANVAS, once.source, 'home', true);
+    expect(twice.source.match(/\bfixed\b/g)?.length).toBe(1);
+  });
+
+  test('fixed=false removes the prop, height untouched', () => {
+    const pinned = applySetArtboardHug(CANVAS, canvas, 'home', true, 777);
+    const out = applySetArtboardHug(CANVAS, pinned.source, 'home', false);
+    expect(out.source).not.toContain('fixed');
+    expect(out.source).toContain('height={777}'); // stays as the hug floor
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('fixed=false on an already-hug board is a no-op', () => {
+    const out = applySetArtboardHug(CANVAS, canvas, 'home', false);
+    expect(out.source).toBe(canvas);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardHug(CANVAS, canvas, 'nope', true)).toThrow(CanvasEditError);
+  });
+});
+
+describe('canvas-edit / applySetArtboardStyle (background/padding/layout/gap)', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('writes background/layout as string literals, padding/gap as numeric', () => {
+    const out = applySetArtboardStyle(CANVAS, canvas, 'home', {
+      background: 'var(--bg-1)',
+      layout: 'flex-col',
+      padding: 16,
+      gap: 8,
+    });
+    expect(out.source).toContain('background="var(--bg-1)"');
+    expect(out.source).toContain('layout="flex-col"');
+    expect(out.source).toContain('padding={16}');
+    expect(out.source).toContain('gap={8}');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('padding/gap of 0 is written verbatim, not clamped to 1', () => {
+    const out = applySetArtboardStyle(CANVAS, canvas, 'home', { padding: 0, gap: 0 });
+    expect(out.source).toContain('padding={0}');
+    expect(out.source).toContain('gap={0}');
+  });
+
+  test('null resets a previously-set prop (removes the attribute)', () => {
+    const styled = applySetArtboardStyle(CANVAS, canvas, 'home', { background: 'red' });
+    const out = applySetArtboardStyle(CANVAS, styled.source, 'home', { background: null });
+    expect(out.source).not.toContain('background=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('an absent key leaves that prop untouched', () => {
+    const styled = applySetArtboardStyle(CANVAS, canvas, 'home', { background: 'red', padding: 4 });
+    const out = applySetArtboardStyle(CANVAS, styled.source, 'home', { padding: 8 });
+    expect(out.source).toContain('background="red"'); // untouched
+    expect(out.source).toContain('padding={8}');
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardStyle(CANVAS, canvas, 'nope', { padding: 4 })).toThrow(
+      CanvasEditError
+    );
+  });
+});
+
 describe('canvas-edit / applyInsertArtboard (I4)', () => {
   const canvas = [
     'export default function Demo() {',

package/apps/studio/test/fixtures/fake-claude-auth.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// Test fixture standing in for the `claude` CLI — implements only the one
+// subcommand probeAcpAvailabilityAuthed()/getClaudeAuthStatus() shell out to.
+// FAKE_CLAUDE_LOGGED_IN=1 controls the reported sign-in state.
+const [, , cmd, sub] = process.argv;
+if (cmd === 'auth' && sub === 'status') {
+  const loggedIn = process.env.FAKE_CLAUDE_LOGGED_IN === '1';
+  process.stdout.write(
+    JSON.stringify({ loggedIn, apiProvider: loggedIn ? 'firstParty' : undefined })
+  );
+  process.exit(0);
+}
+process.exit(1);

package/apps/studio/test/footage-store.test.ts

@@ -0,0 +1,100 @@
+// footage-store — round-trip + rejection coverage (feature-footage-analysis-director).
+// Uses a real temp designRoot on disk (Bun.write/Bun.file). Mirrors the photo
+// store's contract: valid analysis + EDL persist and read back; invalid input
+// returns a discriminated {ok:false,status} (never throws); traversal params in
+// the asset/slug are rejected by construction.
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import type { Context } from '../context.ts';
+import { assetSha8, createFootageStore, edlSlug } from '../footage-store.ts';
+
+let root: string;
+let store: ReturnType<typeof createFootageStore>;
+
+beforeAll(() => {
+  root = mkdtempSync(path.join(tmpdir(), 'footage-store-'));
+  const designRoot = path.join(root, '.design');
+  // Only the fields footage-store touches are needed.
+  store = createFootageStore({ paths: { designRoot } } as unknown as Context);
+});
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+describe('assetSha8 / edlSlug extraction', () => {
+  test('accepts the sha8 in every form', () => {
+    for (const p of ['assets/a1b2c3d4.mp4', '/assets/a1b2c3d4.png', 'a1b2c3d4.mov', 'a1b2c3d4'])
+      expect(assetSha8(p)).toBe('a1b2c3d4');
+  });
+  test('rejects traversal / non-hex', () => {
+    for (const p of ['../x', 'assets/../x', 'not-hex!', '', null]) expect(assetSha8(p)).toBeNull();
+  });
+  test('slug accepts kebab, rejects traversal / dots', () => {
+    expect(edlSlug('alligators-reel')).toBe('alligators-reel');
+    for (const s of ['../evil', 'has.dot', 'UPPER', '/abs', '']) expect(edlSlug(s)).toBeNull();
+  });
+});
+
+describe('analysis round-trip', () => {
+  test('saves a valid analysis and reads it back', async () => {
+    const res = await store.saveAnalysis('assets/a1b2c3d4.mp4', {
+      asset: 'assets/a1b2c3d4.mp4',
+      durationSec: 10,
+      shots: [{ start: 0, end: 3, usable: true, quality: 0.8 }],
+    });
+    expect(res.ok).toBe(true);
+    if (res.ok) expect(res.path).toBe('assets/a1b2c3d4.footage.json');
+    const back = await store.getAnalysis('a1b2c3d4');
+    expect(back?.shots?.[0].quality).toBe(0.8);
+    expect(back?.version).toBe(1);
+  });
+
+  test('rejects an invalid analysis with a 400 (never throws)', async () => {
+    const res = await store.saveAnalysis('assets/a1b2c3d4.mp4', { shots: [{ start: 5, end: 5 }] });
+    expect(res.ok).toBe(false);
+    if (!res.ok) expect(res.status).toBe(400);
+  });
+
+  test('rejects a bad asset param with a 400', async () => {
+    const res = await store.saveAnalysis('../evil', {});
+    expect(res.ok).toBe(false);
+    if (!res.ok) expect(res.status).toBe(400);
+  });
+
+  test('getAnalysis returns null for an absent sidecar', async () => {
+    expect(await store.getAnalysis('ffffffff')).toBeNull();
+  });
+});
+
+describe('EDL round-trip', () => {
+  test('saves a valid EDL under <slug>.edl.json and reads it back', async () => {
+    const res = await store.saveEdl('alligators-reel', {
+      title: 'Reel',
+      fps: 30,
+      width: 1920,
+      height: 1080,
+      beats: [{ clip: 'assets/a1b2c3d4.mp4', startSec: 0, durationFrames: 60, name: 'intro' }],
+    });
+    expect(res.ok).toBe(true);
+    if (res.ok) expect(res.path).toBe('alligators-reel.edl.json');
+    const back = await store.getEdl('alligators-reel');
+    expect(back?.beats?.[0].name).toBe('intro');
+    expect(back?.version).toBe(1);
+  });
+
+  test('rejects an EDL with an unbundled transition', async () => {
+    const res = await store.saveEdl('bad-reel', {
+      beats: [
+        {
+          clip: 'assets/a1b2c3d4.mp4',
+          startSec: 0,
+          durationFrames: 30,
+          transition: { presentation: 'zoom', frames: 5 },
+        },
+      ],
+    });
+    expect(res.ok).toBe(false);
+    if (!res.ok) expect(res.status).toBe(400);
+  });
+});

package/apps/studio/test/generate-route.test.ts

@@ -0,0 +1,106 @@
+// generate-route.test.ts — the privileged /_api/generate* routes on the MAIN
+// origin. Boots a real server (no CANVAS_ORIGIN_SPLIT; loopback host). Proves:
+// validation rejects bad bodies; a key POST reports {configured} and GET never
+// echoes the value; the provider catalogue serializes with a presence flag; and
+// a generate POST enqueues a job (202 {jobId}) that fails cleanly with no key
+// configured (no real Google call). Points MAUDE_GEN_KEYS_PATH at the sandbox
+// so the user's real key store is never touched.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
+
+let keysDir: string;
+beforeEach(() => {
+  keysDir = mkdtempSync(join(tmpdir(), 'maude-genroute-'));
+});
+afterEach(() => rmSync(keysDir, { recursive: true, force: true }));
+
+describe('/_api/generate* main-origin routes', () => {
+  test('providers catalogue, key custody (no echo), validation, and enqueue', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port, {
+      MAUDE_GEN_KEYS_PATH: join(keysDir, 'keys.json'),
+    });
+    const base = `http://localhost:${port}`;
+    try {
+      // Provider catalogue — gemini present, not yet configured.
+      const provRes = await fetch(`${base}/_api/generate/providers`);
+      expect(provRes.status).toBe(200);
+      const provJson = (await provRes.json()) as {
+        providers: Array<{ id: string; configured: boolean }>;
+      };
+      const gemini = provJson.providers.find((p) => p.id === 'gemini');
+      expect(gemini).toBeTruthy();
+      expect(gemini?.configured).toBe(false);
+
+      // Set a key → {configured:true}; the value is NEVER echoed back.
+      const setRes = await fetch(`${base}/_api/generate/keys`, {
+        method: 'POST',
+        headers: { 'content-type': 'text/plain' },
+        body: JSON.stringify({ provider: 'gemini', key: 'AIza-super-secret' }),
+      });
+      expect(setRes.status).toBe(200);
+      const setJson = (await setRes.json()) as Record<string, unknown>;
+      expect(setJson.configured).toBe(true);
+      expect(JSON.stringify(setJson)).not.toContain('super-secret');
+
+      // GET key status → presence only, no value.
+      const statusRes = await fetch(`${base}/_api/generate/keys`);
+      const statusJson = (await statusRes.json()) as { configured: string[] };
+      expect(statusJson.configured).toContain('gemini');
+      expect(JSON.stringify(statusJson)).not.toContain('super-secret');
+
+      // Validation — a malformed generate body 400s before any provider call.
+      const badRes = await fetch(`${base}/_api/generate-jobs`, {
+        method: 'POST',
+        headers: { 'content-type': 'text/plain' },
+        body: JSON.stringify({ modality: 'hologram', provider: '../etc' }),
+      });
+      expect(badRes.status).toBe(400);
+
+      // Unknown provider 400s.
+      const unkRes = await fetch(`${base}/_api/generate-jobs`, {
+        method: 'POST',
+        headers: { 'content-type': 'text/plain' },
+        body: JSON.stringify({ modality: 'image', provider: 'nope', prompt: 'x' }),
+      });
+      expect(unkRes.status).toBe(400);
+
+      // A well-formed request enqueues → 202 { jobId }. (The run will hit the
+      // real Gemini endpoint with a bogus key and fail in the background — we
+      // only assert the queue accepted it and surfaces the job.)
+      const okRes = await fetch(`${base}/_api/generate-jobs`, {
+        method: 'POST',
+        headers: { 'content-type': 'text/plain' },
+        body: JSON.stringify({ modality: 'image', provider: 'gemini', prompt: 'a red circle' }),
+      });
+      expect(okRes.status).toBe(202);
+      const okJson = (await okRes.json()) as { jobId: string };
+      expect(okJson.jobId).toMatch(/^gen_/);
+
+      // The job shows up in the list.
+      const listRes = await fetch(`${base}/_api/generate-jobs`);
+      const listJson = (await listRes.json()) as { jobs: Array<{ id: string }> };
+      expect(listJson.jobs.some((j) => j.id === okJson.jobId)).toBe(true);
+
+      // Remove the key.
+      const delRes = await fetch(`${base}/_api/generate/keys`, {
+        method: 'DELETE',
+        headers: { 'content-type': 'text/plain' },
+        body: JSON.stringify({ provider: 'gemini' }),
+      });
+      expect(delRes.status).toBe(200);
+      const afterDel = (await (await fetch(`${base}/_api/generate/keys`)).json()) as {
+        configured: string[];
+      };
+      expect(afterDel.configured).not.toContain('gemini');
+    } finally {
+      await killProc(proc);
+    }
+  });
+});