@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/collab-stress.test.ts

@@ -1,129 +0,0 @@
-// Phase 8 Task 8 — multi-tab stress harness.
-//
-// Two in-memory peers attached to one Room, broadcasting cursor-shaped
-// Awareness updates at ~30 Hz for `STRESS_MS` (default 10 s in CI; the plan
-// spec calls for 2 min but a tighter CI default keeps the run under 15 s).
-// Measures:
-//
-//   - RSS growth via process.memoryUsage().rss (before vs after)
-//   - Y.Doc state size growth via Y.encodeStateAsUpdate(doc).byteLength
-//   - Awareness state cleanup — when both peers disconnect, no entries leak
-//
-// Pass thresholds (CI-safe):
-//   - RSS delta < 20 MB (plan spec; conservative because GC is non-deterministic)
-//   - Y.Doc growth < 100 KB (the spec ceiling is 500 KB for a 2-min run; with
-//     awareness ephemeral + no doc.update traffic, growth should be ~0).
-
-import { afterEach, describe, expect, test } from 'bun:test';
-
-import { Awareness } from 'y-protocols/awareness';
-import * as Y from 'yjs';
-
-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;
-const YDOC_GROWTH_LIMIT_BYTES = 100_000;
-
-function makeConn(id: string): RoomConn {
-  return {
-    id,
-    send() {
-      /* drain — we don't care about the network bytes; the memory pressure
-         is on the Awareness map + Y.Doc internals, not the WS buffer */
-    },
-  };
-}
-
-describe('multi-tab stress (Phase 8 Task 8)', () => {
-  let cleanupRoom: (() => Promise<void>) | null = null;
-
-  afterEach(async () => {
-    if (cleanupRoom) {
-      await cleanupRoom();
-      cleanupRoom = null;
-    }
-  });
-
-  test(
-    '30 Hz × STRESS_MS × 2 peers — bounded RSS + Y.Doc growth',
-    async () => {
-      const room = createRoom('stress-slug', {
-        async seed() {},
-        async persistJson() {},
-        async persistBinary() {},
-      });
-      cleanupRoom = () => room.destroy();
-
-      const A = makeConn('peer-a');
-      const B = makeConn('peer-b');
-      await room.connect(A);
-      await room.connect(B);
-
-      // Each peer has its own local Awareness instance to model what real
-      // clients do — they don't share a memory address space with the server's
-      // awareness. We pump updates by setting state on the server-side
-      // awareness directly (the server's room.awareness is what the real WS
-      // peers' setLocalState() would land in via applyAwarenessUpdate).
-      const awA = new Awareness(new Y.Doc());
-      const awB = new Awareness(new Y.Doc());
-      awA.setLocalState({ name: 'Alice', color: '#f00', cursor: { x: 0, y: 0 }, __connId: A.id });
-      awB.setLocalState({ name: 'Bob', color: '#0f0', cursor: { x: 0, y: 0 }, __connId: B.id });
-
-      const rssBefore = process.memoryUsage().rss;
-      const docSizeBefore = Y.encodeStateAsUpdate(room.doc).byteLength;
-
-      const start = Date.now();
-      const tickInterval = 33; // ~30 Hz
-      let aX = 0;
-      let bX = 0;
-      let updates = 0;
-      while (Date.now() - start < STRESS_MS) {
-        aX = (aX + 1) % 1000;
-        bX = (bX + 7) % 1000;
-        awA.setLocalState({
-          name: 'Alice',
-          color: '#f00',
-          cursor: { x: aX, y: aX },
-          __connId: A.id,
-        });
-        awB.setLocalState({
-          name: 'Bob',
-          color: '#0f0',
-          cursor: { x: bX, y: bX },
-          __connId: B.id,
-        });
-        updates += 2;
-        await Bun.sleep(tickInterval);
-      }
-
-      const rssAfter = process.memoryUsage().rss;
-      const docSizeAfter = Y.encodeStateAsUpdate(room.doc).byteLength;
-
-      const rssGrowthMb = (rssAfter - rssBefore) / (1024 * 1024);
-      const docGrowth = docSizeAfter - docSizeBefore;
-
-      console.log(
-        `[stress] ${updates} awareness updates over ${STRESS_MS} ms → ` +
-          `RSS Δ=${rssGrowthMb.toFixed(1)} MB, Y.Doc Δ=${docGrowth} bytes`
-      );
-
-      expect(rssGrowthMb).toBeLessThan(RSS_GROWTH_LIMIT_MB);
-      expect(docGrowth).toBeLessThan(YDOC_GROWTH_LIMIT_BYTES);
-
-      // Disconnect both peers; size should go to 0.
-      room.disconnect(A);
-      room.disconnect(B);
-      expect(room.size()).toBe(0);
-    },
-    // Headroom must scale WITH the stress window, not sit a flat few seconds
-    // above it. The body burns `STRESS_MS` of wall clock by construction
-    // (`while (Date.now() - start < STRESS_MS)`), so on a loaded machine the
-    // setup/teardown and the ~33 ms tick drift are the only slack — a flat
-    // +5 s put the budget at 15 s against a measured 10.1 s run, and this was
-    // the one test that tipped over in a full-suite run under load. Nothing
-    // here asserts speed (the checks are RSS + Y.Doc growth), so a wide budget
-    // costs no signal: a real hang still dies, just later.
-    STRESS_MS * 2 + 10_000
-  );
-});

package/apps/studio/test/comment-mount.test.ts

@@ -1,97 +0,0 @@
-// comment-mount — shell-owned comment layer. Covers provider dedup (the
-// Maybe* wrappers consume an outer instance instead of double-mounting) and
-// the bundle scope-guard (react/react-dom externalized to the importmap so the
-// comment layer shares the canvas's single React singleton).
-
-import { describe, expect, test } from 'bun:test';
-import { join } from 'node:path';
-
-import { createElement } from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-
-import {
-  MaybeSelectionSetProvider,
-  SelectionSetProvider,
-  useSelectionSetOptional,
-} from '../use-selection-set.tsx';
-import { MaybeToolProvider, ToolProvider, useToolMode } from '../use-tool-mode.tsx';
-
-describe('comment-mount / MaybeToolProvider dedup', () => {
-  function ToolReader() {
-    const { tool } = useToolMode();
-    return createElement('span', { 'data-tool': tool });
-  }
-
-  test('consumes an OUTER ToolProvider instead of double-mounting', () => {
-    // Outer provider seeds tool='comment'. If MaybeToolProvider mounted a
-    // fresh provider, the reader would see the default 'move' instead.
-    const html = renderToStaticMarkup(
-      createElement(
-        ToolProvider,
-        { initial: 'comment' },
-        createElement(MaybeToolProvider, null, createElement(ToolReader))
-      )
-    );
-    expect(html).toContain('data-tool="comment"');
-  });
-
-  test('mounts its OWN ToolProvider when none exists above', () => {
-    const html = renderToStaticMarkup(
-      createElement(MaybeToolProvider, null, createElement(ToolReader))
-    );
-    // DDR-223 — the default boot tool is `move` (edit mode).
-    expect(html).toContain('data-tool="move"');
-  });
-
-  test('forwards initial="browse" — the comment-mount specimen posture (DDR-223)', () => {
-    // buildCanvasTree passes this explicitly so bare DS specimens keep the
-    // DDR-187 alive posture + native cursors.
-    const html = renderToStaticMarkup(
-      createElement(MaybeToolProvider, { initial: 'browse' }, createElement(ToolReader))
-    );
-    expect(html).toContain('data-tool="browse"');
-  });
-});
-
-describe('comment-mount / MaybeSelectionSetProvider dedup', () => {
-  function SelReader() {
-    const ctx = useSelectionSetOptional();
-    // Tag identity so we can assert a single context instance is shared.
-    return createElement('span', { 'data-has-ctx': ctx ? 'yes' : 'no' });
-  }
-
-  test('provides a SelectionSet when none exists above', () => {
-    const html = renderToStaticMarkup(
-      createElement(MaybeSelectionSetProvider, null, createElement(SelReader))
-    );
-    expect(html).toContain('data-has-ctx="yes"');
-  });
-
-  test('does not throw when nested inside an existing SelectionSetProvider', () => {
-    expect(() =>
-      renderToStaticMarkup(
-        createElement(
-          SelectionSetProvider,
-          { postTarget: null },
-          createElement(MaybeSelectionSetProvider, null, createElement(SelReader))
-        )
-      )
-    ).not.toThrow();
-  });
-});
-
-describe('comment-mount / bundle scope-guard', () => {
-  test('dist/comment-mount.js externalizes react + exports mountCanvas', async () => {
-    const here = join(import.meta.dir, '..');
-    const bundle = Bun.file(join(here, 'dist', 'comment-mount.js'));
-    expect(await bundle.exists()).toBe(true);
-    const src = await bundle.text();
-    // mountCanvas is the public entry the shell calls.
-    expect(src.includes('mountCanvas')).toBe(true);
-    // React must be a BARE import (resolved by _shell.html's importmap), not
-    // inlined — a second React instance would break hooks ("invalid hook
-    // call") across the canvas module and the comment layer.
-    expect(/import[^;]*["']react-dom\/client["']/.test(src)).toBe(true);
-    expect(/import[^;]*["']react["']/.test(src)).toBe(true);
-  });
-});

package/apps/studio/test/comment-relay-origin-gate.test.ts

@@ -1,117 +0,0 @@
-// The shell's inbound-postMessage comment relays must stay scoped to the
-// ACTIVE canvas.
-//
-// Threat: the origin check at the top of app.jsx's `onMessage` compares against
-// the single shared `canvasOrigin`, so EVERY open canvas iframe passes it —
-// including ones in background tabs. `comment-submit` / `comment-patch` /
-// `comment-delete` relay straight onto the privileged WS, so without a
-// per-message `e.source === activeWin` gate a background canvas can write
-// comments onto a file it names itself, with no user gesture. That mattered
-// little while comments were an inert store; the ACP panel's one-click
-// "Implement N comments" action turns open comments into a feed the agent acts
-// on, which is what promoted the seam to worth-closing.
-//
-// This is a SOURCE-STRUCTURE test, not a behavioural one: `App()` is a
-// 14k-line component that cannot be mounted in isolation, and the twenty other
-// `e.source === activeWin` gates in the same handler have no coverage at all.
-// Asserting on the source keeps the guard cheap and honest about its reach —
-// it catches a gate being deleted, a `file:` pin regressing to the
-// caller-supplied value, and (the last test) a gate that is written but cannot
-// execute. It claims nothing beyond that: it does not prove the relay behaves
-// correctly, only that the control is present and reachable.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const SRC = readFileSync(join(import.meta.dir, '..', 'client', 'app.jsx'), 'utf8');
-
-/** The body of one `else if (m.dgn === '<name>' …)` branch, up to the next one. */
-function branch(name: string): string {
-  const start = SRC.indexOf(`m.dgn === '${name}'`);
-  expect(start, `branch for ${name} not found in app.jsx`).toBeGreaterThan(-1);
-  const rest = SRC.slice(start + name.length);
-  const end = rest.indexOf('} else if (m.dgn ===');
-  return rest.slice(0, end === -1 ? 2000 : end);
-}
-
-describe('canvas → shell comment relays are scoped to the active canvas', () => {
-  // The comment relays, plus the three shell-control branches that were
-  // ungated alongside them: `shell-shortcut` (reload / panel toggles /
-  // Export + Handoff dialogs), and `open-export` / `open-timeline-request`,
-  // which reach the same dialogs from the in-canvas toolbar and context menu.
-  // All five are actions a user takes INSIDE the canvas in view; none has a
-  // reason to be honoured from a background frame.
-  for (const name of [
-    'comment-submit',
-    'comment-patch',
-    'comment-delete',
-    'shell-shortcut',
-    'open-export',
-    'open-timeline-request',
-  ]) {
-    test(`${name} is gated on e.source === activeWin`, () => {
-      expect(branch(name)).toContain('e.source === activeWin');
-    });
-  }
-
-  test('comment-submit pins the target file to activePath, never the payload', () => {
-    const body = branch('comment-submit');
-    // The file the comment lands on is the one the user is looking at.
-    expect(body).toContain('file: activePath');
-    // A canvas-supplied target would let a background iframe pick the victim.
-    expect(body).not.toContain('file: p.file');
-  });
-
-  test('comment-patch / comment-delete only accept ids owned by the active canvas', () => {
-    // A bare id would otherwise reach any comment in the project — and these
-    // two verbs change or remove somebody else's note (ws.ts refuses both for a
-    // viewer session for exactly that reason).
-    expect(branch('comment-patch')).toContain('ownsActiveComment(m.id)');
-    expect(branch('comment-delete')).toContain('ownsActiveComment(m.id)');
-  });
-
-  // The above only prove the gate is WRITTEN. This proves it can RUN.
-  //
-  // House style declares `const activeWin` block-locally inside each `else if`
-  // branch, so a branch that compares against `activeWin` without declaring it
-  // reads exactly like a working gate while throwing `ReferenceError` at
-  // runtime — fail-closed, but it takes the legitimate path down with it and
-  // silently reopens the moment anything introduces an outer binding. That is
-  // not hypothetical: the first cut of this fix shipped it, and every
-  // string-matching assertion above stayed green.
-  test('every activeWin comparison has a declaration, derived from activePath', () => {
-    // Line comments are blanked first — the prose in this handler quotes the
-    // gate expression, and a comment is not a use.
-    const CODE = SRC.split('\n')
-      .map((l) => l.replace(/^\s*\/\/.*$/, ''))
-      .join('\n');
-    const BRANCH_START = /\b(?:else )?if \(m\.dgn ===/g;
-    const starts = [...CODE.matchAll(BRANCH_START)].map((m) => m.index ?? 0);
-    const undeclared: string[] = [];
-
-    // Both idioms count: the `===` gate used by the comment relays and the
-    // `!== … return` early-exit form five other branches use. Checking only
-    // one lets a branch convert to the other and slip the check.
-    for (const use of [...CODE.matchAll(/e\.source [!=]== activeWin/g)].map((m) => m.index ?? 0)) {
-      // Nearest branch boundary at or before this usage.
-      const open = starts.filter((s) => s < use).pop() ?? 0;
-      // `= activePath` is the load-bearing half: a declaration that derives the
-      // window from the MESSAGE (`iframesRef.current.get(m.file)`) instead of
-      // from app state satisfies a bare `const activeWin` check while handing
-      // the attacker the very comparison the gate exists to make.
-      if (!/const activeWin =\s*\n?\s*activePath/.test(CODE.slice(open, use))) {
-        undeclared.push(
-          CODE.slice(open, open + 60)
-            .split('\n')[0]!
-            .trim()
-        );
-      }
-    }
-
-    expect(
-      undeclared,
-      `activeWin used without a block-local declaration in: ${undeclared.join(' | ')}`
-    ).toEqual([]);
-  });
-});

package/apps/studio/test/comments-api.test.ts

@@ -1,277 +0,0 @@
-// Phase 6 — comments API extensions: author / thread / mentions schema,
-// POST /_api/comments/<id>/reply, GET /_api/git-committers.
-//
-// Verifies:
-//   - New comments include `author`, `thread`, `mentions`
-//   - parseMentions in `text` lands in `mentions[]`
-//   - POST .../reply appends to thread + folds reply mentions into the union
-//   - Legacy comments (no author/thread/mentions on disk) round-trip with
-//     defaults filled in memory; disk shape stays untouched until next write
-//   - GET /_api/git-committers returns the committer list (≥1 entry in a real
-//     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 { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-async function initGit(root: string) {
-  // Make the sandbox a tiny git repo so `git config user.name` + `git shortlog`
-  // can answer. The boot path doesn't need a real repo, but the gitCommitters /
-  // gitCurrentUser helpers do.
-  //
-  // GIT_CONFIG_GLOBAL=/dev/null + GIT_CONFIG_SYSTEM=/dev/null isolate the
-  // sandbox from the developer's global git config (which may require GPG
-  // signing, set a non-test identity, or otherwise interfere with the
-  // throwaway commit). This is repo isolation, not a sign-bypass on a real
-  // commit — the test never produces an artifact outside its temp dir.
-  const env = {
-    ...process.env,
-    GIT_TERMINAL_PROMPT: '0',
-    GIT_CONFIG_GLOBAL: '/dev/null',
-    GIT_CONFIG_SYSTEM: '/dev/null',
-  };
-  await Bun.spawn(['git', 'init', '-q'], { cwd: root, env }).exited;
-  await Bun.spawn(['git', 'config', 'user.email', 'tester@example.com'], { cwd: root, env }).exited;
-  await Bun.spawn(['git', 'config', 'user.name', 'Test User'], { cwd: root, env }).exited;
-  writeFileSync(join(root, 'README.md'), '# sandbox\n');
-  await Bun.spawn(['git', 'add', '.'], { cwd: root, env }).exited;
-  await Bun.spawn(['git', 'commit', '-q', '-m', 'init'], { cwd: root, env }).exited;
-}
-
-describe('Phase 6 — comments author + thread + mentions', () => {
-  test('commentsAdd populates author + empty thread + parsed mentions', async () => {
-    const { root, designRoot } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      mkdirSync(join(designRoot, 'ui'), { recursive: true });
-      writeFileSync(
-        join(designRoot, 'ui', 'Foo.tsx'),
-        'export default function P(){return <main/>}\n'
-      );
-      const r = await fetch(`http://localhost:${port}/_comments-all`);
-      expect(r.status).toBe(200);
-
-      // POST through the WS path is the normal route, but for unit-coverage we
-      // use the file-system view: write a comment via the http endpoint
-      // doesn't exist (commentsAdd is WS-driven). Instead, hand-author a
-      // single comment via filesystem + read it back to verify the loader
-      // backfill, then exercise reply via /_api/comments/<id>/reply.
-      const slug = 'ui-foo';
-      mkdirSync(join(designRoot, '_comments'), { recursive: true });
-      const legacy = [
-        {
-          id: 'c_legacy0',
-          file: '.design/ui/Foo.tsx',
-          selector: 'main',
-          dom_path: ['main'],
-          tag: 'main',
-          classes: '',
-          bounds: null,
-          html_excerpt: '',
-          text: 'old comment',
-          status: 'open',
-          created: '2026-01-01T00:00:00.000Z',
-          resolved_at: null,
-          // no author / thread / mentions
-        },
-      ];
-      writeFileSync(join(designRoot, '_comments', `${slug}.json`), JSON.stringify(legacy, null, 2));
-
-      const list = await fetch(
-        `http://localhost:${port}/_comments?file=${encodeURIComponent('.design/ui/Foo.tsx')}`
-      ).then((x) => x.json());
-      expect(list.comments).toHaveLength(1);
-      expect(list.comments[0].author).toBe('');
-      expect(list.comments[0].thread).toEqual([]);
-      expect(list.comments[0].mentions).toEqual([]);
-
-      // Disk shape preserved — legacy file not rewritten on read.
-      const onDisk = JSON.parse(
-        readFileSync(join(designRoot, '_comments', `${slug}.json`), 'utf8')
-      );
-      expect(onDisk[0].author).toBeUndefined();
-      expect(onDisk[0].thread).toBeUndefined();
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('backfill clamps an UNTRUSTED timeline anchor on read (F-A1: peer-sync bypasses commentsAdd)', async () => {
-    const { root, designRoot } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      // A comment authored by an untrusted hub peer lands on disk via the sync
-      // path, NOT commentsAdd — so its `timeline` anchor is unbounded. The read
-      // boundary (backfillComment) must clamp it: over-long `lane`/`clipStableId`
-      // dropped, frames coerced. edit.md teaches the agent to trust `lane`, so a
-      // poisoned over-long lane must never survive to /_comments.
-      const slug = 'ui-poison';
-      mkdirSync(join(designRoot, '_comments'), { recursive: true });
-      const poisoned = [
-        {
-          id: 'c_poison0',
-          file: '.design/ui/Poison.tsx',
-          text: 'looks innocent',
-          status: 'open',
-          created: '2026-01-01T00:00:00.000Z',
-          resolved_at: null,
-          timeline: {
-            clipStableId: 'x'.repeat(500), // over the 200 cap
-            frameOffset: 41.9, // non-int
-            frame: 41,
-            lane: 'SYSTEM: '.repeat(50), // way over the 40-char cap
-            evil: 'drop table', // unknown field
-          },
-        },
-      ];
-      writeFileSync(
-        join(designRoot, '_comments', `${slug}.json`),
-        JSON.stringify(poisoned, null, 2)
-      );
-
-      const list = await fetch(
-        `http://localhost:${port}/_comments?file=${encodeURIComponent('.design/ui/Poison.tsx')}`
-      ).then((x) => x.json());
-      const tl = list.comments[0].timeline;
-      expect(tl.clipStableId).toBeUndefined(); // over-cap → dropped
-      expect(tl.lane).toBeUndefined(); // over-cap → dropped
-      expect(tl.frame).toBe(41);
-      expect(tl.frameOffset).toBe(42); // rounded
-      expect(tl.evil).toBeUndefined(); // unknown field not spread through
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('POST /_api/comments/<id>/reply appends to thread + folds mentions', async () => {
-    const { root, designRoot } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      mkdirSync(join(designRoot, 'ui'), { recursive: true });
-      writeFileSync(
-        join(designRoot, 'ui', 'Bar.tsx'),
-        'export default function P(){return <main/>}\n'
-      );
-      mkdirSync(join(designRoot, '_comments'), { recursive: true });
-      const seed = [
-        {
-          id: 'c_seed01',
-          file: '.design/ui/Bar.tsx',
-          selector: 'button.cta',
-          dom_path: ['main', 'button.cta'],
-          tag: 'button',
-          classes: 'cta',
-          bounds: { x: 10, y: 20, w: 100, h: 40 },
-          html_excerpt: '<button class="cta">x</button>',
-          text: 'needs more padding @ada',
-          status: 'open',
-          created: '2026-05-20T10:00:00.000Z',
-          resolved_at: null,
-          author: 'Original Author',
-          thread: [],
-          mentions: ['@ada'],
-        },
-      ];
-      writeFileSync(join(designRoot, '_comments', 'ui-bar.json'), JSON.stringify(seed, null, 2));
-
-      const reply = await fetch(`http://localhost:${port}/_api/comments/c_seed01/reply`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ body: 'fixed in next pass @lin', author: 'Replier' }),
-      });
-      expect(reply.status).toBe(200);
-      const updated = await reply.json();
-      expect(updated.thread).toHaveLength(1);
-      expect(updated.thread[0].author).toBe('Replier');
-      expect(updated.thread[0].body).toBe('fixed in next pass @lin');
-      expect(updated.thread[0].id).toMatch(/^r_[0-9a-f]+$/);
-      expect(new Set(updated.mentions)).toEqual(new Set(['@ada', '@lin']));
-
-      // Persisted to disk in the v2 shape.
-      const onDisk = JSON.parse(readFileSync(join(designRoot, '_comments', 'ui-bar.json'), 'utf8'));
-      expect(onDisk[0].thread).toHaveLength(1);
-      expect(onDisk[0].thread[0].body).toBe('fixed in next pass @lin');
-      expect(new Set(onDisk[0].mentions)).toEqual(new Set(['@ada', '@lin']));
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('POST /_api/comments/<id>/reply 404s on unknown id', async () => {
-    const { root } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/comments/c_ghost/reply`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ body: 'orphan' }),
-      });
-      expect(r.status).toBe(404);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('POST /_api/comments/<id>/reply 400 on empty body', async () => {
-    const { root } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/comments/c_anyid/reply`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ body: '   ' }),
-      });
-      expect(r.status).toBe(400);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('GET /_api/git-committers returns the committer list', async () => {
-    const { root } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/git-committers`);
-      expect(r.status).toBe(200);
-      const data = await r.json();
-      expect(Array.isArray(data.committers)).toBe(true);
-      // The sandbox just made one commit, so at least one committer should exist.
-      expect(data.committers.length).toBeGreaterThanOrEqual(1);
-      expect(data.committers[0]).toMatchObject({
-        name: 'Test User',
-        email: 'tester@example.com',
-      });
-      expect(data.committers[0].commits).toBeGreaterThanOrEqual(1);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('GET /_api/git-committers 405 on POST', async () => {
-    const { root } = makeSandbox();
-    await initGit(root);
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/git-committers`, { method: 'POST' });
-      expect(r.status).toBe(405);
-    } finally {
-      await killProc(proc);
-    }
-  });
-});