@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/sync-meta-codec.test.ts

@@ -1,199 +0,0 @@
-// Gap 2 — .meta.json shared-layout sync codec.
-//
-// Artboard layout must propagate as a file diff (one machine moves an artboard →
-// the other's .meta.json layout converges), while each user's pan/zoom
-// (`viewport`) and the security opt-in (`syncable`) stay strictly local. These
-// tests pin that split: applyMetaToDoc stores only the shared subset, and
-// mergeSharedMetaIntoLocal layers it back without trampling local-only keys.
-
-import { describe, expect, test } from 'bun:test';
-import * as Y from 'yjs';
-
-import {
-  applyCssToDoc,
-  applyMetaToDoc,
-  cssFromDoc,
-  META_LOCAL_KEYS,
-  mergeSharedMetaIntoLocal,
-  metaFromDoc,
-  normalizeSharedMeta,
-  repairSharedMeta,
-} from '../sync/codec.ts';
-
-describe('Gap 2 — meta codec: shared layout syncs, per-user keys stay local', () => {
-  test('applyMetaToDoc stores ONLY the shared subset (viewport/last_modified/syncable stripped)', () => {
-    const doc = new Y.Doc();
-    const full = JSON.stringify({
-      title: 'Kanban',
-      layout: { 'ab-1': { x: 10, y: 20 } },
-      viewport: { x: 999, y: 888, zoom: 0.5 },
-      last_modified: '2026-01-01T00:00:00Z',
-      syncable: true,
-    });
-    expect(applyMetaToDoc(doc, full)).toBe(true);
-
-    const shared = JSON.parse(metaFromDoc(doc) as string);
-    expect(shared.title).toBe('Kanban');
-    expect(shared.layout).toEqual({ 'ab-1': { x: 10, y: 20 } });
-    // The three per-machine keys never enter the synced doc.
-    expect(shared.viewport).toBeUndefined();
-    expect(shared.last_modified).toBeUndefined();
-    expect(shared.syncable).toBeUndefined();
-  });
-
-  test('applyMetaToDoc is a NO-OP when only per-user keys differ (no churn from panning)', () => {
-    const doc = new Y.Doc();
-    applyMetaToDoc(doc, JSON.stringify({ title: 'X', viewport: { x: 1 } }));
-    // Same shared content, different viewport → must not register a change,
-    // otherwise every pan would emit a sync op.
-    expect(applyMetaToDoc(doc, JSON.stringify({ title: 'X', viewport: { x: 2 } }))).toBe(false);
-  });
-
-  test('mergeSharedMetaIntoLocal takes shared layout, PRESERVES local viewport + syncable', () => {
-    const shared = JSON.stringify({ title: 'Kanban', layout: { 'ab-1': { x: 10, y: 20 } } });
-    const local = JSON.stringify({
-      title: 'Kanban (stale)',
-      layout: { 'ab-1': { x: 0, y: 0 } },
-      viewport: { x: 42, y: 7, zoom: 1.5 },
-      syncable: false,
-      last_modified: 'local-ts',
-    });
-    const merged = JSON.parse(mergeSharedMetaIntoLocal(local, shared) as string);
-    expect(merged.layout).toEqual({ 'ab-1': { x: 10, y: 20 } }); // shared layout won
-    expect(merged.title).toBe('Kanban'); // shared title won
-    expect(merged.viewport).toEqual({ x: 42, y: 7, zoom: 1.5 }); // LOCAL viewport kept
-    expect(merged.syncable).toBe(false); // LOCAL opt-in kept (security invariant)
-    expect(merged.last_modified).toBe('local-ts'); // local timestamp kept
-  });
-
-  test('round-trip: artboard move on A reaches B without touching B viewport / syncable', () => {
-    const aDoc = new Y.Doc();
-    applyMetaToDoc(
-      aDoc,
-      JSON.stringify({
-        title: 'K',
-        layout: { 'ab-1': { x: 100, y: 200 } },
-        viewport: { zoom: 0.5 },
-        syncable: true,
-      })
-    );
-    const shared = metaFromDoc(aDoc) as string;
-
-    const bLocal = JSON.stringify({
-      title: 'K',
-      layout: { 'ab-1': { x: 0, y: 0 } },
-      viewport: { zoom: 2.0 },
-      syncable: false,
-    });
-    const bMerged = JSON.parse(mergeSharedMetaIntoLocal(bLocal, shared) as string);
-    expect(bMerged.layout['ab-1']).toEqual({ x: 100, y: 200 }); // A's move landed on B
-    expect(bMerged.viewport).toEqual({ zoom: 2.0 }); // B's camera untouched
-    expect(bMerged.syncable).toBe(false); // B's opt-in untouched
-  });
-
-  test('a freshly-cloned peer with no local viewport just takes the shared subset', () => {
-    const merged = JSON.parse(
-      mergeSharedMetaIntoLocal('{}', JSON.stringify({ title: 'K', layout: { a: 1 } })) as string
-    );
-    expect(merged).toEqual({ title: 'K', layout: { a: 1 } });
-  });
-
-  test('META_LOCAL_KEYS pins the never-synced set', () => {
-    expect([...META_LOCAL_KEYS].sort()).toEqual(['last_modified', 'syncable', 'viewport']);
-  });
-
-  test('mergeSharedMetaIntoLocal returns null on an unparseable shared payload', () => {
-    expect(mergeSharedMetaIntoLocal('{}', 'not json')).toBeNull();
-  });
-});
-
-describe('Gap 3 — css codec (opaque wholesale text)', () => {
-  test('applyCssToDoc round-trips the css string', () => {
-    const doc = new Y.Doc();
-    expect(cssFromDoc(doc)).toBeNull();
-    const css = '.ka-card { color: red; }\n';
-    expect(applyCssToDoc(doc, css)).toBe(true);
-    expect(cssFromDoc(doc)).toBe(css);
-  });
-
-  test('applyCssToDoc is a no-op when unchanged (loop-safe)', () => {
-    const doc = new Y.Doc();
-    applyCssToDoc(doc, '.x{}');
-    expect(applyCssToDoc(doc, '.x{}')).toBe(false);
-    expect(applyCssToDoc(doc, '.x{ color: blue }')).toBe(true);
-  });
-});
-
-describe('a duplicated meta lane — the shape two peers publishing at once leaves', () => {
-  // Meta is a WHOLE VALUE in a Y.Text, written delete-all + insert-all. Two
-  // peers inserting the same string into an empty lane produce two inserts Yjs
-  // has no reason to merge, and the result — `{"a":1}{"a":1}` — is not empty
-  // and not parseable. Every consumer ran it through JSON.parse and bailed, so
-  // a canvas silently lost its title, kind and design-system binding on every
-  // machine that synced the project afterwards.
-  //
-  // Observed live on nine canvases at once, all created on the same laptop.
-
-  const ONE = '{"kind":"web","title":"Home"}';
-
-  function docWith(text: string): Y.Doc {
-    const d = new Y.Doc();
-    d.getText('meta').insert(0, text);
-    return d;
-  }
-
-  test('normalizeSharedMeta collapses identical copies to one', () => {
-    expect(normalizeSharedMeta(ONE + ONE)).toBe(ONE);
-    expect(normalizeSharedMeta(ONE + ONE + ONE)).toBe(ONE);
-  });
-
-  test('a single value passes through untouched', () => {
-    expect(normalizeSharedMeta(ONE)).toBe(ONE);
-  });
-
-  test('empty stays null — that is a real answer, not a broken one', () => {
-    expect(normalizeSharedMeta('')).toBeNull();
-    expect(normalizeSharedMeta(null)).toBeNull();
-  });
-
-  test('it repairs only what it can PROVE — differing copies stay null', () => {
-    // Two DIFFERENT values concatenated is not a duplication; it is a
-    // disagreement, and picking one would be inventing a winner. Null routes it
-    // to "the doc has no usable opinion", where local meta seeds instead.
-    expect(normalizeSharedMeta('{"title":"A"}{"title":"B"}')).toBeNull();
-    expect(normalizeSharedMeta('not json at all')).toBeNull();
-    expect(normalizeSharedMeta('[1,2]')).toBeNull();
-  });
-
-  test('a value CONTAINING "}{" is not mistaken for a seam', () => {
-    // Each segment must itself parse as a complete object, so a brace pair
-    // inside a string cannot manufacture a false split.
-    const tricky = JSON.stringify({ title: 'a}{b' });
-    expect(normalizeSharedMeta(tricky)).toBe(tricky);
-  });
-
-  test('metaFromDoc hands consumers the single value', () => {
-    expect(metaFromDoc(docWith(ONE + ONE))).toBe(ONE);
-  });
-
-  test('repairSharedMeta collapses the lane in place', () => {
-    const d = docWith(ONE + ONE);
-    expect(repairSharedMeta(d)).toBe(true);
-    expect(d.getText('meta').toString()).toBe(ONE);
-    // Idempotent — a repaired lane is not repaired again, so this cannot churn.
-    expect(repairSharedMeta(d)).toBe(false);
-  });
-
-  test('repair leaves an unrepairable lane exactly as it found it', () => {
-    const d = docWith('{"title":"A"}{"title":"B"}');
-    expect(repairSharedMeta(d)).toBe(false);
-    expect(d.getText('meta').toString()).toBe('{"title":"A"}{"title":"B"}');
-  });
-
-  test('applying the same meta over a duplicated lane is a no-op, not a rewrite', () => {
-    // Comparing against the literal text would see a difference every pass and
-    // rewrite forever.
-    const d = docWith(ONE + ONE);
-    expect(applyMetaToDoc(d, ONE)).toBe(false);
-  });
-});

package/apps/studio/test/sync-migrate-flat-fallback.test.ts

@@ -1,98 +0,0 @@
-// Fix 4 of the 2026-08-10 sync RCA — the one-shot quarantine of pre-fix-5
-// flat fallback twins. The rules under test: a flat body moves ONLY when a
-// grouped twin of the same slug exists; siblings ride along; annotations stay
-// (they serve the surviving twin); a lone flat canvas is somebody's work and
-// never moves; a second run is a no-op; nothing ever throws into boot.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { migrateFlatFallback } from '../sync/migrate-flat-fallback.ts';
-
-let designRoot: string;
-
-beforeEach(() => {
-  designRoot = mkdtempSync(join(tmpdir(), 'migrate-flat-'));
-});
-
-afterEach(() => {
-  rmSync(designRoot, { recursive: true, force: true });
-});
-
-const run = () => migrateFlatFallback({ designRoot, designRel: '.design', log: () => {} });
-
-describe('migrateFlatFallback — quarantine the redundant flat copy, never work', () => {
-  test('a collision pair: the flat copy (+ siblings) moves to _trash, the grouped twin stays', () => {
-    mkdirSync(join(designRoot, 'ui'), { recursive: true });
-    writeFileSync(join(designRoot, 'ui/welcome.tsx'), 'grouped\n');
-    writeFileSync(join(designRoot, 'ui-welcome.tsx'), 'flat stub\n');
-    writeFileSync(join(designRoot, 'ui-welcome.meta.json'), '{}\n');
-    writeFileSync(join(designRoot, 'ui-welcome.css'), '.x{}\n');
-    // Annotations are keyed by the flat slug and serve the SURVIVING twin.
-    writeFileSync(join(designRoot, 'ui-welcome.annotations.svg'), '<svg/>\n');
-
-    const moves = run();
-
-    expect(moves).toHaveLength(1);
-    expect(moves[0].slug).toBe('ui-welcome');
-    expect(moves[0].from).toBe('ui-welcome.tsx');
-    expect(moves[0].keptTwin).toBe('ui/welcome.tsx');
-
-    expect(existsSync(join(designRoot, 'ui/welcome.tsx'))).toBe(true);
-    expect(existsSync(join(designRoot, 'ui-welcome.tsx'))).toBe(false);
-    expect(existsSync(join(designRoot, 'ui-welcome.meta.json'))).toBe(false);
-    expect(existsSync(join(designRoot, 'ui-welcome.css'))).toBe(false);
-    expect(existsSync(join(designRoot, 'ui-welcome.annotations.svg'))).toBe(true);
-
-    const trashed = readdirSync(join(designRoot, moves[0].trashedTo)).sort();
-    expect(trashed).toEqual(['ui-welcome.css', 'ui-welcome.meta.json', 'ui-welcome.tsx']);
-  });
-
-  test('a lone flat canvas has no twin — it is somebody’s work and stays put', () => {
-    writeFileSync(join(designRoot, 'scratch-pad.tsx'), 'mine\n');
-    expect(run()).toEqual([]);
-    expect(existsSync(join(designRoot, 'scratch-pad.tsx'))).toBe(true);
-  });
-
-  test('a grouped file with no flat twin is untouched', () => {
-    mkdirSync(join(designRoot, 'ui'), { recursive: true });
-    writeFileSync(join(designRoot, 'ui/card.tsx'), 'x\n');
-    expect(run()).toEqual([]);
-    expect(existsSync(join(designRoot, 'ui/card.tsx'))).toBe(true);
-  });
-
-  test('the second run is a no-op — the quarantine dir is runtime state the scan skips', () => {
-    mkdirSync(join(designRoot, 'ui'), { recursive: true });
-    writeFileSync(join(designRoot, 'ui/welcome.tsx'), 'grouped\n');
-    writeFileSync(join(designRoot, 'ui-welcome.tsx'), 'flat stub\n');
-
-    expect(run()).toHaveLength(1);
-    expect(run()).toEqual([]);
-    // The quarantined copy is still there — moved, never deleted.
-    const trash = readdirSync(join(designRoot, '_trash'));
-    expect(trash).toHaveLength(1);
-  });
-
-  test('nested twins at any depth count', () => {
-    mkdirSync(join(designRoot, 'ui/2026/social'), { recursive: true });
-    writeFileSync(join(designRoot, 'ui/2026/social/summer-camp.tsx'), 'deep\n');
-    writeFileSync(join(designRoot, 'ui-2026-social-summer-camp.tsx'), 'flat stub\n');
-
-    const moves = run();
-    expect(moves).toHaveLength(1);
-    expect(moves[0].keptTwin).toBe('ui/2026/social/summer-camp.tsx');
-    expect(existsSync(join(designRoot, 'ui/2026/social/summer-camp.tsx'))).toBe(true);
-  });
-
-  test('a missing design root is a quiet no-op, not a throw', () => {
-    expect(
-      migrateFlatFallback({
-        designRoot: join(designRoot, 'does-not-exist'),
-        designRel: '.design',
-        log: () => {},
-      })
-    ).toEqual([]);
-  });
-});

package/apps/studio/test/sync-move-retirement.test.ts

@@ -1,231 +0,0 @@
-// The MOVE protocol — a moved canvas retires its old document (stampMovedTo).
-//
-// Before this existed, moving a canvas minted a new slug + new document and
-// the OLD document simply lived on: the hub kept materialising it at the old
-// path, every peer's cold start saw "doc has a body, disk has no file" and
-// resurrected it, and the canvas came back as a duplicate on every machine.
-// Observed live: `shoj` moved into a folder left BOTH paths on both machines
-// and two documents on the hub.
-//
-// What is pinned here:
-//   1. the stamp round-trips and is idempotent;
-//   2. a retired doc is WRITE-INERT in every direction, for both disk
-//      handlers (agent and projection) — no doc→file materialise, no
-//      file→doc revival;
-//   3. retirement is an explicit statement, never inferred from emptiness —
-//      an un-stamped doc behaves exactly as before.
-
-import { describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as Y from 'yjs';
-
-import { createCanvasSyncAgent } from '../sync/agent.ts';
-import { applyHtmlToDoc, htmlFromDoc, movedToFromDoc, stampMovedTo } from '../sync/codec.ts';
-import { createEchoGuard, hashBytes } from '../sync/echo-guard.ts';
-import { createDocProjection } from '../sync/projection.ts';
-
-function tempDir(): string {
-  return mkdtempSync(join(tmpdir(), 'sync-retire-'));
-}
-
-describe('the stamp', () => {
-  test('round-trips, with where the canvas went', () => {
-    const doc = new Y.Doc();
-    expect(movedToFromDoc(doc)).toBe(null);
-    expect(stampMovedTo(doc, 'ui/folder/screen.tsx')).toBe(true);
-    expect(movedToFromDoc(doc)).toBe('ui/folder/screen.tsx');
-  });
-
-  test('is idempotent — restamping the same target writes nothing', () => {
-    const doc = new Y.Doc();
-    stampMovedTo(doc, 'ui/a/b.tsx');
-    let updates = 0;
-    doc.on('update', () => updates++);
-    expect(stampMovedTo(doc, 'ui/a/b.tsx')).toBe(false);
-    expect(updates).toBe(0);
-  });
-
-  test('crosses the wire like any syncMeta', () => {
-    const a = new Y.Doc();
-    const b = new Y.Doc();
-    a.on('update', (u: Uint8Array) => Y.applyUpdate(b, u));
-    stampMovedTo(a, 'ui/x.tsx');
-    expect(movedToFromDoc(b)).toBe('ui/x.tsx');
-  });
-});
-
-describe('a retired doc is write-inert — the agent', () => {
-  test('doc→file: a peer update on a retired doc lands nothing on disk', async () => {
-    const dir = tempDir();
-    try {
-      const doc = new Y.Doc();
-      const paths = {
-        html: join(dir, 'screen.html'),
-        comments: join(dir, '_comments', 'screen.json'),
-        annotations: join(dir, 'screen.annotations.svg'),
-      };
-      const agent = createCanvasSyncAgent({
-        slug: 'screen',
-        doc,
-        paths,
-        echoGuard: createEchoGuard(),
-        flushMs: 0,
-      });
-      agent.start();
-
-      stampMovedTo(doc, 'ui/moved/screen.tsx');
-      applyHtmlToDoc(doc, '<main>ghost</main>');
-      await agent.flush();
-
-      // The resurrection: this file appearing is exactly the bug.
-      expect(existsSync(paths.html)).toBe(false);
-      agent.stop();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('file→doc: a local edit to a stale pre-move file does not revive the doc', () => {
-    const dir = tempDir();
-    try {
-      const doc = new Y.Doc();
-      const paths = {
-        html: join(dir, 'screen.html'),
-        comments: join(dir, '_comments', 'screen.json'),
-        annotations: join(dir, 'screen.annotations.svg'),
-      };
-      const agent = createCanvasSyncAgent({
-        slug: 'screen',
-        doc,
-        paths,
-        echoGuard: createEchoGuard(),
-        flushMs: 0,
-      });
-      agent.start();
-      stampMovedTo(doc, 'ui/moved/screen.tsx');
-
-      const bytes = new TextEncoder().encode('<main>stale local edit</main>');
-      const applied = agent.applyFromFs({
-        path: paths.html,
-        bytes,
-        hash: hashBytes('<main>stale local edit</main>'),
-      });
-
-      expect(applied).toBe(false);
-      expect(htmlFromDoc(doc)).toBe('');
-      agent.stop();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('reconcile materialises nothing from a retired doc', async () => {
-    const dir = tempDir();
-    try {
-      const doc = new Y.Doc();
-      applyHtmlToDoc(doc, '<main>content from before the move</main>');
-      stampMovedTo(doc, 'ui/moved/screen.tsx');
-      const paths = {
-        html: join(dir, 'screen.html'),
-        comments: join(dir, '_comments', 'screen.json'),
-        annotations: join(dir, 'screen.annotations.svg'),
-      };
-      const agent = createCanvasSyncAgent({
-        slug: 'screen',
-        doc,
-        paths,
-        echoGuard: createEchoGuard(),
-        flushMs: 0,
-      });
-      agent.start();
-      await agent.reconcile();
-
-      expect(existsSync(paths.html)).toBe(false);
-      agent.stop();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('and the CONTROL: without the stamp, the very same doc materialises', async () => {
-    // The guard must be the stamp, not some accident of the harness.
-    const dir = tempDir();
-    try {
-      const doc = new Y.Doc();
-      applyHtmlToDoc(doc, '<main>live</main>');
-      const paths = {
-        html: join(dir, 'screen.html'),
-        comments: join(dir, '_comments', 'screen.json'),
-        annotations: join(dir, 'screen.annotations.svg'),
-      };
-      const agent = createCanvasSyncAgent({
-        slug: 'screen',
-        doc,
-        paths,
-        echoGuard: createEchoGuard(),
-        flushMs: 0,
-      });
-      agent.start();
-      await agent.reconcile();
-
-      expect(readFileSync(paths.html, 'utf8')).toBe('<main>live</main>');
-      agent.stop();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('a retired doc is write-inert — the projection', () => {
-  test('doc→file reconcile + flush land nothing', async () => {
-    const dir = tempDir();
-    try {
-      const doc = new Y.Doc();
-      applyHtmlToDoc(doc, '<main>ghost</main>');
-      stampMovedTo(doc, 'ui/moved/screen.tsx');
-      const proj = createDocProjection({
-        slug: 'screen',
-        doc,
-        paths: { html: join(dir, 'screen.tsx') },
-        flushMs: 0,
-      });
-      proj.start();
-      proj.reconcile();
-      await proj.flush();
-
-      expect(existsSync(join(dir, 'screen.tsx'))).toBe(false);
-      proj.stop();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('file→doc refuses too', () => {
-    const dir = tempDir();
-    try {
-      const doc = new Y.Doc();
-      stampMovedTo(doc, 'ui/moved/screen.tsx');
-      const abs = join(dir, 'screen.tsx');
-      writeFileSync(abs, '<main>stale</main>');
-      const proj = createDocProjection({
-        slug: 'screen',
-        doc,
-        paths: { html: abs },
-        flushMs: 0,
-      });
-      proj.start();
-      const applied = proj.applyFromFs({
-        path: abs,
-        bytes: new TextEncoder().encode('<main>stale</main>'),
-        hash: hashBytes('<main>stale</main>'),
-      });
-      expect(applied).toBe(false);
-      expect(htmlFromDoc(doc)).toBe('');
-      proj.stop();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/apps/studio/test/sync-panel-surface.test.ts

@@ -1,153 +0,0 @@
-// feature-sync-progress-modal — the Sync panel + HUB SYNC chip surface.
-//
-// Source-level assertions (cloud-shell-surfaces style): what these pin is
-// exactly what would regress — someone dropping the linked-only gate (a solo
-// project would get a dock tab that opens onto nothing), rewiring the chip
-// away from the dock helpers (breaking the one-panel-per-side invariant), or
-// the panel inventing sync vocabulary / dropping the a11y live region the
-// CloudBar note established.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const STUDIO = join(import.meta.dir, '..');
-const APP = readFileSync(join(STUDIO, 'client', 'app.jsx'), 'utf8');
-const PANEL = readFileSync(join(STUDIO, 'client', 'panels', 'SyncPanel.jsx'), 'utf8');
-
-describe('the Sync panel exists only where a hub link exists', () => {
-  test('sync is a dock panel with a right-side default', () => {
-    expect(APP).toContain("{ id: 'sync', label: 'Sync' }");
-    expect(APP).toMatch(/sync: 'right'/);
-  });
-
-  test('panelAvailable gates sync on a live syncStatus — solo projects get no tab', () => {
-    expect(APP).toContain("if (id === 'sync') return !!syncStatus;");
-  });
-
-  test('the chip toggles through the dock helpers, not a raw setState', () => {
-    // toggleRightPanel keeps the one-panel-per-side invariant; a bare
-    // setSyncPanelOpen(true) here would let Sync render behind an open sibling.
-    expect(APP).toMatch(/onOpenSync=\{syncStatus \? \(\) => toggleRightPanel\('sync'\)/);
-  });
-
-  test('the chip is a real button with pressed-state semantics', () => {
-    expect(APP).toContain('data-testid="open-sync"');
-    expect(APP).toMatch(/aria-pressed=\{syncOpen\}/);
-  });
-
-  test('the span fallback remains for sessions without a handler', () => {
-    // Older wiring / no-handler renders must keep the passive chip rather
-    // than a dead button.
-    expect(APP).toMatch(/onOpenSync \? \(/);
-  });
-});
-
-describe('the Sync panel speaks the presentation vocabulary, safely', () => {
-  test('the header sentence comes from syncPresentation — the one shared rule', () => {
-    expect(PANEL).toContain("from '../../sync/presentation.ts'");
-    expect(PANEL).toContain('syncPresentation(status');
-  });
-
-  test('rows map DocSyncState onto existing words, never new ones', () => {
-    expect(PANEL).toMatch(/pending: 'syncing'/);
-    expect(PANEL).toMatch(/connected: 'synced'/);
-    expect(PANEL).toMatch(/'auth-rejected': 'refused'/);
-  });
-
-  test('every name that reaches the DOM goes through safeName', () => {
-    // Slugs and asset keys are local, but the payload is read back off disk —
-    // bounded text-only rendering is the house rule (DDR-054).
-    expect(PANEL).toContain('import { safeDetail, safeName, syncPresentation }');
-    expect(PANEL).not.toMatch(/dangerouslySetInnerHTML/);
-  });
-
-  test('the live header is a polite status region (the CloudBar a11y pattern)', () => {
-    expect(PANEL).toMatch(/role="status" aria-live="polite"/);
-  });
-
-  test('the asset lane renders from the payload, with the retry promise', () => {
-    expect(PANEL).toContain('data-testid="sync-assets"');
-    expect(PANEL).toContain('retry on the next launch');
-  });
-});
-
-describe('the panel reads the off-disk payload fail-closed (DDR-102 discipline)', () => {
-  test('items, assets and the header counts all pass a readCounts-style gate', () => {
-    // `_sync.json` is JSON.parse with no schema — a partial write or older
-    // producer must degrade to "nothing to show", never crash or print NaN
-    // (security review 2026-08-11, defender W1).
-    expect(PANEL).toContain('function readItems(');
-    expect(PANEL).toContain('function readAssets(');
-    expect(PANEL).toContain('readItems(status?.items)');
-    expect(PANEL).toContain('readAssets(status?.assets)');
-    expect(PANEL).toMatch(/Number\.isInteger/);
-    // The header chip validates the same counts the note fails closed on.
-    expect(PANEL).toMatch(
-      /\[rawDocs\.synced, rawDocs\.pending, rawDocs\.rejected\]\.every\(isCount\)/
-    );
-  });
-});
-
-// feature-sync-resync-and-out-of-process-sweep — the panel gained the one
-// control the whole feature exists for. What is pinned here is not that a
-// button renders, but the three properties that make it safe to press: it
-// re-runs the WHOLE sync (not just assets), it cannot be spammed, and cancel
-// reaches only the sweep.
-describe('the Resync control', () => {
-  test('it calls the whole-sync route, not an asset-only one', () => {
-    expect(PANEL).toContain("fetch('/_api/sync/resync'");
-    expect(PANEL).toContain('data-testid="sync-resync"');
-  });
-
-  test('it disables itself while running AND during the cooldown', () => {
-    // A resync re-authenticates every document against the DDR-102 600/min
-    // bucket; without the cooldown an impatient person pins their own hub.
-    expect(PANEL).toContain('disabled={resyncing || cooling}');
-    expect(PANEL).toMatch(/RESYNC_COOLDOWN_MS = [\d_]+/);
-  });
-
-  test('a 409 reads as "already restarting", never as a failure', () => {
-    expect(PANEL).toMatch(/res\.status === 409/);
-  });
-
-  test('cancel is scoped to the sweep and only offered while one runs', () => {
-    expect(PANEL).toContain("fetch('/_api/sync/cancel-assets'");
-    expect(PANEL).toContain('data-testid="sync-assets-cancel"');
-    expect(PANEL).toMatch(/!assets\.finished && \(/);
-  });
-
-  test('the note is sanitized too — server detail is still bounded text', () => {
-    expect(PANEL).toContain("safeDetail(note, '')");
-  });
-
-  test('it is ABSENT in the cloud — the hub refuses that route on purpose', () => {
-    // A cell's sync runtime serves the project to everyone in it, so cycling it
-    // is an operator action and the hub refuses the route (v0.60.2). The panel
-    // used to render the button regardless, so a cloud member could press a
-    // control that cannot work by design and got an error sentence for it.
-    // See `.ai/logs/rca/issue-cloud-assets-open-findings.md` §5.
-    expect(PANEL).toMatch(/\{!cloud && \(/);
-    expect(PANEL).toMatch(/cloud = null,/);
-  });
-});
-
-describe('a held breaker is visible, because a log line is not a surface', () => {
-  // The finding: `deleteHeld` / `firstAnchorHeld` / `reanchorHeld` shipped
-  // with no consumer at all — declared, assigned, and read by nothing. So the
-  // breakers the release leans on had their entire output in a dev-server
-  // console, on a product whose premise (DDR-177) is that the user never opens
-  // a terminal. A hold that nobody can see is a stall, not a safety control.
-  test('the panel renders every hold the status carries', () => {
-    expect(PANEL).toContain('files.held');
-    expect(PANEL).toMatch(/data-testid=\{`sync-held-\$\{h\.kind\}`\}/);
-  });
-
-  test('it says nothing was removed — the reassurance IS the message', () => {
-    expect(PANEL).toContain('nothing was removed');
-  });
-
-  test('it names the files, so a person can judge whether it was deliberate', () => {
-    expect(PANEL).toMatch(/h\.paths/);
-  });
-});