@1agh/maude 0.24.0 → 0.25.0

package/plugins/design/dev-server/test/annotations-roundtrip.test.ts

@@ -67,6 +67,39 @@ describe('annotations round-trip / back-compat canary (Task 10)', () => {
   });
 });
 
+describe('annotations round-trip / Phase-21 back-compat canary (Phase 24, Task 2)', () => {
+  // A frozen Phase-21-era canvas — sticky + rounded rect + arrow-both-heads-
+  // dashed. Phase 24 must round-trip it BYTE-IDENTICAL (the new polygon /
+  // 6-head / line-type / bold-strike-align fields all serialize only for
+  // non-default values, so a Phase-21 scene gains zero bytes).
+  test('a frozen Phase-21 SVG round-trips BYTE-IDENTICAL', async () => {
+    const fixture = await Bun.file(
+      new URL('./fixtures/phase-21-annotations.svg', import.meta.url)
+    ).text();
+    expect(fixture.endsWith('</svg>')).toBe(true);
+    expect(reparse(fixture)).toBe(fixture);
+  });
+
+  test('parsing the Phase-21 fixture keeps each shape free of phantom Phase-24 fields', async () => {
+    const fixture = await Bun.file(
+      new URL('./fixtures/phase-21-annotations.svg', import.meta.url)
+    ).text();
+    const strokes = svgToStrokes(fixture);
+    expect(strokes.map((s) => s.tool)).toEqual(['sticky', 'rect', 'arrow']);
+    const sticky = strokes.find((s) => s.tool === 'sticky') as StickyStroke;
+    // No phantom bold/strike/align on a plain sticky.
+    expect(sticky.bold).toBeUndefined();
+    expect(sticky.strike).toBeUndefined();
+    expect(sticky.align).toBeUndefined();
+    expect(sticky.cornerRadius).toBe(8);
+    const arrow = strokes.find((s) => s.tool === 'arrow') as ArrowStroke;
+    expect(arrow.startHead).toBe('triangle');
+    expect(arrow.endHead).toBeUndefined(); // triangle is the default → unset
+    expect(arrow.dashed).toBe(true);
+    expect(arrow.lineType).toBeUndefined(); // straight default → no phantom
+  });
+});
+
 describe('annotations round-trip / sticky', () => {
   const sticky: StickyStroke = {
     id: 'st1',
@@ -274,3 +307,213 @@ describe('annotations round-trip / mixed scene idempotency', () => {
     expect(reparse(svg)).toBe(svg);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase 24 — polygon, full arrowhead set + line-type, text/sticky bold/strike/
+// align. Parse needs a DOMParser (registered via happy-dom above).
+
+describe('annotations round-trip / Phase 24 polygon', () => {
+  for (const shape of ['diamond', 'triangle', 'triangle-down'] as const) {
+    test(`${shape} round-trips its bbox + shape + fill`, () => {
+      const poly = {
+        id: `pg-${shape}`,
+        tool: 'polygon' as const,
+        shape,
+        color: '#e5484d',
+        width: 3,
+        x: 10,
+        y: 20,
+        w: 80,
+        h: 60,
+        fill: '#fbe0e1',
+      };
+      const svg = strokesToSvg([poly]);
+      expect(svg).toContain(`data-shape="${shape}"`);
+      const [parsed] = svgToStrokes(svg) as Array<typeof poly>;
+      expect(parsed?.tool).toBe('polygon');
+      expect(parsed?.shape).toBe(shape);
+      expect(parsed?.x).toBeCloseTo(10, 4);
+      expect(parsed?.y).toBeCloseTo(20, 4);
+      expect(parsed?.w).toBeCloseTo(80, 4);
+      expect(parsed?.h).toBeCloseTo(60, 4);
+      expect(parsed?.fill).toBe('#fbe0e1');
+      expect(reparse(svg)).toBe(svg); // idempotent
+    });
+  }
+
+  test('dashed polygon round-trips the dash flag', () => {
+    const svg = strokesToSvg([
+      {
+        id: 'pg',
+        tool: 'polygon',
+        shape: 'diamond',
+        color: '#222',
+        width: 2,
+        x: 0,
+        y: 0,
+        w: 40,
+        h: 40,
+        dashed: true,
+      },
+    ]);
+    expect(svg).toContain('data-dash="1"');
+    const [parsed] = svgToStrokes(svg) as Array<{ dashed?: boolean }>;
+    expect(parsed?.dashed).toBe(true);
+  });
+});
+
+describe('annotations round-trip / Phase 24 full arrowhead set + line-type', () => {
+  const heads: ArrowStroke['startHead'][] = [
+    'none',
+    'line',
+    'triangle',
+    'triangle-outline',
+    'circle',
+    'diamond',
+  ];
+  for (const start of heads) {
+    for (const end of heads) {
+      test(`heads start=${start} end=${end} round-trip`, () => {
+        const arrow: ArrowStroke = {
+          id: 'a',
+          tool: 'arrow',
+          color: '#1a8f3e',
+          width: 3,
+          x1: 0,
+          y1: 0,
+          x2: 100,
+          y2: 20,
+          startHead: start,
+          endHead: end,
+        };
+        const svg = strokesToSvg([arrow]);
+        const [parsed] = svgToStrokes(svg) as ArrowStroke[];
+        expect(parsed?.startHead ?? 'none').toBe(start);
+        expect(parsed?.endHead ?? 'triangle').toBe(end);
+        expect(reparse(svg)).toBe(svg);
+      });
+    }
+  }
+
+  for (const lineType of ['straight', 'curved', 'elbow'] as const) {
+    test(`lineType=${lineType} round-trips + endpoints recover from the shaft`, () => {
+      const arrow: ArrowStroke = {
+        id: 'a',
+        tool: 'arrow',
+        color: '#3b82f6',
+        width: 2,
+        x1: 12,
+        y1: 8,
+        x2: 90,
+        y2: 64,
+        lineType,
+      };
+      const svg = strokesToSvg([arrow]);
+      const [parsed] = svgToStrokes(svg) as ArrowStroke[];
+      expect(parsed?.lineType ?? 'straight').toBe(lineType);
+      // Endpoints survive whether the shaft is a <line> or a <path>.
+      expect(parsed?.x1).toBeCloseTo(12, 4);
+      expect(parsed?.y1).toBeCloseTo(8, 4);
+      expect(parsed?.x2).toBeCloseTo(90, 4);
+      expect(parsed?.y2).toBeCloseTo(64, 4);
+      expect(reparse(svg)).toBe(svg);
+    });
+  }
+});
+
+describe('annotations round-trip / Phase 24 text + sticky bold/strike/align', () => {
+  for (const align of ['left', 'center', 'right'] as const) {
+    test(`standalone text align=${align} + bold + strike round-trips`, () => {
+      const t: TextStroke = {
+        id: 't',
+        tool: 'text',
+        color: '#1a1a1a',
+        fontSize: 36,
+        text: 'huge',
+        x: 10,
+        y: 20,
+        bold: true,
+        strike: true,
+        align,
+      };
+      const [parsed] = svgToStrokes(strokesToSvg([t])) as TextStroke[];
+      expect(parsed?.bold).toBe(true);
+      expect(parsed?.strike).toBe(true);
+      // 'left' is the standalone default → serializer omits it → parser leaves undefined.
+      expect(parsed?.align ?? 'left').toBe(align);
+    });
+  }
+
+  test('anchored text default (centre, no bold/strike) stays byte-identical', () => {
+    const t: TextStroke = {
+      id: 't',
+      tool: 'text',
+      color: '#1a1a1a',
+      fontSize: 14,
+      text: 'x',
+      anchorId: 'h',
+    };
+    const svg = strokesToSvg([t]);
+    expect(svg).not.toContain('data-align');
+    expect(svg).not.toContain('font-weight');
+    expect(svg).not.toContain('text-decoration');
+    expect(reparse(svg)).toBe(svg);
+  });
+
+  test('sticky bold/strike/align round-trips; a plain sticky gains no attrs', () => {
+    const plain: StickyStroke = {
+      id: 'st',
+      tool: 'sticky',
+      color: '#fce8a6',
+      x: 0,
+      y: 0,
+      w: 200,
+      h: 200,
+      text: 'note',
+      fontSize: 16,
+    };
+    const plainSvg = strokesToSvg([plain]);
+    expect(plainSvg).not.toContain('data-bold');
+    expect(plainSvg).not.toContain('data-align');
+    const styled: StickyStroke = { ...plain, bold: true, strike: true, align: 'center' };
+    const svg = strokesToSvg([styled]);
+    expect(svg).toContain('data-bold="1"');
+    expect(svg).toContain('data-strike="1"');
+    expect(svg).toContain('data-align="center"');
+    const [parsed] = svgToStrokes(svg) as StickyStroke[];
+    expect(parsed?.bold).toBe(true);
+    expect(parsed?.strike).toBe(true);
+    expect(parsed?.align).toBe('center');
+  });
+});
+
+describe('annotations round-trip / Phase 24 arrowhead parse-clamp (DDR-067 security)', () => {
+  // A hub-pushed SVG with an out-of-vocabulary / poisoned data-*-head must be
+  // REJECTED on parse (not cast through unchecked) so it can never reach the
+  // serializer to attempt a quote-breakout.
+  test('an out-of-vocab data-start-head is dropped, not cast through', () => {
+    const dirty =
+      '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1">' +
+      '<g data-id="a" data-tool="arrow" stroke="#111" stroke-width="2" fill="none" ' +
+      'data-start-head="t&quot;onload=&quot;alert(1)" data-end-head="evil">' +
+      '<line x1="0" y1="0" x2="50" y2="0"/></g></svg>';
+    const [parsed] = svgToStrokes(dirty) as ArrowStroke[];
+    expect(parsed?.tool).toBe('arrow');
+    expect(parsed?.startHead).toBeUndefined(); // poisoned → rejected
+    expect(parsed?.endHead).toBeUndefined(); // 'evil' → rejected
+    // Re-serializing the clamped stroke emits NO poisoned attribute.
+    const reserialized = strokesToSvg(svgToStrokes(dirty));
+    expect(reserialized).not.toContain('onload');
+    expect(reserialized).not.toContain('evil');
+  });
+
+  test('a valid expanded head (circle/diamond) still round-trips', () => {
+    const ok =
+      '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1">' +
+      '<g data-id="a" data-tool="arrow" stroke="#111" stroke-width="2" fill="none" data-start-head="circle" data-end-head="diamond">' +
+      '<line x1="0" y1="0" x2="50" y2="0"/><polygon points="0,0 0,0 0,0" fill="#111"/><polygon points="0,0 0,0 0,0 0,0" fill="#111"/></g></svg>';
+    const [parsed] = svgToStrokes(ok) as ArrowStroke[];
+    expect(parsed?.startHead).toBe('circle');
+    expect(parsed?.endHead).toBe('diamond');
+  });
+});

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

@@ -4,13 +4,14 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { TOOL_CURSORS } from '../canvas-cursors.ts';
+import { TOOL_CURSORS, resolveToolCursor } from '../canvas-cursors.ts';
 
 const ALL_TOOLS = [
   'move',
   'hand',
   'comment',
   'pen',
+  'shape',
   'rect',
   'ellipse',
   'sticky',
@@ -27,15 +28,20 @@ describe('canvas-cursors / TOOL_CURSORS', () => {
     }
   });
 
-  test('move keeps the system arrow', () => {
-    expect(TOOL_CURSORS.move).toBe('default');
+  test('Phase 24 — every tool ships a Kenney cursor (move is no longer the bare system arrow)', () => {
+    // The brief: ONE unified cursor library for ALL tools. `move` now ships a
+    // Kenney arrow glyph with a `default` native fallback (not bare 'default').
+    expect(TOOL_CURSORS.move).toContain('url("data:image/svg+xml,');
+    expect(TOOL_CURSORS.move).toMatch(/, default$/);
   });
 
   test('custom cursors are well-formed data-URI CSS values with hotspot + fallback', () => {
     const fallback: Record<string, string> = {
+      move: 'default',
       hand: 'grab',
       comment: 'crosshair',
       pen: 'crosshair',
+      shape: 'crosshair',
       rect: 'crosshair',
       ellipse: 'crosshair',
       sticky: 'crosshair',
@@ -49,10 +55,12 @@ describe('canvas-cursors / TOOL_CURSORS', () => {
       expect(v).toMatch(
         new RegExp(`^url\\("data:image/svg\\+xml,%3Csvg[^"]+"\\) \\d+ \\d+, ${fb}$`)
       );
-      // The SVG must declare a 32×32 box and be valid encoded markup.
+      // The SVG renders at 24px (Phase 24 — smaller than the 32-unit viewBox)
+      // and is valid encoded markup.
       const decoded = decodeURIComponent(v.slice(v.indexOf(',') + 1, v.indexOf('")')));
-      expect(decoded).toContain("width='32'");
-      expect(decoded).toContain("height='32'");
+      expect(decoded).toContain("width='24'");
+      expect(decoded).toContain("height='24'");
+      expect(decoded).toContain("viewBox='0 0 32 32'");
       expect(decoded).toContain('</svg>');
     }
   });
@@ -71,3 +79,84 @@ describe('canvas-cursors / TOOL_CURSORS', () => {
     }
   });
 });
+
+// Phase 24 (DDR-067) — the canvas→shell `tool-cursor` bridge echoes a tool
+// TOKEN and the shell resolves it HERE to a trusted cursor. This is the control
+// that closes the phase-24 ethical-hacker Finding 2 (an untrusted synced canvas
+// posting an invisible/displaced SVG cursor as a clickjacking aid over the
+// un-CSP'd shell). These tests assert the confinement so it can't silently
+// regress: only known tool ids resolve, and they always resolve to a trusted,
+// visible data-URI cursor — never to attacker-supplied bytes.
+describe('canvas-cursors / resolveToolCursor (untrusted token → trusted cursor)', () => {
+  test('every known tool resolves to its trusted TOOL_CURSORS string', () => {
+    for (const t of ALL_TOOLS) {
+      expect(resolveToolCursor(t)).toBe(TOOL_CURSORS[t]);
+    }
+  });
+
+  test('resolved value is always a trusted data-URI cursor (or native fallback) — never raw bytes', () => {
+    for (const t of ALL_TOOLS) {
+      const v = resolveToolCursor(t);
+      expect(typeof v).toBe('string');
+      // Each is one of our own frozen entries: a `url("data:image/svg+xml,…")`
+      // glyph with a hotspot + native fallback. The shell interpolates THIS,
+      // not the message, so there is no attacker-controlled region.
+      expect(v).toMatch(/^url\("data:image\/svg\+xml,%3Csvg[^"]+"\) \d+ \d+, [a-z-]+$/);
+    }
+  });
+
+  test('rejects unknown / prototype-polluting / malformed tokens', () => {
+    const hostile = [
+      // not a known tool
+      'pwn',
+      'banana',
+      // prototype chain — `in` would match these; `hasOwnProperty` must not
+      'constructor',
+      'toString',
+      'hasOwnProperty',
+      '__proto__',
+      // shape-gate violations (uppercase / digits / punctuation / whitespace)
+      'Move',
+      'pen1',
+      'pen ',
+      ' pen',
+      'pen;',
+      'pe.n',
+      '',
+      // the OLD attack vector: a full cursor STRING is no longer accepted —
+      // only a bare token is, so an invisible/displaced SVG cursor can't pass
+      'url("data:image/svg+xml,%3Csvg/%3E") 0 0, none',
+    ];
+    for (const tok of hostile) {
+      expect(resolveToolCursor(tok)).toBeNull();
+    }
+  });
+
+  test('rejects non-string tokens (typeof short-circuits BEFORE coercion)', () => {
+    // The `{ toString }` / `[ 'pen' ]` cases prove the guard checks `typeof`
+    // first and never coerces — a malicious `toString`/`Symbol.toPrimitive`
+    // that returns a valid tool id must NOT smuggle a cursor through.
+    let coerced = false;
+    const hostileCoercible = {
+      toString() {
+        coerced = true;
+        return 'pen';
+      },
+    };
+    for (const tok of [
+      null,
+      undefined,
+      42,
+      {},
+      [],
+      ['pen'],
+      true,
+      Symbol('pen'),
+      hostileCoercible,
+    ]) {
+      // biome-ignore lint/suspicious/noExplicitAny: deliberate hostile-input test
+      expect(resolveToolCursor(tok as any)).toBeNull();
+    }
+    expect(coerced).toBe(false);
+  });
+});

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/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-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,13 +222,20 @@ 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',