@1agh/maude 0.41.0 → 0.43.0

package/apps/studio/test/exporters/jobs.test.ts

@@ -0,0 +1,263 @@
+// feature-background-export-notification-center — job queue concurrency,
+// history persistence under concurrency, and byte retrieval/eviction.
+
+import { describe, expect, test } from 'bun:test';
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { bootServer, killProc, makeSandbox, nextPort } from '../_helpers.ts';
+
+interface JobShape {
+  id: string;
+  status: 'queued' | 'running' | 'done' | 'failed';
+  createdAt: string;
+}
+
+async function listJobs(port: number): Promise<JobShape[]> {
+  const r = await fetch(`http://localhost:${port}/_api/export-jobs`);
+  const body = (await r.json()) as { jobs: JobShape[] };
+  return body.jobs;
+}
+
+/** A `project-raw` zip export takes real, measurable time when the sandbox is
+ * large enough (DEFLATE-compressing several MB) — no browser/Playwright
+ * needed, so this stays a fast, deterministic-enough integration test. */
+function seedLargeSandbox(designRoot: string, fileCount = 5000): void {
+  const dir = join(designRoot, 'ui', 'big');
+  mkdirSync(dir, { recursive: true });
+  for (let i = 0; i < fileCount; i += 1) {
+    writeFileSync(join(dir, `f${i}.txt`), randomBytes(2000).toString('base64'));
+  }
+}
+
+describe('exporters/jobs — concurrency gate', () => {
+  test('caps concurrent render-heavy jobs at MAUDE_EXPORT_MAX_CONCURRENT', async () => {
+    const { root, designRoot } = makeSandbox();
+    seedLargeSandbox(designRoot);
+    const port = nextPort();
+    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_CONCURRENT: '2' });
+    try {
+      const jobIds: string[] = [];
+      for (let i = 0; i < 3; i += 1) {
+        const r = await fetch(`http://localhost:${port}/_api/export-jobs`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
+        });
+        expect(r.status).toBe(202);
+        const { jobId } = (await r.json()) as { jobId: string };
+        jobIds.push(jobId);
+      }
+
+      let sawThirdQueued = false;
+      let maxRunningObserved = 0;
+      let allDone = false;
+      const deadline = Date.now() + 4000;
+      while (Date.now() < deadline && !allDone) {
+        const jobs = await listJobs(port);
+        const byId = new Map(jobs.map((j) => [j.id, j]));
+        const running = jobs.filter((j) => j.status === 'running').length;
+        maxRunningObserved = Math.max(maxRunningObserved, running);
+        if (byId.get(jobIds[2])?.status === 'queued') sawThirdQueued = true;
+        allDone = jobIds.every((id) => byId.get(id)?.status === 'done');
+        if (!allDone) await Bun.sleep(15);
+      }
+
+      expect(allDone).toBe(true);
+      // Never more than the configured cap ran at once.
+      expect(maxRunningObserved).toBeLessThanOrEqual(2);
+      // The 3rd job was genuinely gated behind the semaphore at some point,
+      // not just "coincidentally" always running — proves the queue, not just
+      // that everything happened to finish fast.
+      expect(sawThirdQueued).toBe(true);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});
+
+describe('exporters/jobs — pending-queue cap (security fan-out, /flow:done)', () => {
+  test('enqueue() 429s past MAUDE_EXPORT_MAX_QUEUED, then accepts more once jobs drain', async () => {
+    const { root, designRoot } = makeSandbox();
+    seedLargeSandbox(designRoot); // keeps jobs 'queued'/'running' long enough to observe
+    const port = nextPort();
+    const proc = await bootServer(root, port, {
+      MAUDE_EXPORT_MAX_CONCURRENT: '1',
+      MAUDE_EXPORT_MAX_QUEUED: '2',
+    });
+    try {
+      const post = () =>
+        fetch(`http://localhost:${port}/_api/export-jobs`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
+        });
+
+      const r1 = await post();
+      const r2 = await post();
+      expect(r1.status).toBe(202);
+      expect(r2.status).toBe(202);
+
+      // A 3rd job while the first 2 are still queued/running must be rejected
+      // with 429, not silently accepted (the DoS-protection cap).
+      const r3 = await post();
+      expect(r3.status).toBe(429);
+      const text = await r3.text();
+      expect(text.toLowerCase()).toContain('queue');
+
+      // Once jobs drain below the cap, enqueue works again — this is a
+      // capacity limit, not a permanent lockout.
+      let drained = false;
+      const deadline = Date.now() + 5000;
+      while (Date.now() < deadline && !drained) {
+        const jobs = await listJobs(port);
+        drained = jobs.every((j) => j.status === 'done' || j.status === 'failed');
+        if (!drained) await Bun.sleep(15);
+      }
+      expect(drained).toBe(true);
+      const r4 = await post();
+      expect(r4.status).toBe(202);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});
+
+describe('exporters/jobs — list() + history under concurrency', () => {
+  test('list() returns newest-first', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      // `canvas-as-separate` against an empty sandbox (`active: null`)
+      // resolves to zero targets → the adapter's empty-input branch, no
+      // Playwright spawn — fast + deterministic (mirrors endpoint.test.ts).
+      for (let i = 0; i < 3; i += 1) {
+        const r = await fetch(`http://localhost:${port}/_api/export-jobs`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ format: 'png', scope: 'canvas-as-separate' }),
+        });
+        expect(r.status).toBe(202);
+      }
+      // Give the fire-and-forget jobs a moment to land.
+      await Bun.sleep(200);
+      const jobs = await listJobs(port);
+      expect(jobs.length).toBeGreaterThanOrEqual(3);
+      const createdAts = jobs.map((j) => j.createdAt);
+      const sorted = [...createdAts].sort((a, b) => b.localeCompare(a));
+      expect(createdAts).toEqual(sorted);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('history ledger caps at 20 without dropping entries under concurrent completions', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    // MAUDE_EXPORT_MAX_QUEUED override — this test deliberately fires 25 jobs
+    // in one burst (the concurrent-completion race itself), well above the
+    // production default's DoS-protection cap; a real flood is hundreds of
+    // requests, not a legitimate test burst.
+    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_QUEUED: '30' });
+    try {
+      // Fire 25 jobs concurrently (not sequentially) — the exact race the old
+      // read-modify-write appendExportHistory had.
+      await Promise.all(
+        Array.from({ length: 25 }, () =>
+          fetch(`http://localhost:${port}/_api/export-jobs`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ format: 'png', scope: 'canvas-as-separate' }),
+          }).then((r) => expect(r.status).toBe(202))
+        )
+      );
+      // Poll until the ledger settles at the cap.
+      let historyLen = 0;
+      const deadline = Date.now() + 4000;
+      while (Date.now() < deadline && historyLen < 20) {
+        const r = await fetch(`http://localhost:${port}/_api/export-history`);
+        const body = (await r.json()) as { history: unknown[] };
+        historyLen = body.history.length;
+        if (historyLen < 20) await Bun.sleep(20);
+      }
+      expect(historyLen).toBe(20);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});
+
+describe('exporters/jobs — byte retrieval + eviction', () => {
+  test("a finished job's bytes are downloadable, then gone once evicted past the cap", async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    // MAUDE_EXPORT_MAX_QUEUED override — this test pushes 26 jobs through in
+    // one burst (deliberately, to force eviction), above the production
+    // default's DoS-protection cap.
+    const proc = await bootServer(root, port, { MAUDE_EXPORT_MAX_QUEUED: '30' });
+    try {
+      const enqueue = async () => {
+        const r = await fetch(`http://localhost:${port}/_api/export-jobs`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ format: 'zip', scope: 'project-raw' }),
+        });
+        expect(r.status).toBe(202);
+        const { jobId } = (await r.json()) as { jobId: string };
+        return jobId;
+      };
+
+      const firstId = await enqueue();
+      // Wait for it to finish.
+      let done = false;
+      const deadline = Date.now() + 3000;
+      while (Date.now() < deadline && !done) {
+        const jobs = await listJobs(port);
+        done = jobs.find((j) => j.id === firstId)?.status === 'done';
+        if (!done) await Bun.sleep(15);
+      }
+      expect(done).toBe(true);
+
+      const dl = await fetch(`http://localhost:${port}/_api/export-jobs/download?id=${firstId}`);
+      expect(dl.status).toBe(200);
+      expect(dl.headers.get('Content-Type')).toBe('application/zip');
+      const bytes = await dl.arrayBuffer();
+      expect(bytes.byteLength).toBeGreaterThan(0);
+
+      // 404 for an unknown id.
+      const missing = await fetch(`http://localhost:${port}/_api/export-jobs/download?id=nope`);
+      expect(missing.status).toBe(404);
+
+      // Push 25 more jobs through so the first one rolls past the 20-cap and
+      // gets evicted (bytes removed from disk + dropped from the in-memory
+      // map). Eviction runs on EVERY completion, so the oldest jobs drop out
+      // of list() entirely well before the last of the 25 finishes — poll for
+      // "nothing left pending" rather than tracking specific (possibly
+      // already-evicted) ids.
+      for (let i = 0; i < 25; i += 1) {
+        await enqueue();
+      }
+      let settled = false;
+      const deadline2 = Date.now() + 4000;
+      while (Date.now() < deadline2 && !settled) {
+        const jobs = await listJobs(port);
+        settled = jobs.every((j) => j.status === 'done' || j.status === 'failed');
+        if (!settled) await Bun.sleep(15);
+      }
+      expect(settled).toBe(true);
+
+      const r = await fetch(`http://localhost:${port}/_api/export-history`);
+      const body = (await r.json()) as { history: unknown[] };
+      expect(body.history.length).toBe(20);
+
+      const evicted = await fetch(
+        `http://localhost:${port}/_api/export-jobs/download?id=${firstId}`
+      );
+      expect(evicted.status).toBe(404);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});

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/git-branches.test.ts

@@ -14,6 +14,8 @@ import {
   gitFetchRemote,
   gitFoldDraft,
   gitListBranches,
+  gitPull,
+  gitPush,
   remoteAheadBehind,
 } from '../git/service.ts';
 
@@ -111,6 +113,30 @@ test('fold: merges the draft into the Shared version locally; a tokenless publis
   expect((await gitListBranches(dir)).some((b) => b.name === 'nav')).toBe(true);
 });
 
+test('fold: a GitHub remote takes the PR path — pushes the draft, never locally merges main (DDR-162)', async () => {
+  // isGitHubRemote(github.com) → PR flow: publish the DRAFT branch (fails here — no
+  // real access) and NEVER merge/modify the local Shared version. `false` as the ssh
+  // command fails the transport instantly, so there's no network to github.com.
+  const prevSsh = process.env.GIT_SSH_COMMAND;
+  process.env.GIT_SSH_COMMAND = 'false';
+  const shared = (await gitListBranches(dir)).find((b) => b.current)?.name as string;
+  sh(['remote', 'add', 'origin', 'git@github.com:fake-org/fake-repo.git']);
+  await gitCreateBranch(dir, 'nav'); // now on 'nav'
+  writeFileSync(join(dir, 'b.txt'), 'draft work\n');
+  sh(['add', '.']);
+  sh(['commit', '-q', '-m', 'draft work']);
+  const r = await gitFoldDraft(dir, 'nav', undefined, {});
+  process.env.GIT_SSH_COMMAND = prevSsh ?? '';
+  // The draft push failed (fake repo) → not ok, and NOT the iso transport error…
+  expect(r.ok).toBe(false);
+  expect(r.error || '').not.toMatch(/unrecognized transport/i);
+  // …but crucially the Shared version was NEVER locally merged/modified…
+  sh(['checkout', shared]);
+  expect(existsSync(join(dir, 'b.txt'))).toBe(false);
+  // …and the draft still exists (nothing destroyed on a failed publish).
+  expect((await gitListBranches(dir)).some((b) => b.name === 'nav')).toBe(true);
+});
+
 // ── remote drafts (phase: surface remote branches) ───────────────────────────
 
 /** Stand up a bare "remote" with main + a teammate draft, clone it locally (system
@@ -197,6 +223,77 @@ test('an ssh remote routes to system git, never the iso transport error', async
   expect(r.error || '').not.toMatch(/unrecognized transport/i); // didn't fall into iso
 });
 
+// ── publish / get-latest over ssh (DDR-131/DDR-133 parity — the gap that shipped) ──
+// gitFetchRemote was hardened for ssh; gitPush/gitPull historically routed on the
+// USE_SYSTEM_GIT env flag only (default off) and fell into iso → "unrecognized
+// transport protocol: ssh". These prove the write paths now take the same gate.
+
+test('gitPush: an ssh remote routes to system git, never the iso transport error', async () => {
+  process.env.GIT_SSH_COMMAND =
+    'ssh -o BatchMode=yes -o ConnectTimeout=2 -o StrictHostKeyChecking=no';
+  sh(['remote', 'add', 'origin', 'git@nonexistent.invalid:team/app.git']);
+  const r = await gitPush(dir, undefined, {});
+  process.env.GIT_SSH_COMMAND = '';
+  expect(r.ok).toBe(false);
+  expect(r.authRequired).toBeFalsy(); // an ssh failure is not a GitHub sign-in prompt
+  expect(r.error || '').not.toMatch(/unrecognized transport/i); // didn't fall into iso
+});
+
+test('gitPull: an ssh remote routes to system git, never the iso transport error', async () => {
+  process.env.GIT_SSH_COMMAND =
+    'ssh -o BatchMode=yes -o ConnectTimeout=2 -o StrictHostKeyChecking=no';
+  sh(['remote', 'add', 'origin', 'git@nonexistent.invalid:team/app.git']);
+  const r = await gitPull(dir, undefined, {});
+  process.env.GIT_SSH_COMMAND = '';
+  expect(r.ok).toBe(false);
+  expect(r.authRequired).toBeFalsy();
+  expect(r.error || '').not.toMatch(/unrecognized transport/i);
+});
+
+test('SECURITY: gitPush refuses an unsafe (ext::) remote — no spawn, no RCE', async () => {
+  // A poisoned .git/config remote — must be refused BEFORE any git spawn (the payload
+  // never runs); classifyRemoteUrl reads the url via iso getConfig, not the git binary.
+  const sentinel = join(dir, 'PWNED_PUSH');
+  sh(['remote', 'add', 'origin', `ext::sh -c "touch ${sentinel}"`]);
+  const r = await gitPush(dir, 'tok_should_not_be_used', {});
+  expect(r.ok).toBe(false);
+  expect(r.error).toMatch(/github\.com/i); // "can only sync github.com…"
+  expect(existsSync(sentinel)).toBe(false); // payload NEVER executed
+});
+
+test('SECURITY: gitPush does not send the GitHub token to a non-GitHub HTTPS host', async () => {
+  sh(['remote', 'add', 'origin', 'https://evil.example.com/repo.git']);
+  const r = await gitPush(dir, 'tok_secret', {});
+  expect(r.ok).toBe(false);
+  expect(r.error).toMatch(/github\.com/i); // refused by policy, token never attached
+});
+
+test('SECURITY: a backslash-@ host-confusion remote is refused, PAT never attached (F1)', async () => {
+  // `https://github.com\@evil` — new URL() parses host=github.com (backslash → '/'),
+  // but git/curl dials `evil` (backslash = path/userinfo char). The token-host allowlist
+  // must reject the parser differential and NOT lend the PAT — on every token path:
+  // explicit fetch, the unattended ahead/behind probe (the zero-click trigger), and push.
+  sh(['remote', 'add', 'origin', 'https://github.com\\@evil.example/x.git']);
+  const f = await gitFetchRemote(dir, 'tok_secret');
+  expect(f.ok).toBe(false);
+  expect(f.error).toMatch(/github\.com/i); // refused by policy — token never attached
+  const ab = await remoteAheadBehind(dir, 'tok_secret');
+  expect(ab).toEqual({ ahead: 0, behind: 0 }); // the unattended probe refuses too (0/0, no fetch)
+  const p = await gitPush(dir, 'tok_secret', {});
+  expect(p.ok).toBe(false);
+  expect(p.error).toMatch(/github\.com/i);
+});
+
+test('SECURITY: the unattended probe refuses a repo with a url.insteadOf rewrite (verify re-review)', async () => {
+  // A clean github `origin.url` (passes isTrustedTokenHost) + a poisoned
+  // `url.<attacker>.insteadOf` that redirects github.com → attacker (only the system
+  // engine honors it). git would dial the attacker; the zero-click probe must refuse.
+  sh(['remote', 'add', 'origin', 'https://github.com/owner/repo.git']);
+  sh(['config', '--local', 'url.https://attacker.example/.insteadOf', 'https://github.com/']);
+  const ab = await remoteAheadBehind(dir, 'tok_secret');
+  expect(ab).toEqual({ ahead: 0, behind: 0 });
+});
+
 // ── transport-injection hardening (adversarial review of 75a2f0d) ────────────
 
 test('SECURITY: refuses to fetch an `ext::` (command-executing) remote — no spawn, no RCE', async () => {

package/apps/studio/test/github-api.test.ts

@@ -18,6 +18,7 @@ import git from 'isomorphic-git';
 import type { Context } from '../context.ts';
 import { createGitHubEndpoints, __testing as epTesting } from '../github/endpoints.ts';
 import {
+  createPullRequest,
   createRepo,
   GitHubApiError,
   getIdentity,
@@ -98,6 +99,59 @@ describe('GitHub REST request construction', () => {
     expect((err as GitHubApiError).message).toMatch(/already have a project with that name/i);
   });
 
+  test('createPullRequest POSTs title/head/base/body and shapes the result', async () => {
+    const calls = stubFetch(() =>
+      json({ number: 12, html_url: 'https://github.com/octocat/acme/pull/12' }, 201)
+    );
+    const pr = await createPullRequest('t', 'octocat', 'acme', {
+      head: 'nav-redesign',
+      base: 'main',
+      title: 'Add draft',
+      body: 'hi',
+    });
+    expect(pr).toEqual({ number: 12, html_url: 'https://github.com/octocat/acme/pull/12' });
+    expect(calls[0].url).toBe('https://api.github.com/repos/octocat/acme/pulls');
+    expect(calls[0].init?.method).toBe('POST');
+    expect(JSON.parse(calls[0].init?.body as string)).toEqual({
+      title: 'Add draft',
+      head: 'nav-redesign',
+      base: 'main',
+      body: 'hi',
+    });
+  });
+
+  test('createPullRequest recovers the existing PR link on a 422 (already exists)', async () => {
+    const calls = stubFetch((_url, init) =>
+      init?.method === 'POST'
+        ? json({ message: 'A pull request already exists for octocat:nav.' }, 422)
+        : json([{ number: 7, html_url: 'https://github.com/octocat/acme/pull/7' }])
+    );
+    const pr = await createPullRequest('t', 'octocat', 'acme', {
+      head: 'nav',
+      base: 'main',
+      title: 'x',
+    });
+    expect(pr).toEqual({ number: 7, html_url: 'https://github.com/octocat/acme/pull/7' });
+    // the recovery GET filters by head=owner:branch + base + state=open
+    expect(calls[1].url).toContain('head=octocat%3Anav');
+    expect(calls[1].url).toContain('base=main');
+    expect(calls[1].url).toContain('state=open');
+  });
+
+  test('createPullRequest maps a 422 with no existing PR to a "nothing new" message', async () => {
+    stubFetch((_url, init) =>
+      init?.method === 'POST' ? json({ message: 'No commits between main and nav' }, 422) : json([])
+    );
+    const err = await createPullRequest('t', 'octocat', 'acme', {
+      head: 'nav',
+      base: 'main',
+      title: 'x',
+    }).catch((e) => e);
+    expect(err).toBeInstanceOf(GitHubApiError);
+    expect((err as GitHubApiError).status).toBe(422);
+    expect((err as GitHubApiError).message).toMatch(/nothing new to add/i);
+  });
+
   test('inviteCollaborator PUTs permission=push, 201 = invited', async () => {
     const calls = stubFetch(() => json({ id: 1 }, 201));
     const r = await inviteCollaborator('t', 'octocat', 'acme', 'anna');
@@ -242,7 +296,8 @@ describe('token bridge fetch', () => {
     const calls = stubFetch(() => new Response('gho_secret\n', { status: 200 }));
     expect(tokenBridgeAvailable()).toBe(true);
     expect(await getGithubToken()).toBe('gho_secret');
-    expect((calls[0].init?.headers as Record<string, string>)['X-Maude-Token-Key']).toBe('k123');
+    const headers = calls[0].init?.headers as Record<string, string>;
+    expect(headers['X-Maude-Token-Key']).toBe('k123');
   });
 
   test('returns null on 404 (not signed in) and 403 (bad key)', async () => {

package/apps/studio/test/input-router.test.ts

@@ -348,6 +348,39 @@ describe('input-router / isEditableTarget', () => {
     const el = { tagName: 'DIV', isContentEditable: true } as HTMLElement;
     expect(isEditableTarget(el)).toBe(true);
   });
+
+  // Dogfood fix — the reported bug: typing "R" while editing in-canvas
+  // element text (canvas-shell.tsx's contenteditable="plaintext-only") fired
+  // the Rectangle tool shortcut. `.isContentEditable` SHOULD reflect
+  // "plaintext-only" per spec, but engine/version inconsistencies mean it
+  // can't be the only check — these lock in the raw-attribute fallback that
+  // now makes isEditableTarget resilient regardless.
+  test('contenteditable="plaintext-only" (isContentEditable false or unreliable) → true', () => {
+    const el = {
+      tagName: 'DIV',
+      isContentEditable: false,
+      getAttribute: (name: string) => (name === 'contenteditable' ? 'plaintext-only' : null),
+    } as unknown as HTMLElement;
+    expect(isEditableTarget(el)).toBe(true);
+  });
+
+  test('bare contenteditable="" attribute → true', () => {
+    const el = {
+      tagName: 'DIV',
+      isContentEditable: false,
+      getAttribute: (name: string) => (name === 'contenteditable' ? '' : null),
+    } as unknown as HTMLElement;
+    expect(isEditableTarget(el)).toBe(true);
+  });
+
+  test('plain div WITH a getAttribute method (real-element shape) still → false', () => {
+    const el = {
+      tagName: 'DIV',
+      isContentEditable: false,
+      getAttribute: () => null,
+    } as unknown as HTMLElement;
+    expect(isEditableTarget(el)).toBe(false);
+  });
 });
 
 // T25 — Drag-vs-click threshold. Centralized here so every drag-class gesture

package/apps/studio/test/inspect-script-syntax.test.ts

@@ -0,0 +1,53 @@
+// inspect-script-syntax.test.ts — regression guard for a real bug hit while
+// adding the photo-editor's background-removal busy shimmer: INSPECTOR_SCRIPT
+// (inspect.ts) is itself a giant template literal, so a stray backtick in an
+// inline comment silently truncates/reopens it — tsc DOES catch backtick
+// imbalance (it breaks the outer .ts file's own syntax), but nothing catches
+// any OTHER malformed-JS mistake inside the injected string (e.g. a stray
+// unescaped quote, mismatched braces in the CSS array). This test extracts the
+// actual injected <script> body and syntax-checks it directly.
+
+import { describe, expect, test } from 'bun:test';
+import { join } from 'node:path';
+
+import { type Context, createBus } from '../context.ts';
+import { createInspect } from '../inspect.ts';
+import { makeSandbox } from './_helpers.ts';
+
+function mkCtx(root: string, designRoot: string): Context {
+  return {
+    cfg: {} as Context['cfg'],
+    projectLabel: 'test',
+    bus: createBus(),
+    paths: {
+      repoRoot: root,
+      designRel: '.design',
+      designRoot,
+      serverInfoFile: join(designRoot, '_server.json'),
+      activeFile: join(designRoot, '_active.json'),
+      commentsDir: join(designRoot, '_comments'),
+      canvasStateDir: join(designRoot, '_canvas-state'),
+      historyDir: join(designRoot, '_history'),
+      tokensUrlRel: '',
+      systemDirRel: 'system',
+    },
+  };
+}
+
+describe('injectInspector — injected <script> is syntactically valid JS', () => {
+  test('the extracted script body compiles with no SyntaxError', () => {
+    const { root, designRoot } = makeSandbox();
+    const inspect = createInspect(mkCtx(root, designRoot), async () => []);
+    const out = inspect.injectInspector('<html><body></body></html>');
+
+    const scripts = [...out.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1]);
+    expect(scripts.length).toBeGreaterThan(0);
+
+    for (const body of scripts) {
+      // `new Function` only PARSES the body (no window/document access at
+      // construction time) — throws SyntaxError on malformed JS, exactly the
+      // class of bug a stray backtick / unbalanced brace produces.
+      expect(() => new Function(body)).not.toThrow();
+    }
+  });
+});