@1agh/maude 0.28.1 → 0.30.0

package/apps/studio/test/tour-overlay.test.tsx

@@ -0,0 +1,56 @@
+// tour-overlay — Phase 3. Render contract for the hand-rolled tour engine.
+//
+// renderToStaticMarkup doesn't run effects, so the rect stays null on the
+// server render → the overlay falls back to a centered card + scrim. We assert
+// the a11y dialog contract + step/nav wiring; keyboard/focus-trap behavior is a
+// live-only concern (verified via agent-browser).
+
+import { describe, expect, test } from 'bun:test';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { TourOverlay } from '../client/tour/overlay.jsx';
+
+const STEP = { target: '.x', title: 'Welcome', body: 'Body copy here' };
+
+describe('TourOverlay', () => {
+  test('renders an accessible dialog with the first step', () => {
+    const html = renderToStaticMarkup(
+      <TourOverlay open steps={[STEP]} onClose={() => {}} onComplete={() => {}} />
+    );
+    expect(html).toContain('mdcc-tour');
+    expect(html).toContain('role="dialog"');
+    expect(html).toContain('aria-modal="true"');
+    expect(html).toContain('Welcome');
+    expect(html).toContain('Body copy here');
+    expect(html).toContain('1 / 1');
+    expect(html).toContain('mdcc-tour__scrim'); // no rect on the server → scrim, not spotlight
+  });
+
+  test('single step shows Done (not Next) and no Back', () => {
+    const html = renderToStaticMarkup(
+      <TourOverlay open steps={[STEP]} onClose={() => {}} onComplete={() => {}} />
+    );
+    expect(html).toContain('Done');
+    expect(html).not.toContain('mdcc-tour__back');
+  });
+
+  test('multi-step first page shows Next, the counter, and no Back yet', () => {
+    const steps = [STEP, { ...STEP, title: 'Two' }, { ...STEP, title: 'Three' }];
+    const html = renderToStaticMarkup(
+      <TourOverlay open steps={steps} onClose={() => {}} onComplete={() => {}} />
+    );
+    expect(html).toContain('1 / 3');
+    expect(html).toContain('Next');
+    expect(html).not.toContain('mdcc-tour__back'); // i === 0
+  });
+
+  test('closed or empty renders nothing', () => {
+    expect(
+      renderToStaticMarkup(
+        <TourOverlay open={false} steps={[STEP]} onClose={() => {}} onComplete={() => {}} />
+      )
+    ).toBe('');
+    expect(
+      renderToStaticMarkup(<TourOverlay open steps={[]} onClose={() => {}} onComplete={() => {}} />)
+    ).toBe('');
+  });
+});

package/apps/studio/test/use-annotation-resize.test.ts

@@ -0,0 +1,402 @@
+// use-annotation-resize — FigJam resize-modifier math (pure `resizeStroke`).
+//
+// Covers the no-modifier baseline (must stay algebraically identical to the
+// pre-modifier corner math) plus Shift (aspect-lock / 45° snap), Alt
+// (scale-from-center / mirror-from-midpoint), and Shift+Alt combined, across
+// every resizable stroke kind. Pure function — no DOM render needed.
+
+import { describe, expect, test } from 'bun:test';
+
+import type {
+  ArrowStroke,
+  EllipseStroke,
+  ImageStroke,
+  LinkStroke,
+  PenStroke,
+  PolygonStroke,
+  RectStroke,
+  StickyStroke,
+} from '../annotations-layer.tsx';
+import { resizeStroke } from '../use-annotation-resize.tsx';
+
+const rect: RectStroke = {
+  id: 'r1',
+  tool: 'rect',
+  color: '#000',
+  width: 2,
+  x: 0,
+  y: 0,
+  w: 100,
+  h: 50,
+};
+
+describe('resizeStroke / rect — no modifiers (baseline)', () => {
+  test('se corner anchors the nw corner (back-compat)', () => {
+    expect(resizeStroke(rect, 'se', 120, 80)).toEqual({ x: 0, y: 0, w: 120, h: 80 });
+  });
+
+  test('nw corner anchors the se corner', () => {
+    expect(resizeStroke(rect, 'nw', -20, -10)).toEqual({ x: -20, y: -10, w: 120, h: 60 });
+  });
+
+  test('dragging past the anchor flips the box (min/max parity)', () => {
+    // se dragged to the left of x=0 → box lives to the left of the anchor.
+    expect(resizeStroke(rect, 'se', -40, 80)).toEqual({ x: -40, y: 0, w: 40, h: 80 });
+  });
+});
+
+describe('resizeStroke / rect — Shift (aspect lock)', () => {
+  test('keeps the 2:1 start ratio, dominant axis drives scale', () => {
+    // raw 120×200 → scale = max(1.2, 4) = 4 → 400×200 (ratio preserved).
+    expect(resizeStroke(rect, 'se', 120, 200, { shift: true, alt: false })).toEqual({
+      x: 0,
+      y: 0,
+      w: 400,
+      h: 200,
+    });
+  });
+});
+
+describe('resizeStroke / rect — Alt (scale from center)', () => {
+  test('center stays fixed; both sides grow symmetrically', () => {
+    const out = resizeStroke(rect, 'se', 120, 80, { shift: false, alt: true });
+    expect(out).toEqual({ x: -20, y: -30, w: 140, h: 110 });
+    // center invariant: (-20 + 140/2, -30 + 110/2) === (50, 25) === start center.
+    expect((out as RectStroke).x + (out as RectStroke).w / 2).toBe(50);
+    expect((out as RectStroke).y + (out as RectStroke).h / 2).toBe(25);
+  });
+});
+
+describe('resizeStroke / rect — Shift+Alt (ratio + center)', () => {
+  test('center-anchored and ratio-locked at once', () => {
+    expect(resizeStroke(rect, 'se', 120, 200, { shift: true, alt: true })).toEqual({
+      x: -300,
+      y: -150,
+      w: 700,
+      h: 350,
+    });
+  });
+});
+
+describe('resizeStroke / polygon — routes through the shared bbox math', () => {
+  const poly: PolygonStroke = {
+    id: 'p1',
+    tool: 'polygon',
+    shape: 'diamond',
+    color: '#000',
+    width: 2,
+    x: 0,
+    y: 0,
+    w: 100,
+    h: 50,
+  };
+  test('Shift aspect-locks the polygon like a rect', () => {
+    expect(resizeStroke(poly, 'se', 120, 200, { shift: true, alt: false })).toEqual({
+      x: 0,
+      y: 0,
+      w: 400,
+      h: 200,
+    });
+  });
+});
+
+describe('resizeStroke / sticky — always 1:1 square', () => {
+  const sticky: StickyStroke = {
+    id: 's1',
+    tool: 'sticky',
+    color: '#fce8a6',
+    x: 0,
+    y: 0,
+    w: 100,
+    h: 100,
+    text: '',
+    fontSize: 16,
+  };
+  test('no modifiers — larger axis becomes the side', () => {
+    expect(resizeStroke(sticky, 'se', 150, 120)).toEqual({ x: 0, y: 0, w: 150, h: 150 });
+  });
+  test('Alt — square grows from the center', () => {
+    expect(resizeStroke(sticky, 'se', 150, 120, { shift: false, alt: true })).toEqual({
+      x: -50,
+      y: -50,
+      w: 200,
+      h: 200,
+    });
+  });
+});
+
+describe('resizeStroke / image — Phase 23 (aspect-lock by default, Shift frees)', () => {
+  const image: ImageStroke = {
+    id: 'im1',
+    tool: 'image',
+    x: 0,
+    y: 0,
+    w: 100,
+    h: 50, // 2:1 intrinsic aspect
+    href: 'assets/abcd1234.png',
+  };
+  test('no modifiers keeps the intrinsic aspect (the inverse of shapes)', () => {
+    // se → 120,80 would be 2.4:1 free, but the lock keeps 2:1 (dominant axis).
+    expect(resizeStroke(image, 'se', 120, 80)).toEqual({ x: 0, y: 0, w: 160, h: 80 });
+  });
+  test('Shift held inverts to a free (unconstrained) resize', () => {
+    expect(resizeStroke(image, 'se', 120, 80, { shift: true, alt: false })).toEqual({
+      x: 0,
+      y: 0,
+      w: 120,
+      h: 80,
+    });
+  });
+});
+
+describe('resizeStroke / link — Phase 23 (free-resizes like a rect)', () => {
+  const link: LinkStroke = {
+    id: 'lk1',
+    tool: 'link',
+    x: 0,
+    y: 0,
+    w: 200,
+    h: 80,
+    url: 'https://example.com',
+    title: 'Example',
+    domain: 'example.com',
+  };
+  test('no modifiers free-resizes (no forced aspect)', () => {
+    expect(resizeStroke(link, 'se', 300, 120)).toEqual({ x: 0, y: 0, w: 300, h: 120 });
+  });
+});
+
+describe('resizeStroke / ellipse — Alt keeps the center fixed', () => {
+  const ell: EllipseStroke = {
+    id: 'e1',
+    tool: 'ellipse',
+    color: '#000',
+    width: 2,
+    cx: 50,
+    cy: 50,
+    rx: 40,
+    ry: 20,
+  };
+  test('center invariant under symmetric scale', () => {
+    expect(resizeStroke(ell, 'se', 120, 90, { shift: false, alt: true })).toEqual({
+      cx: 50,
+      cy: 50,
+      rx: 70,
+      ry: 40,
+    });
+  });
+});
+
+describe('resizeStroke / arrow', () => {
+  const arrow: ArrowStroke = {
+    id: 'a1',
+    tool: 'arrow',
+    color: '#000',
+    width: 2,
+    x1: 0,
+    y1: 0,
+    x2: 100,
+    y2: 0,
+  };
+  test('no modifiers — only the dragged endpoint moves', () => {
+    expect(resizeStroke(arrow, 'ep2', 100, 40)).toEqual({ x2: 100, y2: 40 });
+  });
+  test('Alt — the midpoint is pinned; the far end mirrors', () => {
+    expect(resizeStroke(arrow, 'ep2', 100, 40, { shift: false, alt: true })).toEqual({
+      x2: 100,
+      y2: 40,
+      x1: 0,
+      y1: -40,
+    });
+  });
+  test('Shift — shaft angle snaps to the nearest 45°', () => {
+    const out = resizeStroke(arrow, 'ep2', 50, 60, { shift: true, alt: false }) as ArrowStroke;
+    // Pointer at atan2(60,50)≈49° snaps to 45° → dx === dy along the shaft.
+    expect(out.x2).toBeCloseTo(out.y2 ?? Number.NaN, 6);
+    expect(out.x2).toBeGreaterThan(0);
+  });
+});
+
+describe('resizeStroke / pen — point scaling', () => {
+  const pen: PenStroke = {
+    id: 'pen1',
+    tool: 'pen',
+    color: '#000',
+    width: 2,
+    points: [
+      [0, 0],
+      [100, 0],
+      [100, 100],
+      [0, 100],
+    ],
+  };
+  test('no modifiers — scales around the opposite corner', () => {
+    const out = resizeStroke(pen, 'se', 200, 200) as PenStroke;
+    expect(out.points[0]).toEqual([0, 0]);
+    expect(out.points[2]).toEqual([200, 200]);
+  });
+  test('Alt — scales around the bbox center', () => {
+    const out = resizeStroke(pen, 'se', 150, 150, { shift: false, alt: true }) as PenStroke;
+    expect(out.points[0]).toEqual([-50, -50]);
+    expect(out.points[2]).toEqual([150, 150]);
+  });
+});
+
+describe('resizeStroke / rotation — Wave G corner rotate zones', () => {
+  // rect center = (50, 25). Angles below are measured around it.
+  test('relative rotation: grab angle is the zero reference (no jump)', () => {
+    // Grab at angle 0° (due east of center), drag to 45° → rotation 45.
+    const rotRef = { angle0: 0, rot0: 0 };
+    const out = resizeStroke(
+      rect,
+      'rot-se',
+      50 + 70,
+      25 + 70,
+      { shift: false, alt: false },
+      rotRef
+    );
+    expect(out).toEqual({ rotation: 45 });
+  });
+
+  test('starting rotation accumulates with the drag delta', () => {
+    const rotated: RectStroke = { ...rect, rotation: 30 };
+    const rotRef = { angle0: 0, rot0: 30 };
+    const out = resizeStroke(
+      rotated,
+      'rot-ne',
+      50 + 70,
+      25 + 70,
+      { shift: false, alt: false },
+      rotRef
+    );
+    expect(out).toEqual({ rotation: 75 });
+  });
+
+  test('magnetic cardinals: within 2° of 0 lock on and serialize as undefined', () => {
+    const rotated: RectStroke = { ...rect, rotation: 44 };
+    // Drag back by 42.5° → raw −1.5° + rot0 44 = ... use angle0 50, current 7.5 → deg = 44 − 42.5 = 1.5 → locks to 0.
+    const cur = (Math.PI / 180) * 7.5;
+    const out = resizeStroke(
+      rotated,
+      'rot-nw',
+      50 + 70 * Math.cos(cur),
+      25 + 70 * Math.sin(cur),
+      { shift: false, alt: false },
+      { angle0: 50, rot0: 44 }
+    );
+    expect(out).toEqual({ rotation: undefined });
+  });
+
+  test('Shift snaps to 15° steps', () => {
+    // delta = 40° → snaps to 45.
+    const cur = (Math.PI / 180) * 40;
+    const out = resizeStroke(
+      rect,
+      'rot-sw',
+      50 + 70 * Math.cos(cur),
+      25 + 70 * Math.sin(cur),
+      { shift: true, alt: false },
+      { angle0: 0, rot0: 0 }
+    );
+    expect(out).toEqual({ rotation: 45 });
+  });
+
+  test('non-rotatable strokes refuse the rotate corners', () => {
+    const arrow: ArrowStroke = {
+      id: 'a1',
+      tool: 'arrow',
+      color: '#000',
+      width: 2,
+      x1: 0,
+      y1: 0,
+      x2: 100,
+      y2: 0,
+    };
+    expect(
+      resizeStroke(arrow, 'rot-se', 50, 50, { shift: false, alt: false }, { angle0: 0, rot0: 0 })
+    ).toBeNull();
+  });
+
+  test('polygon rotates (diamond/triangle are rotatable hosts)', () => {
+    const poly: PolygonStroke = {
+      id: 'p1',
+      tool: 'polygon',
+      shape: 'diamond',
+      color: '#000',
+      width: 2,
+      x: 0,
+      y: 0,
+      w: 100,
+      h: 50,
+    };
+    const out = resizeStroke(
+      poly,
+      'rot-se',
+      50 + 70,
+      25 + 70,
+      { shift: false, alt: false },
+      { angle0: 0, rot0: 0 }
+    );
+    expect(out).toEqual({ rotation: 45 });
+  });
+});
+
+describe('resizeStroke / rotated strokes — Wave H anchor compensation', () => {
+  // rect 100×50 at origin, rotated 90° around its center (50, 25).
+  const rotated: RectStroke = { ...rect, rotation: 90 };
+  const rotP = (px: number, py: number, cx: number, cy: number, deg: number): [number, number] => {
+    const r = (deg * Math.PI) / 180;
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * Math.cos(r) - dy * Math.sin(r), cy + dx * Math.sin(r) + dy * Math.cos(r)];
+  };
+
+  test('se-corner drag keeps the nw corner fixed in WORLD space', () => {
+    // Cursor in the LOCAL frame (applyResize inverse-rotates before calling).
+    const out = resizeStroke(rotated, 'se', 140, 90) as RectStroke;
+    expect(out.w).toBeCloseTo(140, 6);
+    expect(out.h).toBeCloseTo(90, 6);
+    const before = rotP(0, 0, 50, 25, 90);
+    const after = rotP(out.x, out.y, out.x + out.w / 2, out.y + out.h / 2, 90);
+    expect(after[0]).toBeCloseTo(before[0], 6);
+    expect(after[1]).toBeCloseTo(before[1], 6);
+  });
+
+  test('e-edge drag keeps the west edge midpoint fixed in WORLD space', () => {
+    const out = resizeStroke(rotated, 'e', 130, 25) as RectStroke;
+    expect(out.w).toBeCloseTo(130, 6);
+    const before = rotP(0, 25, 50, 25, 90);
+    const after = rotP(out.x, out.y + out.h / 2, out.x + out.w / 2, out.y + out.h / 2, 90);
+    expect(after[0]).toBeCloseTo(before[0], 6);
+    expect(after[1]).toBeCloseTo(before[1], 6);
+  });
+
+  test('Alt resize keeps the center (no compensation path)', () => {
+    const out = resizeStroke(rotated, 'se', 130, 80, { shift: false, alt: true }) as RectStroke;
+    expect(out.x + out.w / 2).toBeCloseTo(50, 6);
+    expect(out.y + out.h / 2).toBeCloseTo(25, 6);
+  });
+
+  test('unrotated strokes are byte-stable (no shift applied)', () => {
+    expect(resizeStroke(rect, 'se', 120, 80)).toEqual({ x: 0, y: 0, w: 120, h: 80 });
+  });
+
+  test('rotated ellipse: se drag keeps the nw bbox corner fixed in WORLD space', () => {
+    const ell: EllipseStroke = {
+      id: 'e1',
+      tool: 'ellipse',
+      color: '#000',
+      width: 2,
+      cx: 50,
+      cy: 25,
+      rx: 50,
+      ry: 25,
+      rotation: 45,
+    };
+    const out = resizeStroke(ell, 'se', 140, 90) as EllipseStroke;
+    const before = rotP(0, 0, 50, 25, 45);
+    const after = rotP(out.cx - out.rx, out.cy - out.ry, out.cx, out.cy, 45);
+    expect(after[0]).toBeCloseTo(before[0], 6);
+    expect(after[1]).toBeCloseTo(before[1], 6);
+  });
+});

package/{plugins/design/dev-server → apps/studio}/test/use-artboard-drag.test.ts

@@ -15,7 +15,6 @@ import {
   DEFAULT_SNAP_TOLERANCE,
   DRAG_THRESHOLD_PX,
   type DragEvent,
-  type DragState,
   dragReducer,
   selectionsToArtboardIds,
 } from '../use-artboard-drag.tsx';

package/{plugins/design/dev-server → apps/studio}/test/use-tool-mode.test.tsx

@@ -1,6 +1,6 @@
 // use-tool-mode — Phase 4.1 Task 2. Provider transitions + cursor sync.
 
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { describe, expect, test } from 'bun:test';
 
 import { renderToStaticMarkup } from 'react-dom/server';
 
@@ -12,14 +12,16 @@ import {
 } from '../use-tool-mode.tsx';
 
 describe('use-tool-mode / static', () => {
-  test('DEFAULT_TOOLS exposes V/H/C + draw set B/R/N/A/T/E (Phase 24 single Shape tool)', () => {
+  test('DEFAULT_TOOLS exposes V/H/C + draw set B/I/R/N/⇧S/A/T/E (single Shape tool + highlighter + section)', () => {
     expect(DEFAULT_TOOLS.map((t) => t.id)).toEqual([
       'move',
       'hand',
       'comment',
       'pen',
+      'highlighter',
       'shape',
       'sticky',
+      'section',
       'arrow',
       'text',
       'eraser',
@@ -29,8 +31,10 @@ describe('use-tool-mode / static', () => {
       'H',
       'C',
       'B',
+      'I',
       'R',
       'N',
+      '⇧S',
       'A',
       'T',
       'E',
@@ -50,8 +54,10 @@ describe('use-tool-mode / static', () => {
       'hand',
       'comment',
       'pen',
+      'highlighter',
       'shape',
       'sticky',
+      'section',
       'arrow',
       'text',
       'eraser',

package/apps/studio/test/whats-new.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { bestSeenVersion, computeUnseen, parseVer, verGt } from '../client/whats-new-seen.js';
+import { loadWhatsNew, resolveMaudeVersion } from '../whats-new.ts';
+
+describe('whats-new feed loader', () => {
+  test('loads the committed feed with a version + non-empty entries', () => {
+    const feed = loadWhatsNew({ fresh: true });
+    expect(typeof feed.version).toBe('string');
+    expect(Array.isArray(feed.entries)).toBe(true);
+    expect(feed.entries.length).toBeGreaterThan(0);
+  });
+
+  test('every entry has the required shape', () => {
+    for (const e of loadWhatsNew({ fresh: true }).entries) {
+      expect(typeof e.id).toBe('string');
+      expect(e.id).toMatch(/^[a-z0-9][a-z0-9-]*$/);
+      expect(['feature', 'improvement', 'usage', 'fix']).toContain(e.kind);
+      expect(e.title.length).toBeGreaterThan(0);
+      expect(e.summary.length).toBeGreaterThan(0);
+    }
+  });
+
+  test('resolveMaudeVersion reads the design plugin manifest', () => {
+    expect(resolveMaudeVersion()).toMatch(/^\d+\.\d+\.\d+/);
+  });
+
+  test('a missing feed dir yields empty entries and never throws', () => {
+    const feed = loadWhatsNew({ root: join(import.meta.dir, '__does-not-exist__'), fresh: true });
+    expect(feed.entries).toEqual([]);
+  });
+
+  // Security regression (ethical-hacker creativity finding): the feed MUST
+  // resolve from the maude package root, NEVER a served project's tree. A
+  // hostile served project dropping its own whats-new.json must not inject
+  // entries into the privileged main-origin UI. Pin the boundary so a future
+  // "project-overridable feed" change can't silently erode it.
+  test('default resolution ignores a feed planted in an arbitrary (served-project) dir', () => {
+    const hostile = mkdtempSync(join(tmpdir(), 'mdcc-served-'));
+    writeFileSync(
+      join(hostile, 'whats-new.json'),
+      JSON.stringify({
+        entries: [{ id: 'evil', kind: 'feature', title: 'pwn', summary: 'x' }],
+      })
+    );
+    const feed = loadWhatsNew({ fresh: true }); // no root → package root only
+    expect(feed.entries.some((e) => e.id === 'evil')).toBe(false);
+    expect(feed.entries.length).toBeGreaterThan(0); // still reads the real package feed
+  });
+
+  // Defense-in-depth contract: a rendered learnMore is always an http(s) URL.
+  test('every committed entry learnMore is http(s) (no javascript:/data: scheme)', () => {
+    for (const e of loadWhatsNew({ fresh: true }).entries) {
+      if (e.learnMore != null) expect(e.learnMore).toMatch(/^https?:\/\//);
+    }
+  });
+});
+
+describe('seen logic (browser-safe, shared with the client)', () => {
+  test('parseVer extracts a semver triple', () => {
+    expect(parseVer('0.28.1')).toEqual([0, 28, 1]);
+    expect(parseVer('1.2.3-beta.4')).toEqual([1, 2, 3]);
+    expect(parseVer('dev')).toBeNull();
+  });
+
+  test('verGt compares semver, treating unparseable seen as oldest', () => {
+    expect(verGt('0.29.0', '0.28.1')).toBe(true);
+    expect(verGt('0.28.1', '0.29.0')).toBe(false);
+    expect(verGt('1.0.0', '0.99.99')).toBe(true);
+    expect(verGt('0.28.1', '0.28.1')).toBe(false);
+    expect(verGt('0.28.1', 'dev')).toBe(true);
+    expect(verGt('dev', '0.28.1')).toBe(false);
+  });
+
+  test('pending (null version) entries are always unseen', () => {
+    const u = computeUnseen(
+      [{ id: 'a', version: null, kind: 'feature', title: 't', summary: 's' }],
+      '9.9.9'
+    );
+    expect(u.map((e) => e.id)).toEqual(['a']);
+  });
+
+  test('computeUnseen returns only entries newer than the seen version', () => {
+    const entries = [
+      { id: 'old', version: '0.27.0', kind: 'feature', title: 't', summary: 's' },
+      { id: 'new', version: '0.29.0', kind: 'feature', title: 't', summary: 's' },
+    ];
+    expect(computeUnseen(entries, '0.28.0').map((e) => e.id)).toEqual(['new']);
+    expect(computeUnseen(entries, '0.29.0')).toEqual([]);
+  });
+
+  test('bestSeenVersion picks the highest of feed + entry versions', () => {
+    expect(bestSeenVersion([{ version: '0.29.0' }, { version: '0.27.0' }], '0.28.1')).toBe(
+      '0.29.0'
+    );
+    expect(bestSeenVersion([{ version: '0.20.0' }], '0.28.1')).toBe('0.28.1');
+    expect(bestSeenVersion([{ version: null }], '0.28.1')).toBe('0.28.1');
+  });
+});

package/apps/studio/text-imports.d.ts

@@ -0,0 +1,9 @@
+// Ambient declarations for Bun text imports — `import x from './f.ext' with { type: 'text' }`.
+// The dev-server runs under Bun (which honors the import attribute) and ships as
+// a `bun --compile` binary (which inlines the text at build time). tsc only needs
+// to know the module resolves to a string default export.
+
+declare module '*.tsx.template' {
+  const content: string;
+  export default content;
+}