@1agh/maude 0.23.0 → 0.25.0

package/plugins/design/dev-server/test/canvas-origin-gate.test.ts

@@ -0,0 +1,76 @@
+// Canvas-origin route gate — A1/A2 (DDR-060 F1 re-audit). Boots a real server
+// with MAUDE_CANVAS_ORIGIN_SPLIT=1 and probes the segregated canvas origin to
+// prove: (1) the %2f-encoded path-traversal that previously leaked repo files
+// outside designRoot is now 403'd; (2) privileged routes stay 403; (3) legit
+// designRoot assets + the shell still serve; (4) the shell carries the hardened
+// CSP. See .ai/logs/security-reviews/phase-9.1-t2-f1-cross-origin-reaudit.md.
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
+
+async function readCanvasOrigin(designRoot: string): Promise<string> {
+  // server.ts writes _server.json under the designRoot once both listeners bind.
+  for (let i = 0; i < 40; i++) {
+    try {
+      const info = JSON.parse(readFileSync(join(designRoot, '_server.json'), 'utf8'));
+      if (info.canvasOrigin) return info.canvasOrigin as string;
+    } catch {
+      /* not written yet */
+    }
+    await Bun.sleep(50);
+  }
+  throw new Error('canvasOrigin never appeared in _server.json');
+}
+
+describe('canvas-origin gate — A1/A2 traversal + privilege containment', () => {
+  test('%2f traversal out of designRoot is 403; privileged 403; legit 200; CSP hardened', async () => {
+    const { root, designRoot } = makeSandbox();
+    // A real asset OUTSIDE .design/ but INSIDE repoRoot — the traversal target.
+    writeFileSync(join(root, 'secret-outside.css'), '.leak{content:"SECRET"}');
+    // A legit canvas asset under designRoot (the allowed case).
+    mkdirSync(join(designRoot, 'ui'), { recursive: true });
+    writeFileSync(
+      join(designRoot, 'ui', 'Gate.tsx'),
+      'export default function G(){return <main/>}\n'
+    );
+
+    const port = nextPort();
+    const proc = await bootServer(root, port, { MAUDE_CANVAS_ORIGIN_SPLIT: '1' });
+    try {
+      const canvas = await readCanvasOrigin(designRoot);
+      const code = async (p: string) =>
+        (await fetch(canvas + p, { signal: AbortSignal.timeout(2000) })).status;
+
+      // (1) The confirmed bypass — must now be 403, not 200.
+      expect(await code('/.design/..%2fsecret-outside.css')).toBe(403);
+      expect(await code('/.design/ui/..%2f..%2fsecret-outside.css')).toBe(403);
+      // Double-encoded + mixed-case variants stay closed.
+      expect(await code('/.design/%2e%2e%2fsecret-outside.css')).toBe(403);
+
+      // (2) Privileged / out-of-scope routes stay 403 on the canvas origin.
+      for (const p of ['/_config', '/_sync-status', '/_api/export', '/package.json']) {
+        expect(await code(p)).toBe(403);
+      }
+
+      // (3) Legit surfaces still serve.
+      expect(await code('/_health')).toBe(200);
+      expect(await code('/_canvas-shell.html')).toBe(200);
+      // A real .tsx canvas under designRoot transpiles + serves (200).
+      expect(await code('/.design/ui/Gate.tsx')).toBe(200);
+
+      // (4) The shell carries the hardened CSP (A6).
+      const shell = await fetch(`${canvas}/_canvas-shell.html`);
+      const csp = shell.headers.get('content-security-policy') ?? '';
+      expect(csp).toContain("connect-src 'self'");
+      expect(csp).toContain("webrtc 'block'");
+      expect(csp).toContain('frame-ancestors');
+      expect(csp).toContain(`http://localhost:${port}`);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});

package/plugins/design/dev-server/test/canvas-route.test.ts

@@ -80,7 +80,10 @@ describe('TSX canvas route', () => {
       expect(r.headers.get('content-type')).toMatch(/javascript/);
       const etag = r.headers.get('etag');
       expect(etag).toBeTruthy();
-      expect(etag).toMatch(/^[0-9a-f]+$/i);
+      // Phase 24 (DDR-067) — the canvas etag is `<source-hash>-<bootId>-<epoch>`:
+      // the boot id + chrome epoch are folded in so a chrome edit (which doesn't
+      // change the canvas source hash) still busts the browser's cached transpile.
+      expect(etag).toMatch(/^[0-9a-f]+-[a-z0-9]+-\d+$/i);
       const body = await r.text();
       // Body should contain data-cd-id metadata + an export — proves the two
       // passes ran end to end.

package/plugins/design/dev-server/test/collab-reseed-guard.test.ts

@@ -0,0 +1,78 @@
+// Gap 1 (file-sync clobber fix) — the syncRoomFrom* no-op guards.
+//
+// createCollab now re-seeds a live room from disk whenever a synced file
+// changes externally (sync-agent hub-push or `design:edit` write), so the
+// room stops clobbering the external change back. That re-seed reuses
+// syncRoomFromComments/syncRoomFromAnnotations, which ALSO run on the room's
+// own persist → file → fs-event path. Without an equality short-circuit that
+// would spin an 800ms persist storm. These tests pin the guard: an identical
+// re-seed emits NO doc update (→ no persist → no loop); a real change emits one.
+
+import { describe, expect, test } from 'bun:test';
+
+import { Y_TYPES } from '../collab/persistence.ts';
+import { createRegistry } from '../collab/registry.ts';
+import type { RoomCallbacks } from '../collab/room.ts';
+
+function noopCallbacks(): RoomCallbacks {
+  return {
+    async seed() {},
+    async persistJson() {},
+    async persistBinary() {},
+  };
+}
+
+describe('Gap 1 — syncRoomFromComments no-op guard', () => {
+  test('re-seeding identical comments emits NO doc update (loop-safe)', () => {
+    const r = createRegistry(noopCallbacks());
+    const room = r.get('s');
+    const list = [{ id: 'c1', text: 'hi' }];
+    r.syncRoomFromComments('s', list);
+
+    let updates = 0;
+    room.doc.on('update', () => {
+      updates++;
+    });
+    // Identical content (the room's-own-persist echo, or a redundant hub push)
+    // → must not emit, or the reseed↔persist loop never settles.
+    r.syncRoomFromComments('s', [{ id: 'c1', text: 'hi' }]);
+    expect(updates).toBe(0);
+
+    // A genuine change still propagates — exactly one update.
+    r.syncRoomFromComments('s', [
+      { id: 'c1', text: 'hi' },
+      { id: 'c2', text: 'yo' },
+    ]);
+    expect(updates).toBe(1);
+  });
+
+  test('re-seed brings a STALE room up to the on-disk list (the clobber fix)', () => {
+    const r = createRegistry(noopCallbacks());
+    const room = r.get('s');
+    const arr = room.doc.getArray(Y_TYPES.comments);
+    expect(arr.length).toBe(0); // room opened empty (the "B shows []" state)
+
+    // Sync agent wrote a hub-pushed comment to disk → createCollab re-seeds:
+    r.syncRoomFromComments('s', [{ id: 'c1', text: 'from peer A' }]);
+    expect(arr.toArray()).toEqual([{ id: 'c1', text: 'from peer A' }]);
+  });
+});
+
+describe('Gap 1 — syncRoomFromAnnotations no-op guard', () => {
+  test('re-seeding the identical svg emits NO doc update', () => {
+    const r = createRegistry(noopCallbacks());
+    const room = r.get('s');
+    const svg = '<svg xmlns="http://www.w3.org/2000/svg"><g/></svg>';
+    r.syncRoomFromAnnotations('s', svg);
+
+    let updates = 0;
+    room.doc.on('update', () => {
+      updates++;
+    });
+    r.syncRoomFromAnnotations('s', svg); // identical → no-op
+    expect(updates).toBe(0);
+
+    r.syncRoomFromAnnotations('s', '<svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>');
+    expect(updates).toBe(1);
+  });
+});

package/plugins/design/dev-server/test/collab-room.test.ts

@@ -3,9 +3,15 @@
 
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
 
+import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
 
-import { encodeHandshake, encodeSyncUpdate, handleMessage } from '../collab/protocol.ts';
+import {
+  encodeAwarenessFrame,
+  encodeHandshake,
+  encodeSyncUpdate,
+  handleMessage,
+} from '../collab/protocol.ts';
 import { type RoomCallbacks, type RoomConn, createRoom } from '../collab/room.ts';
 
 function makeConn(id: string): RoomConn & { recv: Uint8Array[] } {
@@ -140,24 +146,29 @@ describe('Room', () => {
     await room.destroy();
   });
 
-  test('disconnect cleans up awareness states tagged with __connId', async () => {
+  test('disconnect removes the awareness states a conn published', async () => {
     const cb = makeCallbacks();
     const room = createRoom('aw-cleanup-slug', cb);
     const A = makeConn('a');
     await room.connect(A);
 
-    // Simulate Alice publishing her awareness state with the matching __connId.
-    room.awareness.setLocalState({ name: 'Alice', __connId: 'a' });
-    expect(room.awareness.getStates().size).toBe(1);
+    // Alice (conn A) publishes her awareness over the wire — the server learns
+    // her clientID belongs to conn 'a' from the update origin (server-authoritative;
+    // it does NOT trust a client-supplied __connId). Mirrors the real receive path.
+    const clientDoc = new Y.Doc();
+    const clientAw = new Awareness(clientDoc);
+    clientAw.setLocalState({ name: 'Alice' });
+    room.receive(A, encodeAwarenessFrame(clientAw, [clientAw.clientID]));
+    expect(room.awareness.getStates().has(clientAw.clientID)).toBe(true);
 
     room.disconnect(A);
     expect(room.size()).toBe(0);
-    // Awareness state owned by the disconnected conn is gone.
-    const states = room.awareness.getStates();
-    for (const s of states.values()) {
-      expect((s as { __connId?: string }).__connId).not.toBe('a');
-    }
+    // The disconnected conn's awareness state is dropped immediately — no waiting
+    // out the ~30s awareness timeout (the phantom-accumulation bug).
+    expect(room.awareness.getStates().has(clientAw.clientID)).toBe(false);
 
+    clientAw.destroy();
+    clientDoc.destroy();
     await room.destroy();
   });
 

package/plugins/design/dev-server/test/csp-canvas-shell.test.ts

@@ -0,0 +1,46 @@
+// cspForCanvasShell — A6 (DDR-060 F1 re-audit) CSP hardening for the segregated
+// canvas origin. Asserts the exfil-relevant directives are present and that
+// `frame-ancestors` is only emitted when the main origin is known (so the legit
+// cross-origin embed is never accidentally blocked).
+
+import { describe, expect, test } from 'bun:test';
+
+import { cspForCanvasShell } from '../http.ts';
+
+const SHELL = '<!doctype html><html><head><script>const x=1;</script></head><body></body></html>';
+
+describe('cspForCanvasShell — A6 hardening', () => {
+  test('locks down the dangerous lanes', () => {
+    const csp = cspForCanvasShell(SHELL);
+    expect(csp).toContain("default-src 'none'");
+    expect(csp).toContain("connect-src 'self'");
+    expect(csp).toContain("object-src 'none'");
+    expect(csp).toContain("base-uri 'none'");
+    // No eval / no inline-script escape hatch.
+    expect(csp).not.toContain('unsafe-eval');
+    expect(csp).not.toMatch(/script-src[^;]*unsafe-inline/);
+  });
+
+  test("adds webrtc 'block' (connect-src does not cover WebRTC exfil)", () => {
+    expect(cspForCanvasShell(SHELL)).toContain("webrtc 'block'");
+  });
+
+  test("adds form-action 'none'", () => {
+    expect(cspForCanvasShell(SHELL)).toContain("form-action 'none'");
+  });
+
+  test('hashes inline scripts (no unsafe-inline for script-src)', () => {
+    const csp = cspForCanvasShell(SHELL);
+    expect(csp).toMatch(/script-src 'self' 'sha256-[A-Za-z0-9+/=]+'/);
+  });
+
+  test('frame-ancestors allowlists the main origin when known', () => {
+    const csp = cspForCanvasShell(SHELL, 'http://localhost:4399');
+    expect(csp).toContain("frame-ancestors 'self' http://localhost:4399");
+  });
+
+  test('frame-ancestors is OMITTED when the main origin is unknown (would block the legit embed)', () => {
+    const csp = cspForCanvasShell(SHELL);
+    expect(csp).not.toContain('frame-ancestors');
+  });
+});

package/plugins/design/dev-server/test/exporters/png.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { run } from '../../exporters/png.ts';
+import { clampScale, run } from '../../exporters/png.ts';
 
 const CTX = {
   designRoot: '/tmp/.design',
@@ -30,3 +30,26 @@ describe('png adapter — contract', () => {
     );
   });
 });
+
+describe('png clampScale — size presets (item 1)', () => {
+  test('defaults to 2× when scale is absent / invalid', () => {
+    expect(clampScale(undefined)).toBe(2);
+    expect(clampScale(null)).toBe(2);
+    expect(clampScale('nonsense')).toBe(2);
+    expect(clampScale(0)).toBe(2);
+  });
+
+  test('honours the 1×/2×/3× presets (number or string)', () => {
+    expect(clampScale(1)).toBe(1);
+    expect(clampScale(2)).toBe(2);
+    expect(clampScale(3)).toBe(3);
+    expect(clampScale('1')).toBe(1);
+    expect(clampScale('3')).toBe(3);
+  });
+
+  test('clamps out-of-range / fractional values to the preset set', () => {
+    expect(clampScale(4)).toBe(2); // above max → safe default
+    expect(clampScale(2.6)).toBe(3); // rounds to nearest preset
+    expect(clampScale(1.2)).toBe(1);
+  });
+});

package/plugins/design/dev-server/test/exporters/pptx-deck.test.ts

@@ -0,0 +1,112 @@
+// PPTX adapter — native (svg2pptx) pipeline units (export-pipeline-fixes item 6).
+//
+// Covers the two pure pieces that make svg2pptx faithful + the deck merge:
+//   - preprocessSvg: lift tspan x/y onto <text> + collapse the font stack.
+//   - mergeDecks: combine N single-slide svg2pptx decks into one valid package.
+// The svg2pptx conversion itself (Python) + live render are integration-shape.
+
+import { describe, expect, test } from 'bun:test';
+import JSZip from 'jszip';
+
+import { mergeDecks, preprocessSvg } from '../../exporters/pptx.ts';
+
+describe('preprocessSvg', () => {
+  test('lifts the first tspan x/y onto a <text> that lacks them', () => {
+    const svg = `<svg><text fill="rgb(0,0,0)"><tspan x="33" y="65.5">Hi</tspan></text></svg>`;
+    const out = preprocessSvg(svg);
+    // svg2pptx reads text@x/y — they must now be present (was the 0,0 pile-up).
+    expect(out).toMatch(/<text x="33" y="65\.5"/);
+  });
+
+  test('collapses a CSS font-family stack to its first concrete name', () => {
+    const svg = `<text font-family="&quot;Berkeley Mono&quot;, TX-02, &quot;JetBrains Mono&quot;, monospace"><tspan x="1" y="2">x</tspan></text>`;
+    const out = preprocessSvg(svg);
+    // A PPTX typeface is a single font name, not a fallback list.
+    expect(out).toContain('font-family="Berkeley Mono"');
+    expect(out).not.toContain('TX-02');
+  });
+
+  test('does not clobber a <text> that already has its own x/y', () => {
+    const svg = `<text x="10" y="20"><tspan x="99" y="88">x</tspan></text>`;
+    const out = preprocessSvg(svg);
+    expect(out).toContain('<text x="10" y="20"');
+    expect(out).not.toContain('<text x="99"');
+  });
+});
+
+const REL_NS = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const OD_REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const CT_NS = 'http://schemas.openxmlformats.org/package/2006/content-types';
+const SLIDE_CT = 'application/vnd.openxmlformats-officedocument.presentationml.slide+xml';
+
+/** Minimal single-slide deck shaped like svg2pptx output (native, no media). */
+async function singleSlideDeck(): Promise<Uint8Array> {
+  const zip = new JSZip();
+  zip.file(
+    '[Content_Types].xml',
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="${CT_NS}"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/ppt/presentation.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"/><Override PartName="/ppt/slideMasters/slideMaster1.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml"/><Override PartName="/ppt/slides/slide1.xml" ContentType="${SLIDE_CT}"/></Types>`
+  );
+  zip.file(
+    'ppt/presentation.xml',
+    '<?xml version="1.0"?><p:presentation xmlns:p="x" xmlns:r="y"><p:sldMasterIdLst><p:sldMasterId id="1" r:id="rId1"/></p:sldMasterIdLst><p:sldIdLst><p:sldId id="256" r:id="rId2"/></p:sldIdLst></p:presentation>'
+  );
+  zip.file(
+    'ppt/_rels/presentation.xml.rels',
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${REL_NS}"><Relationship Id="rId1" Type="${OD_REL}/slideMaster" Target="slideMasters/slideMaster1.xml"/><Relationship Id="rId2" Type="${OD_REL}/slide" Target="slides/slide1.xml"/></Relationships>`
+  );
+  zip.file('ppt/slides/slide1.xml', '<?xml version="1.0"?><p:sld xmlns:p="x"/>');
+  zip.file(
+    'ppt/slides/_rels/slide1.xml.rels',
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${REL_NS}"><Relationship Id="rId1" Type="${OD_REL}/slideLayout" Target="../slideLayouts/slideLayout1.xml"/></Relationships>`
+  );
+  zip.file('ppt/slideMasters/slideMaster1.xml', '<?xml version="1.0"?><p:sldMaster xmlns:p="x"/>');
+  zip.file('ppt/slideLayouts/slideLayout1.xml', '<?xml version="1.0"?><p:sldLayout xmlns:p="x"/>');
+  return zip.generateAsync({ type: 'uint8array' });
+}
+
+describe('mergeDecks — combine svg2pptx single-slide decks', () => {
+  test('single deck passes through', async () => {
+    const d = await singleSlideDeck();
+    const merged = await mergeDecks([d]);
+    expect(merged.byteLength).toBe(d.byteLength);
+  });
+
+  test('three decks → one valid package, all refs + Content-Types resolve', async () => {
+    const decks = await Promise.all([singleSlideDeck(), singleSlideDeck(), singleSlideDeck()]);
+    const merged = await mergeDecks(decks);
+    const zip = await JSZip.loadAsync(merged);
+    const parts = new Set(Object.keys(zip.files).filter((n) => !n.endsWith('/')));
+
+    // 3 contiguous slides; no 4th.
+    for (const n of [1, 2, 3]) expect(parts.has(`ppt/slides/slide${n}.xml`)).toBe(true);
+    expect(parts.has('ppt/slides/slide4.xml')).toBe(false);
+
+    // presentation.xml lists 3 slides; its rels keep the slideMaster (the
+    // "unopenable" regression) + carry 3 slide rels.
+    const pres = (await zip.file('ppt/presentation.xml')?.async('string')) ?? '';
+    expect((pres.match(/<p:sldId /g) ?? []).length).toBe(3);
+    const prels = (await zip.file('ppt/_rels/presentation.xml.rels')?.async('string')) ?? '';
+    expect(prels).toContain('Target="slideMasters/slideMaster1.xml"');
+    expect((prels.match(/Type="[^"]*\/relationships\/slide"/g) ?? []).length).toBe(3);
+
+    // Every rels Target resolves.
+    for (const rf of [...parts].filter((p) => p.endsWith('.rels'))) {
+      const xml = (await zip.file(rf)?.async('string')) ?? '';
+      const baseDir = rf.replace(/_rels\/[^/]+$/, '');
+      for (const rel of xml.matchAll(/<Relationship\b[^>]*\/>/g)) {
+        if (/TargetMode="External"/.test(rel[0])) continue;
+        const tgt = /Target="([^"]+)"/.exec(rel[0])?.[1];
+        if (!tgt) continue;
+        const resolved = new URL(tgt, `file:///${baseDir}`).pathname.replace(/^\//, '');
+        expect(parts.has(resolved)).toBe(true);
+      }
+    }
+
+    // Every Content-Types Override resolves; exactly 3 slide overrides.
+    const ct = (await zip.file('[Content_Types].xml')?.async('string')) ?? '';
+    for (const o of ct.matchAll(/<Override\s+PartName="([^"]+)"/g)) {
+      expect(parts.has(o[1].replace(/^\//, ''))).toBe(true);
+    }
+    expect((ct.match(/PartName="\/ppt\/slides\/slide\d+\.xml"/g) ?? []).length).toBe(3);
+  });
+});

package/plugins/design/dev-server/test/exporters/pw-launch.test.ts

@@ -0,0 +1,49 @@
+// Unit cover for the shared Chromium launcher's error mapping. The launch path
+// itself is integration-shape (needs a real browser); here we pin the pure
+// classifier + the user-facing contract so a regression can't silently turn the
+// "browser not installed" 500 back into an opaque stack trace.
+//
+// Regression guard for `.ai/logs/rca/issue-nefunguji-exporty.md`.
+
+import { describe, expect, test } from 'bun:test';
+
+import { INSTALL_HINT, NO_BROWSER_EXIT, isMissingBrowserError } from '../../bin/_pw-launch.mjs';
+
+describe('_pw-launch — missing-browser classifier', () => {
+  test('matches the real Playwright "Executable doesn\'t exist" message', () => {
+    const real =
+      "browserType.launch: Executable doesn't exist at " +
+      '/Users/x/Library/Caches/ms-playwright/chromium_headless_shell-1223/' +
+      'chrome-headless-shell-mac-arm64/chrome-headless-shell\n' +
+      '╔════════════════════════════════════════════════════════════╗';
+    expect(isMissingBrowserError(real)).toBe(true);
+  });
+
+  test('matches the "please run … to download" + "playwright install" variants', () => {
+    expect(isMissingBrowserError('Please run the following command to download new browsers')).toBe(
+      true
+    );
+    expect(
+      isMissingBrowserError('Looks like Playwright was just installed... npx playwright install')
+    ).toBe(true);
+  });
+
+  test('does NOT match unrelated launch failures (preserve real diagnostics)', () => {
+    expect(isMissingBrowserError('Target page, context or browser has been closed')).toBe(false);
+    expect(isMissingBrowserError('connect ECONNREFUSED 127.0.0.1:9222')).toBe(false);
+    expect(isMissingBrowserError('Timeout 30000ms exceeded')).toBe(false);
+    expect(isMissingBrowserError('')).toBe(false);
+    expect(isMissingBrowserError(null)).toBe(false);
+    expect(isMissingBrowserError(undefined)).toBe(false);
+  });
+});
+
+describe('_pw-launch — user-facing contract', () => {
+  test('INSTALL_HINT is the copy-pasteable remediation', () => {
+    expect(INSTALL_HINT).toContain('npx playwright install chromium');
+  });
+
+  test('NO_BROWSER_EXIT is a distinct non-zero code', () => {
+    expect(NO_BROWSER_EXIT).toBeGreaterThan(0);
+  });
+});

package/plugins/design/dev-server/test/fixtures/phase-20-annotations.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"><path data-id="p1" data-tool="pen" stroke="#d63b1f" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" vector-effect="non-scaling-stroke" fill="none" d="M0 0 L10 10 L20 5" pointer-events="stroke"/><rect data-id="r1" data-tool="rect" stroke="#222" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" vector-effect="non-scaling-stroke" fill="#fff4d6" x="10" y="20" width="30" height="40"/><ellipse data-id="e1" data-tool="ellipse" stroke="#222" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" vector-effect="non-scaling-stroke" fill="#e6f4ea" cx="100" cy="100" rx="40" ry="25"/><g data-id="a1" data-tool="arrow" stroke="#1a8f3e" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" vector-effect="non-scaling-stroke" fill="none"><line x1="0" y1="0" x2="100" y2="0"/><polyline points="85.5844981135613,6.94213982588093 100,0 85.5844981135613,-6.94213982588093" fill="#1a8f3e"/></g><text data-id="t1" data-tool="text" data-anchor-id="r1" data-font-size="14" fill="#1a1a1a" text-anchor="middle" dominant-baseline="middle">needs work</text></svg>

package/plugins/design/dev-server/test/fixtures/phase-21-annotations.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"><g data-id="st1" data-tool="sticky" data-r="8" data-fs="14" fill="#ffe27a"><rect x="40" y="50" width="200" height="160" rx="8" ry="8"/><text data-sticky-body="1" x="52" y="62" font-size="14" fill="#1a1a1a" dominant-baseline="hanging">ship it</text></g><rect data-id="r1" data-tool="rect" stroke="#3b82f6" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" vector-effect="non-scaling-stroke" fill="none" x="10" y="20" width="120" height="80" rx="8" ry="8" data-r="8"/><g data-id="a1" data-tool="arrow" stroke="#e5484d" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" vector-effect="non-scaling-stroke" fill="none" data-start-head="triangle" data-dash="1"><line x1="0" y1="0" x2="80" y2="40" stroke-dasharray="6 4"/><polyline points="17.99801569252915,0.2672660312767773 0,0 11.012622240538908,14.238052935257258" fill="#e5484d"/><polyline points="62.00198430747085,39.732733968723224 80,40 68.98737775946108,25.761947064742742" fill="#e5484d"/></g></svg>

package/plugins/design/dev-server/test/input-router.test.ts

@@ -201,10 +201,10 @@ describe('input-router / keydown — Phase 5 draw tools', () => {
     });
   });
 
-  test('R → tool rect', () => {
+  test('R → tool shape (Phase 24 — single Shape tool)', () => {
     expect(classify(base({ type: 'keydown', key: 'r' }))).toEqual({
       kind: 'tool',
-      tool: 'rect',
+      tool: 'shape',
     });
   });
 
@@ -222,10 +222,31 @@ describe('input-router / keydown — Phase 5 draw tools', () => {
     });
   });
 
-  test('O → tool ellipse (Phase 5.1)', () => {
+  test('O → tool shape (Phase 24 — legacy ellipse key now arms Shape)', () => {
     expect(classify(base({ type: 'keydown', key: 'o' }))).toEqual({
       kind: 'tool',
-      tool: 'ellipse',
+      tool: 'shape',
+    });
+  });
+
+  test('shape tool owns bare pointer events (SVG overlay claims)', () => {
+    expect(classify(base({ type: 'pointerdown', activeTool: 'shape', button: 0 })).kind).toBe(
+      'no-op'
+    );
+    expect(classify(base({ type: 'pointermove', activeTool: 'shape' })).kind).toBe('no-op');
+  });
+
+  test('N → tool sticky (Phase 21)', () => {
+    expect(classify(base({ type: 'keydown', key: 'n' }))).toEqual({
+      kind: 'tool',
+      tool: 'sticky',
+    });
+  });
+
+  test('T → tool text (Phase 21)', () => {
+    expect(classify(base({ type: 'keydown', key: 't' }))).toEqual({
+      kind: 'tool',
+      tool: 'text',
     });
   });
 
@@ -268,6 +289,13 @@ describe('input-router / pointer events — Phase 5 annotation tools', () => {
     expect(classify(base({ type: 'pointermove', activeTool: 'ellipse' })).kind).toBe('no-op');
   });
 
+  test('sticky + text tools own bare pointer events (Phase 21 — SVG overlay claims)', () => {
+    for (const activeTool of ['sticky', 'text'] as const) {
+      expect(classify(base({ type: 'pointerdown', activeTool, button: 0 })).kind).toBe('no-op');
+      expect(classify(base({ type: 'pointermove', activeTool })).kind).toBe('no-op');
+    }
+  });
+
   test('cmd+left-click in arrow tool → select replace (escape hatch to move)', () => {
     expect(
       classify(