@1agh/maude 0.27.0 → 0.28.1

package/plugins/design/dev-server/test/activity.test.ts

@@ -0,0 +1,195 @@
+// activity — Phase 13. fs:any → per-file active|idle tracker + region diff.
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  ACTIVITY_IDLE_MS,
+  type ActivityChange,
+  createActivity,
+  diffArtboardIds,
+  isCanvasFile,
+} from '../activity.ts';
+import { type Context, createBus } from '../context.ts';
+
+function mkCtx(): Context {
+  const bus = createBus();
+  return {
+    cfg: {} as Context['cfg'],
+    projectLabel: '',
+    // No designRoot → refineArtboards() short-circuits; transition tests stay
+    // fs-free. The diff is exercised directly via diffArtboardIds() below.
+    paths: {} as Context['paths'],
+    bus,
+  };
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe('activity / isCanvasFile', () => {
+  test('accepts .tsx + .html canvases under ui/', () => {
+    expect(isCanvasFile('ui/Smoke TSX.tsx')).toBe(true);
+    expect(isCanvasFile('ui/legacy.html')).toBe(true);
+    expect(isCanvasFile('ui/components/Card.tsx')).toBe(true);
+  });
+
+  test('rejects non-canvas extensions', () => {
+    expect(isCanvasFile('ui/Smoke.css')).toBe(false);
+    expect(isCanvasFile('_locator.json')).toBe(false);
+    expect(isCanvasFile('ui/shot.png')).toBe(false);
+  });
+
+  test('rejects _-prefixed files + dirs (runtime artifacts, history, draw, smoke)', () => {
+    expect(isCanvasFile('_active.json')).toBe(false);
+    expect(isCanvasFile('_history/ui/Smoke TSX/0001.tsx')).toBe(false);
+    expect(isCanvasFile('_draw/logo.proof.tsx')).toBe(false);
+    expect(isCanvasFile('_history/snap.html')).toBe(false);
+  });
+
+  test('rejects SKIP_DIRS segments', () => {
+    expect(isCanvasFile('node_modules/react/index.tsx')).toBe(false);
+    expect(isCanvasFile('dist/runtime/x.tsx')).toBe(false);
+    expect(isCanvasFile('ui/build/out.tsx')).toBe(false);
+  });
+
+  test('rejects DS preview specimens (false-positive guard)', () => {
+    expect(isCanvasFile('system/aurora/preview/motion.html')).toBe(false);
+    expect(isCanvasFile('system/aurora/preview/motion.tsx')).toBe(false);
+    // but a real canvas elsewhere under system/ is fine
+    expect(isCanvasFile('system/aurora/showcase.tsx')).toBe(true);
+  });
+
+  test('normalizes back-slash + leading slash', () => {
+    expect(isCanvasFile('\\ui\\Smoke.tsx')).toBe(true);
+    expect(isCanvasFile('/ui/Smoke.tsx')).toBe(true);
+    expect(isCanvasFile('')).toBe(false);
+  });
+});
+
+describe('activity / transitions', () => {
+  test('idle → active on first canvas fs:any event', () => {
+    const ctx = mkCtx();
+    const seen: ActivityChange[] = [];
+    ctx.bus.on('activity:change', (c) => seen.push(c));
+    const act = createActivity(ctx, { idleMs: 40, diff: false });
+
+    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
+    expect(act.state['ui/Smoke.tsx']?.status).toBe('active');
+    expect(seen).toHaveLength(1);
+    expect(seen[0]).toMatchObject({ file: 'ui/Smoke.tsx', status: 'active', artboard_ids: null });
+    act.stop();
+  });
+
+  test('non-canvas fs:any events are ignored', () => {
+    const ctx = mkCtx();
+    const seen: ActivityChange[] = [];
+    ctx.bus.on('activity:change', (c) => seen.push(c));
+    const act = createActivity(ctx, { idleMs: 40, diff: false });
+
+    ctx.bus.emit('fs:any', 'ui/Smoke.css');
+    ctx.bus.emit('fs:any', '_active.json');
+    ctx.bus.emit('fs:any', 'system/x/preview/motion.tsx');
+    expect(seen).toHaveLength(0);
+    expect(act.state['ui/Smoke.css']).toBeUndefined();
+    act.stop();
+  });
+
+  test('active → active: rapid events keep the file active past one idle window', async () => {
+    const ctx = mkCtx();
+    const act = createActivity(ctx, { idleMs: 60, diff: false });
+
+    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
+    await sleep(40);
+    ctx.bus.emit('fs:any', 'ui/Smoke.tsx'); // refresh before the 60 ms idle fires
+    await sleep(40); // 80 ms since first event, but only 40 ms since the refresh
+    expect(act.state['ui/Smoke.tsx']?.status).toBe('active');
+    act.stop();
+  });
+
+  test('active → idle after idleMs of silence, and emits the idle change', async () => {
+    const ctx = mkCtx();
+    const seen: ActivityChange[] = [];
+    ctx.bus.on('activity:change', (c) => seen.push(c));
+    const act = createActivity(ctx, { idleMs: 40, diff: false });
+
+    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
+    await sleep(80);
+    expect(act.state['ui/Smoke.tsx']?.status).toBe('idle');
+    const last = seen[seen.length - 1];
+    expect(last).toMatchObject({ file: 'ui/Smoke.tsx', status: 'idle' });
+    act.stop();
+  });
+
+  test('mark() test seam marks active without the bus', () => {
+    const ctx = mkCtx();
+    const seen: ActivityChange[] = [];
+    ctx.bus.on('activity:change', (c) => seen.push(c));
+    const act = createActivity(ctx, { idleMs: 40, diff: false });
+
+    act.mark('ui/Manual.tsx');
+    expect(act.state['ui/Manual.tsx']?.status).toBe('active');
+    expect(seen[0]?.file).toBe('ui/Manual.tsx');
+    act.stop();
+  });
+
+  test('stop() halts the idle timer (no idle emit after stop)', async () => {
+    const ctx = mkCtx();
+    const seen: ActivityChange[] = [];
+    ctx.bus.on('activity:change', (c) => seen.push(c));
+    const act = createActivity(ctx, { idleMs: 40, diff: false });
+
+    ctx.bus.emit('fs:any', 'ui/Smoke.tsx');
+    act.stop();
+    await sleep(80);
+    expect(seen.filter((c) => c.status === 'idle')).toHaveLength(0);
+    // stop() also detaches the bus subscription.
+    ctx.bus.emit('fs:any', 'ui/Other.tsx');
+    expect(act.state['ui/Other.tsx']).toBeUndefined();
+  });
+});
+
+describe('activity / diffArtboardIds (Task 7)', () => {
+  const wrap = (primaryBody: string, secondaryBody: string) =>
+    `import { DesignCanvas, DCArtboard } from '@maude/canvas-lib';
+export default function C() {
+  return (
+    <DesignCanvas>
+      <DCArtboard id="primary" label="Primary" width={400} height={300}>${primaryBody}</DCArtboard>
+      <DCArtboard id="secondary" label="Secondary" width={400} height={300}>${secondaryBody}</DCArtboard>
+    </DesignCanvas>
+  );
+}`;
+
+  test('change confined to one artboard → that id only', () => {
+    const prev = wrap('<p>A</p>', '<p>B</p>');
+    const next = wrap('<p>A</p>', '<p>B changed</p>');
+    expect(diffArtboardIds(prev, next)).toEqual(['secondary']);
+  });
+
+  test('change in both artboards → both ids', () => {
+    const prev = wrap('<p>A</p>', '<p>B</p>');
+    const next = wrap('<p>A2</p>', '<p>B2</p>');
+    expect(diffArtboardIds(prev, next)?.sort()).toEqual(['primary', 'secondary']);
+  });
+
+  test('identical content → null (no region changed)', () => {
+    const src = wrap('<p>A</p>', '<p>B</p>');
+    expect(diffArtboardIds(src, src)).toBeNull();
+  });
+
+  test('change outside any artboard body → null (file-level fallback)', () => {
+    const prev = wrap('<p>A</p>', '<p>B</p>');
+    // Added an import line outside any DCArtboard → skeleton differs.
+    const next = `import x from 'y';\n${wrap('<p>A</p>', '<p>B</p>')}`;
+    expect(diffArtboardIds(prev, next)).toBeNull();
+  });
+
+  test('no DCArtboard markers → null (ambiguous)', () => {
+    expect(diffArtboardIds('<div>old</div>', '<div>new</div>')).toBeNull();
+  });
+
+  test('artboard added/removed → null (shell differs)', () => {
+    const prev = wrap('<p>A</p>', '<p>B</p>');
+    const next = `${wrap('<p>A</p>', '<p>B</p>')}\n// trailing <DCArtboard id="third" label="T" width={1} height={1}>x</DCArtboard>`;
+    expect(diffArtboardIds(prev, next)).toBeNull();
+  });
+});

package/plugins/design/dev-server/test/ai-activity.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { HEARTBEAT_GRACE_MS, createAiActivity } from '../collab/ai-activity.ts';
+import { createAiActivity, HEARTBEAT_GRACE_MS } from '../collab/ai-activity.ts';
 import { type Context, createBus } from '../context.ts';
 
 function makeCtx(): { ctx: Context; events: { file: string; entry: unknown }[] } {

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

@@ -8,11 +8,10 @@
 //   - PUT rejects oversized bodies (>1 MB)
 //   - Unknown method → 405
 
+import { describe, expect, test } from 'bun:test';
 import { existsSync, 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';
 
 const SVG_OK =

package/plugins/design/dev-server/test/annotations-draw-modifiers.test.ts

@@ -6,13 +6,13 @@ import { describe, expect, test } from 'bun:test';
 
 import {
   type ArrowStroke,
+  applyDrawModifiers,
+  constrainDrawBox,
   type EllipseStroke,
   type PenStroke,
   type PolygonStroke,
   type RectStroke,
   type StickyStroke,
-  applyDrawModifiers,
-  constrainDrawBox,
 } from '../annotations-layer.tsx';
 
 const NONE = { shift: false, alt: false };

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

@@ -11,23 +11,23 @@ import { describe, expect, test } from 'bun:test';
 
 import {
   type ArrowStroke,
+  arrowHeadPoints,
   type EllipseStroke,
   type PenStroke,
   type PolygonStroke,
-  type RectStroke,
-  STICKY_PALETTE,
-  type StickyStroke,
-  type Stroke,
-  type TextStroke,
-  arrowHeadPoints,
   penPathD,
   polygonPoints,
   polygonVertices,
+  type RectStroke,
   rid,
+  STICKY_PALETTE,
+  type StickyStroke,
+  type Stroke,
   strokeBBox,
   strokeHitTest,
   strokesShallowEqual,
   strokesToSvg,
+  type TextStroke,
 } from '../annotations-layer.tsx';
 
 describe('annotations-layer / penPathD', () => {

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

@@ -17,9 +17,9 @@ import {
   type RectStroke,
   type StickyStroke,
   type Stroke,
-  type TextStroke,
   strokesToSvg,
   svgToStrokes,
+  type TextStroke,
 } from '../annotations-layer.tsx';
 import { sanitizeAnnotationSvg } from '../api.ts';
 

package/plugins/design/dev-server/test/artboard-activity-overlay.test.tsx

@@ -0,0 +1,56 @@
+// 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/);
+  });
+});

package/plugins/design/dev-server/test/boot-self-heal.test.ts

@@ -9,7 +9,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { type SelfHealOptions, bootSelfHeal } from '../boot-self-heal.ts';
+import { bootSelfHeal, type SelfHealOptions } from '../boot-self-heal.ts';
 
 let TMP: string;
 

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

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { TOOL_CURSORS, resolveToolCursor } from '../canvas-cursors.ts';
+import { resolveToolCursor, TOOL_CURSORS } from '../canvas-cursors.ts';
 
 const ALL_TOOLS = [
   'move',

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

@@ -5,7 +5,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { CanvasEditError, applyEdit, editAttribute } from '../canvas-edit.ts';
+import { applyEdit, CanvasEditError, editAttribute } from '../canvas-edit.ts';
 import { transpileCanvasSource } from '../canvas-pipeline.ts';
 
 const CANVAS = '/abs/Canvas.tsx';

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

@@ -7,10 +7,10 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import {
-  type MetaSidecar,
   applyHeader,
   applyHeaderToSource,
   buildHeader,
+  type MetaSidecar,
 } from '../canvas-header.ts';
 
 const META: MetaSidecar = {

package/plugins/design/dev-server/test/canvas-hmr-runtime.test.tsx

@@ -0,0 +1,114 @@
+// canvas-hmr-runtime — Phase 13.1 / DDR-077. The resettable error boundary that
+// keeps the last good render (no white flash) when an agent edit produces a
+// broken intermediate, and recovers when a good build lands.
+//
+// Error boundaries don't run under renderToStaticMarkup (SSR rethrows), so this
+// needs a live DOM. We register happy-dom for THIS file only (like
+// annotations-roundtrip.test.ts) and drive a real createRoot.
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { GlobalRegistrator } from '@happy-dom/global-registrator';
+
+beforeAll(() => {
+  GlobalRegistrator.register();
+  (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+});
+afterAll(() => {
+  GlobalRegistrator.unregister();
+});
+
+import { act, createElement } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+
+import { CanvasErrorBoundary } from '../canvas-comment-mount.tsx';
+
+function Good({ tag }: { tag: string }) {
+  return createElement('div', { 'data-good': tag }, `good:${tag}`);
+}
+function Boom(): never {
+  throw new Error('render exploded (missing import)');
+}
+
+function mount(el: HTMLElement) {
+  let root!: Root;
+  act(() => {
+    root = createRoot(el);
+  });
+  return root;
+}
+
+describe('CanvasErrorBoundary', () => {
+  test('renders children when they do not throw', () => {
+    const host = document.createElement('div');
+    const root = mount(host);
+    act(() => {
+      root.render(
+        createElement(
+          CanvasErrorBoundary,
+          {
+            attempt: 0,
+            onError: () => {},
+            fallback: () => createElement(Good, { tag: 'fallback' }),
+          },
+          createElement(Good, { tag: 'live' })
+        )
+      );
+    });
+    expect(host.querySelector('[data-good="live"]')).not.toBeNull();
+    expect(host.querySelector('[data-good="fallback"]')).toBeNull();
+    act(() => root.unmount());
+  });
+
+  test('a throwing child → renders fallback (NOT blank) and fires onError once', () => {
+    const host = document.createElement('div');
+    const root = mount(host);
+    let errors = 0;
+    act(() => {
+      root.render(
+        createElement(
+          CanvasErrorBoundary,
+          {
+            attempt: 0,
+            onError: () => {
+              errors++;
+            },
+            fallback: () => createElement(Good, { tag: 'lastgood' }),
+          },
+          createElement(Boom)
+        )
+      );
+    });
+    // The boundary held a render (the fallback) — the host is NOT empty.
+    expect(host.querySelector('[data-good="lastgood"]')).not.toBeNull();
+    expect(host.textContent).toContain('good:lastgood');
+    expect(errors).toBe(1);
+    act(() => root.unmount());
+  });
+
+  test('a new attempt with a good child recovers (swaps fallback → live)', () => {
+    const host = document.createElement('div');
+    const root = mount(host);
+    const render = (attempt: number, child: ReturnType<typeof createElement>) =>
+      act(() => {
+        root.render(
+          createElement(
+            CanvasErrorBoundary,
+            {
+              attempt,
+              onError: () => {},
+              fallback: () => createElement(Good, { tag: 'lastgood' }),
+            },
+            child
+          )
+        );
+      });
+
+    render(0, createElement(Boom)); // broken build → fallback
+    expect(host.querySelector('[data-good="lastgood"]')).not.toBeNull();
+
+    render(1, createElement(Good, { tag: 'fixed' })); // good build lands
+    expect(host.querySelector('[data-good="fixed"]')).not.toBeNull();
+    expect(host.querySelector('[data-good="lastgood"]')).toBeNull();
+    act(() => root.unmount());
+  });
+});

package/plugins/design/dev-server/test/canvas-lib-inline.test.ts

@@ -3,7 +3,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { type LibMap, buildLibMap, inlineUsedExports } from '../canvas-lib-inline.ts';
+import { buildLibMap, inlineUsedExports, type LibMap } from '../canvas-lib-inline.ts';
 
 const LIB_PATH = '/virtual/_lib/canvas-lib.tsx';
 

package/plugins/design/dev-server/test/canvas-lib-resolver.test.ts

@@ -2,12 +2,11 @@
 // bundled canvas-lib (Phase 3.6.1 Task 2; relocated to dev-server in Phase
 // 4.0.5 per DDR-025).
 
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { existsSync } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-
 import { buildCanvasModule } from '../canvas-build.ts';
 import {
   CANVAS_LIB_SPECIFIER,

package/plugins/design/dev-server/test/canvas-meta-api.test.ts

@@ -8,11 +8,10 @@
 //   - GET returns the merged meta
 //   - Paths that escape repoRoot are 400
 
+import { describe, expect, test } from 'bun:test';
 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';
 
 interface MetaShape {

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

@@ -5,11 +5,10 @@
 // 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 { describe, expect, test } from 'bun:test';
 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> {

package/plugins/design/dev-server/test/collab-annotations-bridge.test.ts

@@ -45,7 +45,7 @@ describe('Registry.syncRoomFromAnnotations', () => {
   test('inspector-write origin propagates through doc.update', () => {
     const r = createRegistry(noopCallbacks());
     const room = r.get('echo-slug');
-    let lastOrigin: unknown = undefined;
+    let lastOrigin: unknown;
     room.doc.on('update', (_update, origin) => {
       lastOrigin = origin;
     });

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

@@ -71,7 +71,7 @@ describe('Registry inspector-bridge', () => {
   test('inspector-write origin triggers doc.update broadcast', async () => {
     const r = createRegistry(noopCallbacks());
     const room = r.get('echo-slug');
-    let lastOrigin: unknown = undefined;
+    let lastOrigin: unknown;
     room.doc.on('update', (_update, origin) => {
       lastOrigin = origin;
     });

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

@@ -8,12 +8,12 @@ import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
 
 import {
-  MESSAGE_AWARENESS,
-  MESSAGE_SYNC,
   encodeAwarenessFrame,
   encodeHandshake,
   encodeSyncUpdate,
   handleMessage,
+  MESSAGE_AWARENESS,
+  MESSAGE_SYNC,
 } from '../collab/protocol.ts';
 
 function readType(frame: Uint8Array): number {

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

@@ -12,7 +12,7 @@ import {
   encodeSyncUpdate,
   handleMessage,
 } from '../collab/protocol.ts';
-import { type RoomCallbacks, type RoomConn, createRoom } from '../collab/room.ts';
+import { createRoom, type RoomCallbacks, type RoomConn } from '../collab/room.ts';
 
 function makeConn(id: string): RoomConn & { recv: Uint8Array[] } {
   const recv: Uint8Array[] = [];

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

@@ -19,7 +19,7 @@ import { afterEach, describe, expect, test } from 'bun:test';
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
 
-import { type RoomConn, createRoom } from '../collab/room.ts';
+import { createRoom, type RoomConn } from '../collab/room.ts';
 
 const STRESS_MS = Number(process.env.MAUDE_STRESS_MS ?? 10_000);
 const RSS_GROWTH_LIMIT_MB = 20;

package/plugins/design/dev-server/test/comments-api.test.ts

@@ -11,11 +11,10 @@
 //     git sandbox; gracefully empty if git fails)
 //   - Reply on unknown id → 404
 
+import { describe, expect, test } from 'bun:test';
 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 initGit(root: string) {

package/plugins/design/dev-server/test/compile-entry.test.ts

@@ -4,12 +4,11 @@
 // no spawn): given a target, it writes two files (`init-oxc-<slug>.ts` +
 // `server-<slug>.ts`) under dist/.compile-entries/ and returns the entry path.
 
+import { describe, expect, test } from 'bun:test';
 import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { describe, expect, test } from 'bun:test';
-
 import { writeCompileEntry } from '../build.ts';
 
 const ROOT = dirname(fileURLToPath(import.meta.url));

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

@@ -4,9 +4,8 @@
 // + the empty/file-tree branches.
 
 import { describe, expect, test } from 'bun:test';
-
-import { buildHandoffMarkdown } from '../../exporters/canva-handoff-prompt.ts';
 import { run } from '../../exporters/canva.ts';
+import { buildHandoffMarkdown } from '../../exporters/canva-handoff-prompt.ts';
 
 const CTX = {
   designRoot: '/tmp/.design',

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

@@ -1,10 +1,9 @@
 // Phase 6.5 T10 — export history persistence + endpoint.
 
+import { describe, expect, test } from 'bun:test';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { describe, expect, test } from 'bun:test';
-
 import { bootServer, killProc, makeSandbox, nextPort } from '../_helpers.ts';
 
 interface HistoryShape {

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

@@ -7,7 +7,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { INSTALL_HINT, NO_BROWSER_EXIT, isMissingBrowserError } from '../../bin/_pw-launch.mjs';
+import { INSTALL_HINT, isMissingBrowserError, NO_BROWSER_EXIT } from '../../bin/_pw-launch.mjs';
 
 describe('_pw-launch — missing-browser classifier', () => {
   test('matches the real Playwright "Executable doesn\'t exist" message', () => {