@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/annotation-strokes-command.test.ts

@@ -1,166 +0,0 @@
-import { describe, expect, mock, test } from 'bun:test';
-
-import type { PenStroke, RectStroke, Stroke } from '../annotations-layer.tsx';
-import { createAnnotationStrokesCommand } from '../commands/annotation-strokes-command.ts';
-
-const pen1: PenStroke = {
-  id: 'pen-1',
-  tool: 'pen',
-  color: '#000',
-  width: 2,
-  points: [
-    [0, 0],
-    [10, 10],
-  ],
-};
-
-const pen2: PenStroke = {
-  id: 'pen-2',
-  tool: 'pen',
-  color: '#f00',
-  width: 4,
-  points: [[20, 20]],
-};
-
-const rect1: RectStroke = {
-  id: 'rect-1',
-  tool: 'rect',
-  color: '#000',
-  width: 2,
-  x: 0,
-  y: 0,
-  w: 50,
-  h: 30,
-  fill: null,
-};
-
-describe('createAnnotationStrokesCommand', () => {
-  test('do() PUTs the AFTER set', async () => {
-    const putFn = mock(() => Promise.resolve());
-    const cmd = createAnnotationStrokesCommand({
-      before: [],
-      after: [pen1],
-      putFn,
-    });
-    await cmd.do();
-    expect(putFn).toHaveBeenCalledTimes(1);
-    expect(putFn.mock.calls[0]?.[0]).toEqual([pen1]);
-  });
-
-  test('undo() PUTs the BEFORE set', async () => {
-    const putFn = mock(() => Promise.resolve());
-    const cmd = createAnnotationStrokesCommand({
-      before: [pen1],
-      after: [pen1, pen2],
-      putFn,
-    });
-    await cmd.undo();
-    expect(putFn).toHaveBeenCalledTimes(1);
-    expect(putFn.mock.calls[0]?.[0]).toEqual([pen1]);
-  });
-
-  test('round-trip — add stroke then undo restores empty', async () => {
-    const calls: Stroke[][] = [];
-    const putFn: (next: readonly Stroke[]) => Promise<void> = (next) => {
-      calls.push([...next]);
-      return Promise.resolve();
-    };
-    const cmd = createAnnotationStrokesCommand({
-      before: [],
-      after: [pen1],
-      putFn,
-    });
-    await cmd.do();
-    await cmd.undo();
-    await cmd.do(); // redo
-    expect(calls).toEqual([[pen1], [], [pen1]]);
-  });
-
-  test('eraser path — before has stroke, after is empty', async () => {
-    const putFn = mock(() => Promise.resolve());
-    const cmd = createAnnotationStrokesCommand({
-      before: [pen1],
-      after: [],
-      putFn,
-    });
-    expect(cmd.label).toBe('erase 1 stroke');
-    await cmd.do();
-    expect(putFn.mock.calls[0]?.[0]).toEqual([]);
-    await cmd.undo();
-    expect(putFn.mock.calls[1]?.[0]).toEqual([pen1]);
-  });
-
-  test("do() passes the pre-op BEFORE as putFn's second arg; undo() passes the post-op AFTER", async () => {
-    // The live-bug regression this locks in: putStrokes needs its own
-    // command's baseline to tell a delete (an id `before` had that `next`
-    // dropped) apart from a genuinely concurrent sibling addition (an id
-    // `prev` has that this command's OWN before/next never knew about).
-    const putFn = mock(() => Promise.resolve());
-    const cmd = createAnnotationStrokesCommand({
-      before: [pen1, pen2],
-      after: [pen1],
-      putFn,
-    });
-    await cmd.do();
-    expect(putFn.mock.calls[0]).toEqual([[pen1], [pen1, pen2]]);
-    await cmd.undo();
-    expect(putFn.mock.calls[1]).toEqual([[pen1, pen2], [pen1]]);
-  });
-
-  test('default label — add 2 strokes', () => {
-    const cmd = createAnnotationStrokesCommand({
-      before: [pen1],
-      after: [pen1, pen2, rect1],
-      putFn: () => {},
-    });
-    expect(cmd.label).toBe('add 2 strokes');
-  });
-
-  test('default label — same-count edit', () => {
-    const cmd = createAnnotationStrokesCommand({
-      before: [pen1],
-      after: [{ ...pen1, color: '#f00' }],
-      putFn: () => {},
-    });
-    expect(cmd.label).toBe('edit 1 stroke');
-  });
-
-  test('snapshots are deep-cloned — mutating source after construction does not poison', async () => {
-    // Use locally-owned strokes so the test's mutation only affects the
-    // source arrays, never the module-scope `pen1`/`pen2` shared with other
-    // tests.
-    const localPen: PenStroke = {
-      id: 'local',
-      tool: 'pen',
-      color: '#000',
-      width: 1,
-      points: [
-        [1, 1],
-        [2, 2],
-      ],
-    };
-    const localPenAfter: PenStroke = {
-      id: 'local-after',
-      tool: 'pen',
-      color: '#111',
-      width: 1,
-      points: [[3, 3]],
-    };
-    const sourceBefore: Stroke[] = [localPen];
-    const sourceAfter: Stroke[] = [localPen, localPenAfter];
-    const putFn = mock(() => Promise.resolve());
-    const cmd = createAnnotationStrokesCommand({
-      before: sourceBefore,
-      after: sourceAfter,
-      putFn,
-    });
-    // Mutate source arrays after construction — replace entries entirely so
-    // we don't reach through into shared sub-arrays.
-    sourceAfter[0] = { ...localPen, color: '#POISONED' };
-    sourceBefore.length = 0;
-    await cmd.do();
-    expect(putFn.mock.calls[0]?.[0]).toEqual([localPen, localPenAfter]);
-    await cmd.undo();
-    expect(putFn.mock.calls[1]?.[0]).toEqual([localPen]);
-  });
-});

package/apps/studio/test/annotations-align.test.ts

@@ -1,88 +0,0 @@
-// annotations-align — FigJam v3 align + distribute (pure bbox math, DOM-free).
-
-import { describe, expect, test } from 'bun:test';
-
-import { alignStrokes, distributeStrokes } from '../annotations-align.ts';
-import type { RectStroke, Stroke } from '../annotations-model.ts';
-
-function rect(
-  id: string,
-  x: number,
-  y: number,
-  w = 50,
-  h = 50,
-  extra: Partial<RectStroke> = {}
-): RectStroke {
-  return { id, tool: 'rect', color: '#1f1f1f', width: 3, x, y, w, h, ...extra };
-}
-
-const byId = (strokes: readonly Stroke[], id: string): RectStroke =>
-  strokes.find((s) => s.id === id) as RectStroke;
-
-describe('alignStrokes', () => {
-  test('align left snaps every unit to the selection bbox left edge', () => {
-    const strokes = [rect('a', 0, 0), rect('b', 100, 80), rect('c', 40, 200)];
-    const out = alignStrokes(strokes, ['a', 'b', 'c'], 'left');
-    expect(byId(out, 'a').x).toBe(0);
-    expect(byId(out, 'b').x).toBe(0);
-    expect(byId(out, 'c').x).toBe(0);
-    // y untouched by a horizontal align
-    expect(byId(out, 'b').y).toBe(80);
-  });
-
-  test('align h-center / right / bottom', () => {
-    const strokes = [rect('a', 0, 0, 100, 100), rect('b', 200, 50, 20, 20)];
-    const centered = alignStrokes(strokes, ['a', 'b'], 'h-center');
-    // Selection spans x:0..220 → center 110; b (w20) → x=100.
-    expect(byId(centered, 'b').x).toBe(100);
-    const right = alignStrokes(strokes, ['a', 'b'], 'right');
-    expect(byId(right, 'a').x).toBe(120);
-    const bottom = alignStrokes(strokes, ['a', 'b'], 'bottom');
-    expect(byId(bottom, 'b').y).toBe(80);
-  });
-
-  test('a group aligns as ONE unit — members keep their relative offsets', () => {
-    const strokes = [
-      rect('g1', 100, 0, 50, 50, { groupIds: ['g'] }),
-      rect('g2', 160, 30, 50, 50, { groupIds: ['g'] }),
-      rect('solo', 0, 200),
-    ];
-    const out = alignStrokes(strokes, ['g1', 'solo'], 'left');
-    // Group bbox spans x:100..210; aligning left moves the group by -100.
-    expect(byId(out, 'g1').x).toBe(0);
-    expect(byId(out, 'g2').x).toBe(60);
-    expect(byId(out, 'solo').x).toBe(0);
-  });
-
-  test('fewer than two units → referential no-op', () => {
-    const strokes = [
-      rect('a', 0, 0),
-      rect('b', 10, 10, 50, 50, { groupIds: ['g'] }),
-      rect('c', 70, 10, 50, 50, { groupIds: ['g'] }),
-    ];
-    expect(alignStrokes(strokes, ['b'], 'left')).toBe(strokes);
-  });
-});
-
-describe('distributeStrokes', () => {
-  test('equalizes gaps, pinning the first and last unit', () => {
-    // a: 0..50, b: 60..110, c: 200..250 → span 250, total 150, gap = 50.
-    const strokes = [rect('a', 0, 0), rect('b', 60, 0), rect('c', 200, 0)];
-    const out = distributeStrokes(strokes, ['a', 'b', 'c'], 'h');
-    expect(byId(out, 'a').x).toBe(0);
-    expect(byId(out, 'b').x).toBe(100);
-    expect(byId(out, 'c').x).toBe(200);
-  });
-
-  test('vertical distribute', () => {
-    // a: 0..50, b: 55..105, c: 300..350 → span 350, total 150, gap = 100.
-    const strokes = [rect('a', 0, 0), rect('b', 0, 55), rect('c', 0, 300)];
-    const out = distributeStrokes(strokes, ['a', 'b', 'c'], 'v');
-    expect(byId(out, 'b').y).toBe(150);
-  });
-
-  test('fewer than three units → referential no-op', () => {
-    const strokes = [rect('a', 0, 0), rect('b', 100, 0)];
-    expect(distributeStrokes(strokes, ['a', 'b'], 'h')).toBe(strokes);
-  });
-});

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

@@ -1,145 +0,0 @@
-// /_api/annotations — Phase 5 GET / PUT round-trip + validation gates.
-//
-// Verifies:
-//   - GET returns empty body for a canvas with no annotations file
-//   - PUT writes `<designRoot>/<slug>.annotations.svg`
-//   - GET subsequently returns the saved SVG
-//   - PUT rejects non-SVG bodies (400)
-//   - 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 { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-const SVG_OK =
-  '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1">' +
-  '<path data-id="p1" data-tool="pen" stroke="#d63b1f" stroke-width="2" fill="none" d="M0 0 L10 10"/>' +
-  '</svg>';
-
-describe('/_api/annotations — GET/PUT', () => {
-  test('GET on a canvas with no annotations returns empty body (200)', async () => {
-    const { root, designRoot } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      mkdirSync(join(designRoot, 'ui'), { recursive: true });
-      writeFileSync(
-        join(designRoot, 'ui', 'Phase5.tsx'),
-        'export default function P(){return <main/>}\n'
-      );
-      const r = await fetch(
-        `http://localhost:${port}/_api/annotations?file=${encodeURIComponent(
-          '.design/ui/Phase5.tsx'
-        )}`
-      );
-      expect(r.status).toBe(200);
-      const body = await r.text();
-      expect(body).toBe('');
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('PUT writes <designRoot>/<slug>.annotations.svg and GET round-trips', async () => {
-    const { root, designRoot } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      mkdirSync(join(designRoot, 'ui'), { recursive: true });
-      writeFileSync(
-        join(designRoot, 'ui', 'Round.tsx'),
-        'export default function P(){return <main/>}\n'
-      );
-      const put = await fetch(`http://localhost:${port}/_api/annotations`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ file: '.design/ui/Round.tsx', svg: SVG_OK }),
-      });
-      expect(put.status).toBe(204);
-
-      // File slug derives from the path under designRoot: `ui-round`.
-      const written = join(designRoot, 'ui-round.annotations.svg');
-      expect(existsSync(written)).toBe(true);
-      expect(readFileSync(written, 'utf8')).toBe(SVG_OK);
-
-      const get = await fetch(
-        `http://localhost:${port}/_api/annotations?file=${encodeURIComponent(
-          '.design/ui/Round.tsx'
-        )}`
-      );
-      expect(get.status).toBe(200);
-      expect(get.headers.get('content-type')).toContain('image/svg+xml');
-      expect(await get.text()).toBe(SVG_OK);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('PUT rejects non-SVG bodies with 400', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/annotations`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ file: '.design/ui/X.tsx', svg: '<p>nope</p>' }),
-      });
-      expect(r.status).toBe(400);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('PUT rejects missing file', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/annotations`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ svg: SVG_OK }),
-      });
-      expect(r.status).toBe(400);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('PUT rejects bodies above the 1 MB ceiling', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const huge = `<svg>${'x'.repeat(1024 * 1024 + 100)}</svg>`;
-      const r = await fetch(`http://localhost:${port}/_api/annotations`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ file: '.design/ui/X.tsx', svg: huge }),
-      });
-      // readJson throws on body too large → readJson returns null → 400.
-      // saveAnnotations would also reject on length, so either path yields 400.
-      expect(r.status).toBe(400);
-    } finally {
-      await killProc(proc);
-    }
-  });
-
-  test('Unknown method (DELETE) returns 405', async () => {
-    const { root } = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(root, port);
-    try {
-      const r = await fetch(`http://localhost:${port}/_api/annotations`, {
-        method: 'DELETE',
-      });
-      expect(r.status).toBe(405);
-    } finally {
-      await killProc(proc);
-    }
-  });
-});

package/apps/studio/test/annotations-bindings.test.ts

@@ -1,262 +0,0 @@
-// annotations-bindings — FigJam v3 connector binding (pure, DOM-free).
-// Semantics: Excalidraw proximity bind + FigJam side/center magnets; bound
-// endpoints derive from the host; deleting the host unbinds + freezes.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  anchorPoint,
-  BIND_THRESHOLD_PX,
-  bindCandidate,
-  facingAnchor,
-  isBindable,
-  recomputeBoundArrows,
-} from '../annotations-bindings.ts';
-import type { ArrowStroke, RectStroke, Stroke, TextStroke } from '../annotations-model.ts';
-
-function rect(id: string, x = 0, y = 0, w = 100, h = 80): RectStroke {
-  return { id, tool: 'rect', color: '#1f1f1f', width: 3, x, y, w, h };
-}
-function arrow(id: string, extra: Partial<ArrowStroke> = {}): ArrowStroke {
-  return { id, tool: 'arrow', color: '#1f1f1f', width: 3, x1: 0, y1: 0, x2: 50, y2: 0, ...extra };
-}
-
-describe('bindCandidate', () => {
-  test('binds within the threshold and snaps to the nearest magnet', () => {
-    const strokes: Stroke[] = [rect('host', 100, 100, 100, 100)];
-    // Just right of the host's right edge, vertically centered → (1, 0.5).
-    const bind = bindCandidate(205, 150, strokes, BIND_THRESHOLD_PX);
-    expect(bind).toEqual({ hostId: 'host', nx: 1, ny: 0.5 });
-    // Top-left corner region → (0, 0).
-    expect(bindCandidate(98, 102, strokes, BIND_THRESHOLD_PX)).toEqual({
-      hostId: 'host',
-      nx: 0,
-      ny: 0,
-    });
-  });
-
-  test('misses outside the threshold; topmost host wins; exclusions respected', () => {
-    const below = rect('below', 0, 0, 100, 100);
-    const above = rect('above', 50, 50, 100, 100);
-    const strokes: Stroke[] = [below, above];
-    expect(bindCandidate(500, 500, strokes, BIND_THRESHOLD_PX)).toBeNull();
-    expect(bindCandidate(75, 75, strokes, BIND_THRESHOLD_PX)?.hostId).toBe('above');
-    expect(bindCandidate(75, 75, strokes, BIND_THRESHOLD_PX, new Set(['above']))?.hostId).toBe(
-      'below'
-    );
-  });
-
-  test('pen / arrow / link never host', () => {
-    expect(isBindable(rect('r'))).toBe(true);
-    expect(
-      isBindable({ id: 'p', tool: 'pen', color: '#000', width: 2, points: [[0, 0]] } as Stroke)
-    ).toBe(false);
-    expect(
-      isBindable({
-        id: 'l',
-        tool: 'link',
-        x: 0,
-        y: 0,
-        w: 10,
-        h: 10,
-        url: 'https://x.test',
-        title: 't',
-        domain: 'x.test',
-      } as Stroke)
-    ).toBe(false);
-  });
-});
-
-// DDR-216 D9 — the widening, and the three exclusions that keep it from
-// regressing the NATIVE whiteboard. FigJam binds connectors to anything; on the
-// only real board measured, 2/2 connectors had an endpoint Maude could not bind,
-// so an imported connector degraded to a frozen line. Widening also closes a
-// plain native gap (you could not attach an arrow to a text label or a section).
-describe('isBindable widening — text + section (DDR-216 D9)', () => {
-  const standaloneText = (over: Partial<TextStroke> = {}): TextStroke => ({
-    id: 't',
-    tool: 'text',
-    color: '#1a1a1a',
-    fontSize: 14,
-    text: 'Archetyp',
-    x: 0,
-    y: 0,
-    ...over,
-  });
-
-  const section = (id: string, x = 0, y = 0, w = 400, h = 300): Stroke =>
-    ({ id, tool: 'section', x, y, w, h, label: 'Sekce', color: '#8b8b94' }) as Stroke;
-
-  test('standalone text IS bindable, and hosts a real bind', () => {
-    const label = standaloneText();
-    expect(isBindable(label)).toBe(true);
-    const bind = bindCandidate(1, 1, [label], BIND_THRESHOLD_PX);
-    expect(bind?.hostId).toBe('t');
-  });
-
-  test('ANCHORED text is NOT bindable — its bbox is unresolvable here', () => {
-    // `strokeBBox` returns null for anchored text without the anchors map, which
-    // every caller in this module omits. Admitting it would mint a bind that can
-    // never resolve — worse than not binding, because it never self-corrects.
-    const anchored = standaloneText({ anchorId: 'some-shape' });
-    expect(isBindable(anchored)).toBe(false);
-    expect(bindCandidate(0, 0, [anchored], BIND_THRESHOLD_PX)).toBeNull();
-  });
-
-  test('oversized text is NOT offered — no board-wide bind magnet', () => {
-    // A TextStroke has no stored w/h; strokeBBox synthesizes one from content,
-    // so 5 000 chars on one line projects a ~38 500 px-wide invisible strip.
-    const huge = standaloneText({ text: 'x'.repeat(5000) });
-    expect(isBindable(huge)).toBe(false);
-    // A rect under the cursor still wins, rather than the giant text stealing it.
-    const r = rect('r', 0, 0, 100, 100);
-    expect(bindCandidate(50, 50, [r, huge], BIND_THRESHOLD_PX)?.hostId).toBe('r');
-  });
-
-  test('a section binds on its BORDER, matching strokeHitTest', () => {
-    const s = section('sec');
-    expect(isBindable(s)).toBe(true);
-    expect(bindCandidate(0, 150, [s], BIND_THRESHOLD_PX)?.hostId).toBe('sec');
-  });
-
-  test('a section does NOT swallow binds through its click-through interior', () => {
-    // The natural gesture is to draw a section AROUND existing notes, which puts
-    // it later in the array = topmost. Testing its raw bbox would make every
-    // arrow drawn between two stickies inside it bind to the section instead.
-    const inner = rect('inner', 100, 100, 60, 60);
-    const s = section('sec', 0, 0, 400, 300);
-    const strokes: Stroke[] = [inner, s]; // section topmost
-    expect(bindCandidate(130, 130, strokes, BIND_THRESHOLD_PX)?.hostId).toBe('inner');
-    // Deep interior with nothing under it binds to nothing, not to the section.
-    expect(bindCandidate(300, 200, [s], BIND_THRESHOLD_PX)).toBeNull();
-  });
-
-  test('a bind whose anchorPoint cannot resolve is STRIPPED, not frozen-but-claimed', () => {
-    // Fix 2: `applyEnd` used to `return` silently when anchorPoint was null,
-    // which kept a bind that could never be honoured. Inert before the widening,
-    // load-bearing after it.
-    const ghost = standaloneText({ id: 'ghost', anchorId: 'gone' });
-    const ar = arrow('ar', {
-      x1: 0,
-      y1: 0,
-      x2: 100,
-      y2: 100,
-      startBind: { hostId: 'ghost', nx: 0.5, ny: 0.5 },
-    });
-    const out = recomputeBoundArrows([ghost, ar]);
-    const a = out.find((s) => s.id === 'ar') as ArrowStroke;
-    expect(a.startBind).toBeUndefined();
-    expect([a.x1, a.y1]).toEqual([0, 0]); // endpoint frozen in place, honestly
-  });
-
-  test('a bound arrow follows a text host as it moves', () => {
-    const label = standaloneText({ x: 0, y: 0 });
-    const ar = arrow('ar', {
-      x1: 0,
-      y1: 0,
-      x2: 300,
-      y2: 300,
-      startBind: { hostId: 't', nx: 0, ny: 0 },
-    });
-    const moved: Stroke[] = [{ ...label, x: 40, y: 60 }, ar];
-    const out = recomputeBoundArrows(moved);
-    const a = out.find((s) => s.id === 'ar') as ArrowStroke;
-    // The exact bbox is content-derived; what matters is that it TRACKED.
-    expect(a.startBind?.hostId).toBe('t');
-    expect(a.x1).not.toBe(0);
-  });
-});
-
-describe('anchorPoint / recomputeBoundArrows', () => {
-  test('bound endpoints follow the host on move (translate → recompute)', () => {
-    const host = rect('host', 0, 0, 100, 100);
-    const ar = arrow('ar', {
-      x1: 100,
-      y1: 50,
-      x2: 300,
-      y2: 50,
-      startBind: { hostId: 'host', nx: 1, ny: 0.5 },
-    });
-    const moved: Stroke[] = [{ ...host, x: 50, y: 20 }, ar];
-    const out = recomputeBoundArrows(moved);
-    const a = out.find((s) => s.id === 'ar') as ArrowStroke;
-    expect([a.x1, a.y1]).toEqual([150, 70]);
-    expect([a.x2, a.y2]).toEqual([300, 50]); // free end untouched
-  });
-
-  test('anchor stays proportional through a host resize', () => {
-    const host = rect('host', 0, 0, 200, 100);
-    expect(anchorPoint(host, 0.5, 1)).toEqual([100, 100]);
-    expect(anchorPoint({ ...host, w: 400 }, 0.5, 1)).toEqual([200, 100]);
-  });
-
-  test('missing host → bind stripped, endpoint frozen (arrow survives)', () => {
-    const ar = arrow('ar', {
-      x1: 100,
-      y1: 50,
-      x2: 300,
-      y2: 50,
-      startBind: { hostId: 'gone', nx: 1, ny: 0.5 },
-    });
-    const out = recomputeBoundArrows([ar]);
-    const a = out.find((s) => s.id === 'ar') as ArrowStroke;
-    expect(a.startBind).toBeUndefined();
-    expect([a.x1, a.y1]).toEqual([100, 50]);
-  });
-
-  test('referential no-op when every endpoint already sits at its anchor', () => {
-    const host = rect('host', 0, 0, 100, 100);
-    const ar = arrow('ar', {
-      x1: 100,
-      y1: 50,
-      x2: 300,
-      y2: 50,
-      startBind: { hostId: 'host', nx: 1, ny: 0.5 },
-    });
-    const strokes: Stroke[] = [host, ar];
-    expect(recomputeBoundArrows(strokes)).toBe(strokes);
-  });
-});
-
-describe('facingAnchor (AI annotate / quick-create side pick)', () => {
-  test('picks the side magnet facing the target', () => {
-    const host = rect('h', 0, 0, 100, 100);
-    expect(facingAnchor(host, 500, 50)).toEqual({ hostId: 'h', nx: 1, ny: 0.5 });
-    expect(facingAnchor(host, -400, 50)).toEqual({ hostId: 'h', nx: 0, ny: 0.5 });
-    expect(facingAnchor(host, 50, 900)).toEqual({ hostId: 'h', nx: 0.5, ny: 1 });
-    expect(facingAnchor(host, 50, -900)).toEqual({ hostId: 'h', nx: 0.5, ny: 0 });
-  });
-});
-
-describe('the text bind cap is PER AXIS, not an area product (review F8)', () => {
-  test('a long single line at the font-size floor is NOT a bind host', () => {
-    // The area cap it replaced was satisfiable by exactly this shape: 4 000
-    // chars at fontSize 8 gives w ≈ 17 600 × h ≈ 9.6 — area 168 960, under a
-    // 640×480 product — i.e. a 17 600 px-wide invisible magnet.
-    const strip: TextStroke = {
-      id: 'strip',
-      tool: 'text',
-      color: '#1a1a1a',
-      fontSize: 8,
-      text: 'x'.repeat(4000),
-      x: 0,
-      y: 0,
-    };
-    expect(isBindable(strip)).toBe(false);
-    const r = rect('r', 100, 0, 100, 100);
-    expect(bindCandidate(150, 50, [r, strip], BIND_THRESHOLD_PX)?.hostId).toBe('r');
-  });
-
-  test('an ordinary label is still a bind host', () => {
-    const label: TextStroke = {
-      id: 't',
-      tool: 'text',
-      color: '#1a1a1a',
-      fontSize: 14,
-      text: 'Archetyp',
-      x: 0,
-      y: 0,
-    };
-    expect(isBindable(label)).toBe(true);
-  });
-});