@1agh/maude 0.28.1 → 0.30.0

package/plugins/design/dev-server/test/sync-agent.test.ts

@@ -1,305 +0,0 @@
-// Sync-agent integration tests — Phase 9 Task 4.
-//
-// Uses an in-memory pair of Y.Docs cross-linked via Y.applyUpdate as a stand-in
-// for HocuspocusProvider's transport. The agent under test owns docB; docA
-// represents "another peer talking to the hub". Updates flow:
-//
-//   docA → encode → applyUpdate(docB) → agent observes → write to disk
-//   disk → onRead → applyFromFs → applyHtmlToDoc(docB) → encode → docA
-//
-// This lets us validate the whole bidi loop, echo prevention, and the
-// 100-event stress scenario from the plan without booting a real hub.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as Y from 'yjs';
-
-import { type CanvasSyncAgent, createCanvasSyncAgent } from '../sync/agent.ts';
-import { applyHtmlToDoc, htmlFromDoc, Y_SYNC_TYPES } from '../sync/codec.ts';
-import { createEchoGuard, hashBytes } from '../sync/echo-guard.ts';
-import { createFsReader } from '../sync/fs-mirror.ts';
-
-let dir: string;
-let agent: CanvasSyncAgent;
-let docA: Y.Doc;
-let docB: Y.Doc;
-
-function paths() {
-  return {
-    html: join(dir, 'screen.html'),
-    comments: join(dir, '_comments', 'screen.json'),
-    annotations: join(dir, 'screen.annotations.svg'),
-  };
-}
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'sync-agent-'));
-  docA = new Y.Doc();
-  docB = new Y.Doc();
-  // Mirror docA→docB and docB→docA, ignoring transient origin objects from
-  // the transport itself (we use a symbol).
-  const TRANSPORT = Symbol('transport');
-  docA.on('update', (update: Uint8Array, origin: unknown) => {
-    if (origin === TRANSPORT) return;
-    Y.applyUpdate(docB, update, TRANSPORT);
-  });
-  docB.on('update', (update: Uint8Array, origin: unknown) => {
-    if (origin === TRANSPORT) return;
-    Y.applyUpdate(docA, update, TRANSPORT);
-  });
-});
-
-afterEach(() => {
-  agent?.stop();
-  rmSync(dir, { recursive: true, force: true });
-});
-
-function makeAgent(extra: { adopt?: boolean; flushMs?: number } = {}): CanvasSyncAgent {
-  const a = createCanvasSyncAgent({
-    slug: 'screen',
-    doc: docB,
-    paths: paths(),
-    echoGuard: createEchoGuard(),
-    flushMs: 0, // synchronous flush; the agent uses queueMicrotask
-    ...extra,
-  });
-  a.start();
-  return a;
-}
-
-describe('CanvasSyncAgent — hub → disk (Flow B)', () => {
-  test('writes HTML to disk when other peer mutates the doc', async () => {
-    agent = makeAgent();
-    // Other peer types into docA — propagates to docB via the in-memory
-    // transport, which our agent observes.
-    applyHtmlToDoc(docA, '<button>v1</button>');
-    await agent.flush();
-
-    expect(readFileSync(paths().html, 'utf8')).toBe('<button>v1</button>');
-  });
-
-  test('debounces multiple rapid peer edits into one disk write', async () => {
-    agent = makeAgent({ flushMs: 30 });
-    for (let i = 0; i < 10; i++) {
-      applyHtmlToDoc(docA, `<button>v${i}</button>`);
-    }
-    await new Promise((res) => setTimeout(res, 80));
-
-    expect(readFileSync(paths().html, 'utf8')).toBe('<button>v9</button>');
-  });
-
-  test('writes comments JSON when Y.Array changes', async () => {
-    agent = makeAgent();
-    docA.transact(() => {
-      docA.getArray('comments').push([{ id: 'c1', body: 'hello' }]);
-    });
-    await agent.flush();
-
-    const written = JSON.parse(readFileSync(paths().comments, 'utf8'));
-    expect(written).toEqual([{ id: 'c1', body: 'hello' }]);
-  });
-
-  test('writes annotations SVG when Y.Map.svg changes', async () => {
-    agent = makeAgent();
-    docA.transact(() => {
-      docA.getMap('annotations').set('svg', '<svg>annot</svg>');
-    });
-    await agent.flush();
-
-    expect(readFileSync(paths().annotations, 'utf8')).toBe('<svg>annot</svg>');
-  });
-});
-
-describe('CanvasSyncAgent — disk → hub (Flow A)', () => {
-  test('applies disk HTML to doc when applyFromFs is called', () => {
-    agent = makeAgent();
-    const bytes = new TextEncoder().encode('<div>local-edit</div>');
-    const changed = agent.applyFromFs({
-      path: paths().html,
-      bytes,
-      hash: hashBytes(bytes),
-    });
-    expect(changed).toBe(true);
-    expect(htmlFromDoc(docA)).toBe('<div>local-edit</div>');
-  });
-
-  test('parses + applies comments JSON from disk', () => {
-    agent = makeAgent();
-    const snap = [{ id: 'c2' }];
-    const str = `${JSON.stringify(snap, null, 2)}\n`;
-    const bytes = new TextEncoder().encode(str);
-    agent.applyFromFs({ path: paths().comments, bytes, hash: hashBytes(bytes) });
-    expect(docA.getArray('comments').toArray()).toEqual(snap);
-  });
-
-  test('applies annotations SVG from disk', () => {
-    agent = makeAgent();
-    const bytes = new TextEncoder().encode('<svg>x</svg>');
-    agent.applyFromFs({ path: paths().annotations, bytes, hash: hashBytes(bytes) });
-    expect(docA.getMap<string>('annotations').get('svg')).toBe('<svg>x</svg>');
-  });
-
-  test('drops the fs-watch echo of its own atomic write', async () => {
-    agent = makeAgent();
-    // Peer edits → agent writes to disk → echo guard recorded.
-    applyHtmlToDoc(docA, '<button>hi</button>');
-    await agent.flush();
-
-    // Simulate the fs.watch firing for the path we just wrote.
-    const bytes = readFileSync(paths().html);
-    const u8 = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const changed = agent.applyFromFs({
-      path: paths().html,
-      bytes: u8,
-      hash: hashBytes(u8),
-    });
-
-    expect(changed).toBe(false);
-  });
-});
-
-describe('CanvasSyncAgent — cold start reconciliation', () => {
-  test('hub-wins (default): overwrites disk when doc differs', async () => {
-    // Local disk has stale content.
-    writeFileSync(paths().html, '<old>');
-    // Hub state arrives via docA (propagated to docB before reconcile runs).
-    applyHtmlToDoc(docA, '<new>');
-
-    agent = makeAgent();
-    await agent.reconcile();
-
-    expect(readFileSync(paths().html, 'utf8')).toBe('<new>');
-  });
-
-  test('adopt mode: pushes local disk state up to the doc', async () => {
-    writeFileSync(paths().html, '<button>local</button>');
-    // Hub has stale content.
-    applyHtmlToDoc(docA, '<old-hub>');
-
-    agent = makeAgent({ adopt: true });
-    await agent.reconcile();
-
-    expect(htmlFromDoc(docA)).toBe('<button>local</button>');
-    expect(htmlFromDoc(docB)).toBe('<button>local</button>');
-  });
-
-  test('adopt mode is one-shot — second reconcile is hub-wins', async () => {
-    writeFileSync(paths().html, '<button>local-v1</button>');
-    agent = makeAgent({ adopt: true });
-    await agent.reconcile();
-
-    // Hub changes the value.
-    applyHtmlToDoc(docA, '<button>hub-v2</button>');
-
-    // Disk reverts to a stale local-only state.
-    writeFileSync(paths().html, '<button>local-v3</button>');
-    await agent.reconcile();
-
-    // Hub state won this time.
-    expect(htmlFromDoc(docB)).toBe('<button>hub-v2</button>');
-  });
-
-  test('empty hub doc does NOT clobber a non-empty local body — seeds local up instead (data-loss guard)', async () => {
-    // Local holds the real canvas body; the hub is fresh — no state for this
-    // slug yet (docB starts empty → docHtml === ''). The old behaviour wrote
-    // the empty doc over disk and emptied the file; the guard must keep local.
-    writeFileSync(paths().html, '<button>real-canvas</button>');
-
-    let conflicts = 0;
-    agent = createCanvasSyncAgent({
-      slug: 'screen',
-      doc: docB,
-      paths: paths(),
-      echoGuard: createEchoGuard(),
-      flushMs: 0,
-      onConflict: () => {
-        conflicts++;
-      },
-    });
-    agent.start();
-    await agent.reconcile();
-
-    // The local body MUST survive — an empty hub must never empty a real canvas.
-    expect(readFileSync(paths().html, 'utf8')).toBe('<button>real-canvas</button>');
-    // …and it is seeded UP to the hub instead of being discarded (local→doc).
-    expect(htmlFromDoc(docA)).toBe('<button>real-canvas</button>');
-    // An empty-hub seed is not a "hub overwrote your local" conflict.
-    expect(conflicts).toBe(0);
-  });
-
-  test('identical disk + doc states: no disk write', async () => {
-    writeFileSync(paths().html, '<button>same</button>');
-    applyHtmlToDoc(docA, '<button>same</button>');
-
-    agent = makeAgent();
-    let writes = 0;
-    const customAgent = createCanvasSyncAgent({
-      slug: 'screen',
-      doc: docB,
-      paths: paths(),
-      echoGuard: createEchoGuard(),
-      flushMs: 0,
-      writer: () => {
-        writes++;
-      },
-    });
-    customAgent.start();
-    await customAgent.reconcile();
-    customAgent.stop();
-
-    expect(writes).toBe(0);
-  });
-});
-
-describe('CanvasSyncAgent — stress: 100 rapid disk writes converge with no echo loop', () => {
-  test('100-event scenario from plan validate', async () => {
-    // Wire up fs-mirror against the temp dir so this looks like the production
-    // flow: file writes → fs.watch → fs-mirror debounce → agent.applyFromFs.
-    agent = makeAgent({ flushMs: 20 });
-
-    const reader = createFsReader({
-      rootDir: dir,
-      quietMs: 15,
-      accept: (p) => p.endsWith('.html'),
-      onRead: async (evt) => {
-        agent.applyFromFs({
-          path: join(dir, evt.path),
-          bytes: evt.bytes,
-          hash: evt.hash,
-        });
-      },
-    });
-
-    // Track how many times the doc transitioned — should be bounded, no echo
-    // loop multiplying it.
-    let docUpdates = 0;
-    docB.on('update', () => {
-      docUpdates++;
-    });
-
-    for (let i = 0; i < 100; i++) {
-      writeFileSync(paths().html, `<button>${i}</button>`);
-      reader.notify('screen.html');
-    }
-
-    // Let everything settle: reader quiet (15ms), agent flush (20ms) + slack.
-    await new Promise((res) => setTimeout(res, 200));
-    await reader.flush();
-    await agent.flush();
-    reader.stop();
-
-    // Doc + disk + peer all converge on the last write.
-    const last = '<button>99</button>';
-    expect(htmlFromDoc(docB)).toBe(last);
-    expect(htmlFromDoc(docA)).toBe(last);
-    expect(readFileSync(paths().html, 'utf8')).toBe(last);
-
-    // Update count must be bounded — strictly < 100 transitions (debounce did
-    // its job) AND < 200 (no echo loop running 2x amplification).
-    expect(docUpdates).toBeLessThan(200);
-    // Also: it should be > 0 — we DID see real syncs.
-    expect(docUpdates).toBeGreaterThan(0);
-  });
-});

package/plugins/design/dev-server/test/use-annotation-resize.test.ts

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