@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/annotations-snap.test.ts

@@ -1,135 +0,0 @@
-// annotations-snap — FigJam v3 drag snapping + smart guides (pure, DOM-free).
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  computeSnap,
-  GRID_PITCH_PX,
-  type GuideLineCandidate,
-  SNAP_THRESHOLD_PX,
-  type SnapBox,
-} from '../annotations-snap.ts';
-
-const box = (x: number, y: number, w = 100, h = 100): SnapBox => ({ x, y, w, h });
-
-describe('computeSnap', () => {
-  test('snaps left edge to a candidate left edge within the threshold', () => {
-    const res = computeSnap(box(104, 300), [box(100, 0)], SNAP_THRESHOLD_PX);
-    expect(res.dx).toBe(-4);
-    expect(res.dy).toBe(0);
-    expect(res.guides).toHaveLength(1);
-    const guide = res.guides[0];
-    expect(guide?.axis).toBe('x');
-    expect(guide?.at).toBe(100);
-    // The guide spans from the candidate to the (snapped) moving box.
-    expect(guide?.from).toBe(0);
-    expect(guide?.to).toBe(400);
-  });
-
-  test('centers participate — center-to-center snap', () => {
-    // moving center x = 153, candidate center x = 150 → dx -3.
-    const res = computeSnap(box(103, 0), [box(100, 300)], SNAP_THRESHOLD_PX);
-    expect(res.dx).toBe(-3);
-  });
-
-  test('axes resolve independently against different candidates', () => {
-    const res = computeSnap(box(104, 203), [box(100, 500), box(500, 200)], SNAP_THRESHOLD_PX);
-    expect(res.dx).toBe(-4); // left edge → first candidate
-    expect(res.dy).toBe(-3); // top edge → second candidate
-    expect(res.guides).toHaveLength(2);
-  });
-
-  test('nearest line wins; outside the threshold = no snap', () => {
-    const res = computeSnap(box(104, 0), [box(100, 0), box(105, 0)], SNAP_THRESHOLD_PX);
-    expect(res.dx).toBe(1); // 105 is 1 away vs 100 being 4 away
-    const none = computeSnap(box(120, 0), [box(100, 300)], SNAP_THRESHOLD_PX);
-    expect(none.dx).toBe(0);
-    expect(none.guides).toHaveLength(0);
-  });
-
-  test('empty candidates / zero threshold → no snap', () => {
-    expect(computeSnap(box(0, 0), [], SNAP_THRESHOLD_PX).guides).toHaveLength(0);
-    expect(computeSnap(box(101, 0), [box(100, 0)], 0).dx).toBe(0);
-  });
-
-  test('grid fallback — leading edge snaps to the 24px lattice with no candidates', () => {
-    // x=98 → nearest grid line 96 (4·24), 2 away; y=50 → nearest 48, 2 away.
-    const res = computeSnap(box(98, 50), [], SNAP_THRESHOLD_PX, { grid: GRID_PITCH_PX });
-    expect(res.dx).toBe(-2);
-    expect(res.dy).toBe(-2);
-    // Grid snap is silent — the dots themselves are the visual, no guide lines.
-    expect(res.guides).toHaveLength(0);
-  });
-
-  test('grid fallback is per-axis — a smart-guide axis keeps its candidate snap', () => {
-    // x snaps to the candidate edge (dx -4 → x=100, NOT the 96 grid line);
-    // y has no candidate within reach → grid line 48 wins (dy -2).
-    const res = computeSnap(box(104, 50), [box(100, 500)], SNAP_THRESHOLD_PX, {
-      grid: GRID_PITCH_PX,
-    });
-    expect(res.dx).toBe(-4);
-    expect(res.dy).toBe(-2);
-  });
-
-  test('grid outside the threshold → no correction', () => {
-    // x=84 sits 12 from both 72 and 96 — beyond the 6px threshold.
-    const res = computeSnap(box(84, 84), [], SNAP_THRESHOLD_PX, { grid: GRID_PITCH_PX });
-    expect(res.dx).toBe(0);
-    expect(res.dy).toBe(0);
-  });
-});
-
-// feature-1-artboard-kinds-foundation, T7 — generic-layout-guide lines feed
-// the same candidate pool as stroke/artboard bboxes.
-describe('computeSnap / guide lines (T7)', () => {
-  test('leading edge snaps to a guide line within threshold', () => {
-    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 100, from: 0, to: 1000 }];
-    const res = computeSnap(box(104, 300), [], SNAP_THRESHOLD_PX, { guideLines });
-    expect(res.dx).toBe(-4);
-    expect(res.guides).toHaveLength(1);
-    expect(res.guides[0]).toMatchObject({ axis: 'x', at: 100, from: 0, to: 1000 });
-  });
-
-  test('center also tests against a guide line', () => {
-    // moving center x = 153, guide at 150 → dx -3.
-    const guideLines: GuideLineCandidate[] = [{ axis: 'y', at: 350, from: 0, to: 1000 }];
-    const res = computeSnap(box(103, 300), [], SNAP_THRESHOLD_PX, { guideLines });
-    // center y = 350, guide at 350 → dy 0 (exact), still emits a guide.
-    expect(res.dy).toBe(0);
-    expect(res.guides.find((g) => g.axis === 'y')).toMatchObject({ at: 350 });
-  });
-
-  test('nearest-wins applies across BOTH sources — a closer guide beats a farther candidate', () => {
-    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 105, from: 0, to: 1000 }];
-    const res = computeSnap(box(104, 300), [box(100, 0)], SNAP_THRESHOLD_PX, { guideLines });
-    // candidate edge (100) is 4 away; guide (105) is 1 away — guide wins.
-    expect(res.dx).toBe(1);
-  });
-
-  test('a closer stroke/artboard candidate beats a farther guide line', () => {
-    // candidate edge (100) is 4 away from x=104; guide (110) is 6 away — the
-    // candidate is strictly closer, so it wins even though the guide is
-    // still within the 6px threshold.
-    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 110, from: 0, to: 1000 }];
-    const res = computeSnap(box(104, 300), [box(100, 0)], SNAP_THRESHOLD_PX, { guideLines });
-    expect(res.dx).toBe(-4);
-  });
-
-  test('outside threshold, a guide line is ignored', () => {
-    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 500, from: 0, to: 1000 }];
-    const res = computeSnap(box(104, 300), [], SNAP_THRESHOLD_PX, { guideLines });
-    expect(res.dx).toBe(0);
-    expect(res.guides).toHaveLength(0);
-  });
-
-  test('guide-line snap composes with the grid fallback on the OTHER axis', () => {
-    // x snaps to the guide line; y has no candidate → grid fallback fires.
-    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 100, from: 0, to: 1000 }];
-    const res = computeSnap(box(104, 50), [], SNAP_THRESHOLD_PX, {
-      guideLines,
-      grid: GRID_PITCH_PX,
-    });
-    expect(res.dx).toBe(-4);
-    expect(res.dy).toBe(-2);
-  });
-});

package/apps/studio/test/annotations-text-format.test.ts

@@ -1,396 +0,0 @@
-// annotations text-format polish — multi-line tspans, italic / underline,
-// ordered + unordered lists, dashed shapes, and the highlighter pen. The PARSE
-// side needs a DOMParser (happy-dom, registered per-file). The load-bearing
-// assertions: every NEW field serializes ONLY when set (the byte-identical
-// round-trip canary holds for legacy/unstyled strokes), and multi-line text
-// reconstructs its `\n` from tspans (list markers stripped).
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-import {
-  type EllipseStroke,
-  listPrefixedBody,
-  type PenStroke,
-  type RectStroke,
-  type StickyStroke,
-  splitTextLines,
-  stickyCornerPath,
-  stripEditorMarkers,
-  strokeBBox,
-  strokesToSvg,
-  svgToStrokes,
-  type TextStroke,
-} from '../annotations-layer.tsx';
-import { sanitizeAnnotationSvg } from '../api.ts';
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-afterAll(async () => {
-  await GlobalRegistrator.unregister();
-});
-
-/** Re-serialize a freshly-parsed SVG. Idempotency helper. */
-function reparse(svg: string): string {
-  return strokesToSvg(svgToStrokes(svg));
-}
-
-const baseStandalone: TextStroke = {
-  id: 't1',
-  tool: 'text',
-  color: '#1f1f1f',
-  fontSize: 14,
-  text: 'one line',
-  x: 40,
-  y: 60,
-};
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Multi-line text (item 4a)
-
-describe('text-format / multi-line tspans', () => {
-  test('single-line text emits NO tspan and round-trips byte-identical', () => {
-    const svg = strokesToSvg([baseStandalone]);
-    expect(svg).not.toContain('<tspan');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('standalone multi-line text emits one tspan per line and recovers \\n', () => {
-    const multi: TextStroke = { ...baseStandalone, text: 'line one\nline two\nline three' };
-    const svg = strokesToSvg([multi]);
-    expect((svg.match(/<tspan/g) ?? []).length).toBe(3);
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.text).toBe('line one\nline two\nline three');
-    expect(reparse(svg)).toBe(svg); // idempotent
-  });
-
-  test('anchored multi-line text round-trips its \\n', () => {
-    const anchored: TextStroke = {
-      id: 'ta',
-      tool: 'text',
-      color: '#1f1f1f',
-      fontSize: 16,
-      text: 'top\nbottom',
-      anchorId: 'host-1',
-    };
-    const svg = strokesToSvg([anchored]);
-    expect(svg).toContain('<tspan');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.anchorId).toBe('host-1');
-    expect(parsed?.text).toBe('top\nbottom');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('multi-line text survives the PUT-path sanitizer byte-intact (tspan allowlisted)', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, text: 'a\nb' }]);
-    expect(sanitizeAnnotationSvg(svg)).toBe(svg);
-    const [parsed] = svgToStrokes(sanitizeAnnotationSvg(svg)) as TextStroke[];
-    expect(parsed?.text).toBe('a\nb');
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Italic + underline (item 4b)
-
-describe('text-format / italic + underline', () => {
-  test('italic serializes font-style only when set; round-trips', () => {
-    const plain = strokesToSvg([baseStandalone]);
-    expect(plain).not.toContain('font-style');
-    const svg = strokesToSvg([{ ...baseStandalone, italic: true }]);
-    expect(svg).toContain('font-style="italic"');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.italic).toBe(true);
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('underline serializes text-decoration only when set; round-trips', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, underline: true }]);
-    expect(svg).toContain('text-decoration="underline"');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.underline).toBe(true);
-    expect(parsed?.strike).toBeUndefined();
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('strike + underline combine into one text-decoration (order stable)', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, strike: true, underline: true }]);
-    expect(svg).toContain('text-decoration="line-through underline"');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.strike).toBe(true);
-    expect(parsed?.underline).toBe(true);
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('strike-only stays byte-identical to the legacy line-through form', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, strike: true }]);
-    expect(svg).toContain('text-decoration="line-through"');
-    expect(svg).not.toContain('underline');
-  });
-
-  test('all four formats (bold+italic+strike+underline) combine + round-trip', () => {
-    // The editors commit bold/italic/underline (Cmd+B/I/U) + strike together;
-    // assert every flag serializes and survives the round-trip.
-    const svg = strokesToSvg([
-      { ...baseStandalone, bold: true, italic: true, strike: true, underline: true },
-    ]);
-    expect(svg).toContain('font-weight="700"');
-    expect(svg).toContain('font-style="italic"');
-    expect(svg).toContain('text-decoration="line-through underline"');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.bold).toBe(true);
-    expect(parsed?.italic).toBe(true);
-    expect(parsed?.strike).toBe(true);
-    expect(parsed?.underline).toBe(true);
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('sticky italic + underline round-trip; 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,
-    };
-    expect(strokesToSvg([plain])).not.toContain('data-italic');
-    const svg = strokesToSvg([{ ...plain, italic: true, underline: true }]);
-    expect(svg).toContain('data-italic="1"');
-    expect(svg).toContain('data-underline="1"');
-    const [parsed] = svgToStrokes(svg) as StickyStroke[];
-    expect(parsed?.italic).toBe(true);
-    expect(parsed?.underline).toBe(true);
-    expect(reparse(svg)).toBe(svg);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Lists (item 4c)
-
-describe('text-format / ordered + unordered lists', () => {
-  test('bullet list: data-list set, markers render-only, stored text clean', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, text: 'apple\npear', listType: 'bullet' }]);
-    expect(svg).toContain('data-list="bullet"');
-    expect(svg).toContain('• apple');
-    expect(svg).toContain('• pear');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    // Stored text has NO marker — markers are presentation only.
-    expect(parsed?.text).toBe('apple\npear');
-    expect(parsed?.listType).toBe('bullet');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('numbered list: per-line N. markers, re-numbered from stored text', () => {
-    const svg = strokesToSvg([
-      { ...baseStandalone, text: 'first\nsecond\nthird', listType: 'number' },
-    ]);
-    expect(svg).toContain('1. first');
-    expect(svg).toContain('2. second');
-    expect(svg).toContain('3. third');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.text).toBe('first\nsecond\nthird');
-    expect(parsed?.listType).toBe('number');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('a single-line list item still round-trips (forces a tspan)', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, text: 'solo', listType: 'bullet' }]);
-    expect(svg).toContain('<tspan');
-    expect(svg).toContain('• solo');
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.text).toBe('solo');
-    expect(parsed?.listType).toBe('bullet');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('a line that literally starts with the marker is not double-stripped', () => {
-    const svg = strokesToSvg([{ ...baseStandalone, text: '• already', listType: 'bullet' }]);
-    const [parsed] = svgToStrokes(svg) as TextStroke[];
-    expect(parsed?.text).toBe('• already');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('no list ⇒ no data-list attribute (canary)', () => {
-    expect(strokesToSvg([baseStandalone])).not.toContain('data-list');
-  });
-
-  test('sticky list round-trips with markers render-only (body text stays raw)', () => {
-    const svg = strokesToSvg([
-      {
-        id: 'sl',
-        tool: 'sticky',
-        color: '#fce8a6',
-        x: 0,
-        y: 0,
-        w: 200,
-        h: 200,
-        text: 'buy milk\nbuy eggs',
-        fontSize: 16,
-        listType: 'bullet',
-      },
-    ]);
-    expect(svg).toContain('data-list="bullet"');
-    // The persisted sticky body <text> keeps RAW text (no marker).
-    expect(svg).toContain('>buy milk\nbuy eggs<');
-    const [parsed] = svgToStrokes(svg) as StickyStroke[];
-    expect(parsed?.text).toBe('buy milk\nbuy eggs');
-    expect(parsed?.listType).toBe('bullet');
-    expect(reparse(svg)).toBe(svg);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Dashed rect / ellipse (item 7)
-
-describe('text-format / dashed shapes', () => {
-  const rect: RectStroke = {
-    id: 'r',
-    tool: 'rect',
-    color: '#1f1f1f',
-    width: 2,
-    x: 0,
-    y: 0,
-    w: 80,
-    h: 60,
-    fill: null,
-  };
-  const ellipse: EllipseStroke = {
-    id: 'e',
-    tool: 'ellipse',
-    color: '#1f1f1f',
-    width: 2,
-    cx: 40,
-    cy: 30,
-    rx: 30,
-    ry: 20,
-    fill: null,
-  };
-
-  test('solid rect / ellipse emit no dash attr (canary)', () => {
-    expect(strokesToSvg([rect])).not.toContain('data-dash');
-    expect(strokesToSvg([ellipse])).not.toContain('data-dash');
-    expect(reparse(strokesToSvg([rect]))).toBe(strokesToSvg([rect]));
-    expect(reparse(strokesToSvg([ellipse]))).toBe(strokesToSvg([ellipse]));
-  });
-
-  test('dashed rect round-trips data-dash + stroke-dasharray', () => {
-    const svg = strokesToSvg([{ ...rect, dashed: true }]);
-    expect(svg).toContain('data-dash="1"');
-    expect(svg).toContain('stroke-dasharray="6 4"');
-    const [parsed] = svgToStrokes(svg) as RectStroke[];
-    expect(parsed?.dashed).toBe(true);
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('dashed ellipse round-trips data-dash', () => {
-    const svg = strokesToSvg([{ ...ellipse, dashed: true }]);
-    expect(svg).toContain('data-dash="1"');
-    const [parsed] = svgToStrokes(svg) as EllipseStroke[];
-    expect(parsed?.dashed).toBe(true);
-    expect(reparse(svg)).toBe(svg);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Highlighter pen (item 8) — appended after Task 9.
-
-describe('text-format / highlighter pen', () => {
-  const pen: PenStroke = {
-    id: 'p',
-    tool: 'pen',
-    color: '#1f1f1f',
-    width: 3,
-    points: [
-      [0, 0],
-      [10, 0],
-    ],
-  };
-
-  test('a normal pen emits no data-highlighter (canary)', () => {
-    const svg = strokesToSvg([pen]);
-    expect(svg).not.toContain('data-highlighter');
-    expect(reparse(svg)).toBe(svg);
-  });
-
-  test('a highlighter pen round-trips data-highlighter + wide translucent stroke', () => {
-    const hl: PenStroke = { ...pen, highlighter: true, width: 16, color: '#ffe40066' };
-    const svg = strokesToSvg([hl]);
-    expect(svg).toContain('data-highlighter="1"');
-    const [parsed] = svgToStrokes(svg) as PenStroke[];
-    expect(parsed?.highlighter).toBe(true);
-    expect(parsed?.width).toBe(16);
-    expect(parsed?.color).toBe('#ffe40066');
-    expect(reparse(svg)).toBe(svg);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Render-contract helpers (item 1 sticky corner + item 4a bbox)
-
-describe('text-format / sticky sharp-corner path (item 1)', () => {
-  test('stickyCornerPath rounds TL/TR/BL and keeps the bottom-right SHARP', () => {
-    const d = stickyCornerPath(0, 0, 100, 80, 8);
-    // The BR corner is a straight L to the exact corner (no Q arc there): the
-    // right edge drops to (100,80) then the bottom edge runs to the BL arc.
-    expect(d).toContain('L100 80'); // sharp bottom-right corner vertex
-    // Three rounded corners ⇒ exactly three quadratic arcs (TR, BL, TL).
-    expect((d.match(/Q/g) ?? []).length).toBe(3);
-    expect(d.endsWith('Z')).toBe(true);
-  });
-
-  test('radius clamps to half the smaller side (never self-overlaps)', () => {
-    const d = stickyCornerPath(0, 0, 10, 200, 999);
-    // r clamps to min(999, 5, 100) = 5; the first move starts at x = r = 5.
-    expect(d.startsWith('M5 0')).toBe(true);
-  });
-});
-
-describe('text-format / editor list markers (item 4c — show while editing)', () => {
-  test('listPrefixedBody adds markers; stripEditorMarkers removes them (round-trip)', () => {
-    expect(listPrefixedBody('a\nb', 'bullet')).toBe('• a\n• b');
-    expect(listPrefixedBody('a\nb\nc', 'number')).toBe('1. a\n2. b\n3. c');
-    expect(listPrefixedBody('a\nb', undefined)).toBe('a\nb');
-    for (const list of ['bullet', 'number'] as const) {
-      const raw = 'milk\neggs\nbread';
-      // The editor shows markers; on commit they strip back to the raw text.
-      expect(stripEditorMarkers(listPrefixedBody(raw, list), list)).toBe(raw);
-    }
-  });
-
-  test('stripEditorMarkers removes a numbered prefix regardless of the typed number', () => {
-    // A user who edits/reorders lines may leave stale numbers; strip is generic.
-    expect(stripEditorMarkers('1. x\n5. y\nz', 'number')).toBe('x\ny\nz');
-    expect(stripEditorMarkers('• keep\nno marker', 'bullet')).toBe('keep\nno marker');
-    expect(stripEditorMarkers('untouched', undefined)).toBe('untouched');
-  });
-});
-
-describe('text-format / multi-line bbox (item 4a)', () => {
-  test('a standalone multi-line text bbox grows with line count', () => {
-    const single = strokeBBox({
-      id: 't',
-      tool: 'text',
-      color: '#000',
-      fontSize: 20,
-      text: 'one',
-      x: 0,
-      y: 0,
-    });
-    const triple = strokeBBox({
-      id: 't',
-      tool: 'text',
-      color: '#000',
-      fontSize: 20,
-      text: 'one\ntwo\nthree',
-      x: 0,
-      y: 0,
-    });
-    expect(single?.h).toBeCloseTo(20 * 1.2, 4); // single-line keeps legacy height
-    expect(triple?.h).toBeGreaterThan((single?.h ?? 0) * 2); // ~3 lines tall
-    expect(splitTextLines('one\ntwo\nthree')).toEqual(['one', 'two', 'three']);
-  });
-});

package/apps/studio/test/artboard-activity-overlay.test.tsx

@@ -1,56 +0,0 @@
-// artboard-activity-overlay — Phase 13. Presentational overlay contract.
-//
-// The positioned overlay only renders inside a laid-out DesignCanvas (rect
-// resolves after layout effects, which renderToStaticMarkup doesn't run), so we
-// assert the leaf component directly: the rim box, the badge text, and the
-// active→fading toggle. The gating decision (present + artboard scope) is
-// covered in use-canvas-activity.test.tsx.
-
-import { describe, expect, test } from 'bun:test';
-
-import { renderToStaticMarkup } from 'react-dom/server';
-
-import { ArtboardActivityOverlay } from '../artboard-activity-overlay.tsx';
-
-const RECT = { x: 10, y: 20, w: 300, h: 200 };
-
-describe('artboard-activity-overlay', () => {
-  test('renders the rim + badge with the editing label', () => {
-    const html = renderToStaticMarkup(
-      <ArtboardActivityOverlay rect={RECT} label="Smoke TSX.tsx" active />
-    );
-    expect(html).toContain('dc-activity-rim');
-    expect(html).toContain('dc-activity-badge');
-    expect(html).toContain('dc-activity-scan'); // Phase 13.3 full-artboard scan beam
-    expect(html).toContain('editing —');
-    expect(html).toContain('Smoke TSX.tsx');
-    expect(html).toContain('aria-hidden');
-  });
-
-  test('agent color overrides the activity CSS var', () => {
-    const html = renderToStaticMarkup(
-      <ArtboardActivityOverlay rect={RECT} label="Nimble Ferret" active color="#ff9800" />
-    );
-    expect(html).toMatch(/--mdcc-activity:\s*#ff9800/);
-  });
-
-  test('active overlay is NOT marked fading', () => {
-    const html = renderToStaticMarkup(<ArtboardActivityOverlay rect={RECT} label="x" active />);
-    expect(html).not.toContain('data-fading');
-  });
-
-  test('idle overlay carries data-fading for the cross-fade out', () => {
-    const html = renderToStaticMarkup(
-      <ArtboardActivityOverlay rect={RECT} label="x" active={false} />
-    );
-    expect(html).toContain('data-fading="true"');
-  });
-
-  test('positions at the artboard world rect', () => {
-    const html = renderToStaticMarkup(<ArtboardActivityOverlay rect={RECT} label="x" active />);
-    expect(html).toMatch(/left:\s*10px/);
-    expect(html).toMatch(/top:\s*20px/);
-    expect(html).toMatch(/width:\s*300px/);
-    expect(html).toMatch(/height:\s*200px/);
-  });
-});