@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/applyRenderStyle.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { applyRenderStyleToLayers } from '../doc/utils/applyRenderStyle.js';
-import { resolveBlockTransition } from '../schemas/Transitions.js';
-import { DEFAULT_THEME, resolveTheme } from '../schemas/themeLibrary.js';
-import type { Theme } from '../schemas/Theme.js';
-import type { Layer } from '../schemas/Doc.js';
-
-function themeWith(patch: {
-  animationSpeed?: number;
-  ambientMotion?: boolean;
-  defaultImageAnimation?: Theme['renderStyle']['defaultImageAnimation'];
-  defaultTransition?: Theme['renderStyle']['defaultTransition'];
-}): Theme {
-  return {
-    ...DEFAULT_THEME,
-    style: {
-      ...DEFAULT_THEME.style,
-      ...(patch.animationSpeed != null ? { animationSpeed: patch.animationSpeed } : {}),
-    },
-    renderStyle: {
-      ...DEFAULT_THEME.renderStyle,
-      ...(patch.ambientMotion != null ? { ambientMotion: patch.ambientMotion } : {}),
-      ...(patch.defaultImageAnimation
-        ? { defaultImageAnimation: patch.defaultImageAnimation }
-        : {}),
-      ...(patch.defaultTransition ? { defaultTransition: patch.defaultTransition } : {}),
-    },
-  };
-}
-
-const fullBleedImage = (id = 'img'): Layer => ({
-  type: 'image',
-  id,
-  content: { src: 'x.jpg', alt: '' },
-  position: { x: 0, y: 0, width: '100%', height: '100%' },
-});
-
-const BLOCK = { id: 'b1', duration: 6 };
-
-describe('applyRenderStyleToLayers', () => {
-  it('is a no-op at animationSpeed 1.0 with no ambient motion (returns same objects)', () => {
-    const layers: Layer[] = [{ ...fullBleedImage(), animation: { type: 'fadeIn', duration: 2 } }];
-    const out = applyRenderStyleToLayers(layers, BLOCK, DEFAULT_THEME);
-    expect(out).toBe(layers);
-  });
-
-  it('scales duration and delay by animationSpeed', () => {
-    const layers: Layer[] = [
-      {
-        type: 'text',
-        id: 't',
-        content: { text: 'hi', style: { fontSize: 20, color: '#ffffff' } },
-        position: { x: '50%', y: '50%' },
-        animation: { type: 'fadeIn', duration: 2, delay: 1 },
-      },
-    ];
-    const out = applyRenderStyleToLayers(layers, BLOCK, themeWith({ animationSpeed: 0.5 }));
-    expect(out[0].animation).toEqual({ type: 'fadeIn', duration: 1, delay: 0.5 });
-    // Input untouched (pure)
-    expect(layers[0].animation).toEqual({ type: 'fadeIn', duration: 2, delay: 1 });
-  });
-
-  it('gives full-bleed cover imagery a deterministic ambient Ken Burns', () => {
-    const theme = themeWith({ ambientMotion: true });
-    const a = applyRenderStyleToLayers([fullBleedImage()], BLOCK, theme);
-    const b = applyRenderStyleToLayers([fullBleedImage()], BLOCK, theme);
-    expect(a[0].animation?.type).toBe('slowZoom');
-    expect(a[0].animation?.duration).toBeGreaterThanOrEqual(8);
-    // Deterministic: same block+layer id → same variant
-    expect(a[0].animation).toEqual(b[0].animation);
-    // Different layer id → independent (usually different) but still defined
-    const c = applyRenderStyleToLayers([fullBleedImage('other')], BLOCK, theme);
-    expect(c[0].animation?.type).toBe('slowZoom');
-  });
-
-  it('does not let a default entrance animation override ambientMotion=false', () => {
-    const out = applyRenderStyleToLayers(
-      [fullBleedImage()],
-      BLOCK,
-      themeWith({ ambientMotion: false, defaultImageAnimation: 'slowZoom' }),
-    );
-    expect(out[0].animation).toBeUndefined();
-  });
-
-  it('never overrides an authored animation, including type none', () => {
-    const theme = themeWith({ ambientMotion: true });
-    const none: Layer = { ...fullBleedImage(), animation: { type: 'none' } };
-    const authored: Layer = {
-      ...fullBleedImage('a2'),
-      animation: { type: 'fadeIn', duration: 3 },
-    };
-    const out = applyRenderStyleToLayers([none, authored], BLOCK, theme);
-    expect(out[0].animation).toEqual({ type: 'none' });
-    expect(out[1].animation?.type).toBe('fadeIn');
-  });
-
-  it('does not blanket-animate partial or contain-fit imagery', () => {
-    const theme = themeWith({ ambientMotion: true });
-    const strip: Layer = {
-      type: 'image',
-      id: 'strip',
-      content: { src: 'x.jpg', alt: '' },
-      position: { x: '65%', y: 0, width: '35%', height: '100%' },
-    };
-    const contained: Layer = {
-      type: 'image',
-      id: 'contained',
-      content: { src: 'x.jpg', alt: '', fit: 'contain' },
-      position: { x: 0, y: 0, width: '100%', height: '100%' },
-    };
-    const out = applyRenderStyleToLayers([strip, contained], BLOCK, theme);
-    expect(out[0].animation).toBeUndefined();
-    expect(out[1].animation).toBeUndefined();
-  });
-});
-
-describe('resolveBlockTransition', () => {
-  const theme = themeWith({ defaultTransition: { type: 'dissolve', duration: 1.2 } });
-
-  it('authored transition always wins', () => {
-    const t = resolveBlockTransition({ transition: { type: 'cut' } }, theme, 3);
-    expect(t).toEqual({ type: 'cut' });
-  });
-
-  it('falls back to the theme default for blocks after the first', () => {
-    expect(resolveBlockTransition({}, theme, 1)).toEqual({ type: 'dissolve', duration: 1.2 });
-  });
-
-  it('never applies a theme default to block 0', () => {
-    expect(resolveBlockTransition({}, theme, 0)).toBeUndefined();
-  });
-
-  it('returns undefined when neither block nor theme specify one', () => {
-    const bare: Theme = {
-      ...DEFAULT_THEME,
-      renderStyle: { ...DEFAULT_THEME.renderStyle, defaultTransition: undefined },
-    };
-    expect(resolveBlockTransition({}, bare, 2)).toBeUndefined();
-  });
-
-  it('documentary (built-in) authors a default transition that now resolves', () => {
-    const documentary = resolveTheme('documentary');
-    const t = resolveBlockTransition({}, documentary, 1);
-    expect(t?.type).toBe('fade');
-  });
-});

package/src/__tests__/asciiDiagramBattle.test.ts

@@ -1,246 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  detectAsciiDiagram,
-  parseAsciiDiagram,
-  renderAsciiDiagram,
-  type AsciiDiagram,
-} from '../doc/asciiDiagram/index.js';
-import { BATTLE_DIAGRAMS, type BattleDiagram } from './fixtures/asciiDiagramBattle.js';
-
-/**
- * Battle test: a broad corpus of AI-style ASCII diagrams (linear flows,
- * fan-out/in, DAGs, cycles, many-to-many, containers, labeled edges,
- * styles) driven through the codec end-to-end. Each fixture asserts:
- *
- *  1. Detection — the art is recognized as a diagram.
- *  2. Parse accuracy — it parses to EXACTLY the intended nodes / edges /
- *     containment (the "we read what the AI drew" guarantee).
- *  3. Semantic fixpoint — render→parse preserves that semantic (editing
- *     the canvas never silently drops a node or edge).
- *  4. Byte idempotence — render→parse→render is byte-stable across cycles
- *     (no jitter, no drift).
- *
- * Followed by a focused many-to-many section and honest graceful-
- * degradation / known-limitation coverage.
- */
-
-interface Semantic {
-  nodes: string[];
-  edges: string[];
-}
-function semantic(d: AsciiDiagram): Semantic {
-  return {
-    nodes: d.nodes.map((n) => `${n.id}${n.containerId ? `<${n.containerId}` : ''}`).sort(),
-    edges: d.edges.map((e) => `${e.source}|${e.target}|${e.directed}|${e.label ?? ''}`).sort(),
-  };
-}
-function expectedEdgeStrings(fx: BattleDiagram): string[] {
-  return fx.edges
-    .map(
-      ([s, t, label, directed]) => `${s}|${t}|${directed === false ? false : true}|${label ?? ''}`,
-    )
-    .sort();
-}
-
-describe('battle test — every fixture round-trips', () => {
-  for (const fx of BATTLE_DIAGRAMS) {
-    describe(`${fx.category}: ${fx.name}`, () => {
-      const d = parseAsciiDiagram(fx.art);
-
-      it('detects as a diagram', () => {
-        expect(detectAsciiDiagram(fx.art).isDiagram).toBe(true);
-      });
-
-      it('parses the intended nodes', () => {
-        expect(d.nodes.map((n) => n.id).sort()).toEqual([...fx.nodes].sort());
-      });
-
-      it('parses the intended edges (source, target, direction, label)', () => {
-        const got = d.edges
-          .map((e) => `${e.source}|${e.target}|${e.directed}|${e.label ?? ''}`)
-          .sort();
-        expect(got).toEqual(expectedEdgeStrings(fx));
-      });
-
-      it('parses the intended containment', () => {
-        const got: Record<string, string> = {};
-        for (const n of d.nodes) if (n.containerId) got[n.id] = n.containerId;
-        expect(got).toEqual(fx.containers ?? {});
-      });
-
-      it('render→parse preserves the semantic (fixpoint)', () => {
-        const reparsed = parseAsciiDiagram(renderAsciiDiagram(d));
-        expect(semantic(reparsed)).toEqual(semantic(d));
-      });
-
-      it('render→parse→render is byte-stable across three cycles', () => {
-        const t1 = renderAsciiDiagram(d);
-        const t2 = renderAsciiDiagram(parseAsciiDiagram(t1));
-        const t3 = renderAsciiDiagram(parseAsciiDiagram(t2));
-        expect(t2).toBe(t1);
-        expect(t3).toBe(t1);
-      });
-    });
-  }
-});
-
-describe('battle test — coverage sanity', () => {
-  it('covers every intended category', () => {
-    const categories = new Set(BATTLE_DIAGRAMS.map((f) => f.category));
-    for (const c of [
-      'linear',
-      'fan-out',
-      'fan-in',
-      'dag',
-      'cycle',
-      'many-to-many',
-      'edges',
-      'labels',
-      'container',
-      'style',
-    ]) {
-      expect(categories.has(c)).toBe(true);
-    }
-  });
-
-  it('fixture names are unique', () => {
-    const names = BATTLE_DIAGRAMS.map((f) => f.name);
-    expect(new Set(names).size).toBe(names.length);
-  });
-});
-
-describe('battle test — many-to-many relationships', () => {
-  it('recovers every edge of a full 3-node mesh (6 directed edges)', () => {
-    const fx = BATTLE_DIAGRAMS.find((f) => f.name === 'fullMesh3')!;
-    const d = parseAsciiDiagram(fx.art);
-    expect(d.edges).toHaveLength(6);
-    const pairs = new Set(d.edges.map((e) => `${e.source}->${e.target}`));
-    for (const a of ['alpha', 'beta', 'gamma']) {
-      for (const b of ['alpha', 'beta', 'gamma']) {
-        if (a !== b) expect(pairs.has(`${a}->${b}`)).toBe(true);
-      }
-    }
-  });
-
-  it('recovers a fan-out hub connecting to all of its targets', () => {
-    const fx = BATTLE_DIAGRAMS.find((f) => f.name === 'loadBalancerFanout')!;
-    const d = parseAsciiDiagram(fx.art);
-    const targets = d.edges
-      .filter((e) => e.source === 'load-balancer')
-      .map((e) => e.target)
-      .sort();
-    expect(targets).toEqual(['web1', 'web2', 'web3', 'web4']);
-  });
-
-  it('recovers a fan-in hub reached by all of its sources', () => {
-    const fx = BATTLE_DIAGRAMS.find((f) => f.name === 'collectorFanin')!;
-    const d = parseAsciiDiagram(fx.art);
-    const sources = d.edges
-      .filter((e) => e.target === 'collector')
-      .map((e) => e.source)
-      .sort();
-    expect(sources).toEqual(['s1', 's2', 's3']);
-  });
-
-  it('recovers a diamond (two disjoint paths reconverging)', () => {
-    const fx = BATTLE_DIAGRAMS.find((f) => f.name === 'diamond')!;
-    const d = parseAsciiDiagram(fx.art);
-    const edges = new Set(d.edges.map((e) => `${e.source}->${e.target}`));
-    expect(edges).toEqual(new Set(['a->b', 'a->c', 'b->d', 'c->d']));
-    // Byte-stable, so an edit never collapses one of the two paths.
-    expect(renderAsciiDiagram(parseAsciiDiagram(renderAsciiDiagram(d)))).toBe(
-      renderAsciiDiagram(d),
-    );
-  });
-
-  it('preserves a bidirectional pair as two directed edges', () => {
-    const fx = BATTLE_DIAGRAMS.find((f) => f.name === 'bidirReplication')!;
-    const d = parseAsciiDiagram(fx.art);
-    expect(d.edges).toHaveLength(2);
-    expect(new Set(d.edges.map((e) => `${e.source}->${e.target}`))).toEqual(
-      new Set(['primary->replica', 'replica->primary']),
-    );
-  });
-});
-
-describe('battle test — graceful degradation of the hard cases', () => {
-  // Dense bipartite crossing meshes are inherently ambiguous in ASCII (two
-  // lines that cross in a tight channel cannot be told from a merge). The
-  // parser must not crash or hallucinate — it returns *some* subset without
-  // throwing, and detection/rendering stay well-defined.
-  it('does not crash on a dense bipartite crossing mesh', () => {
-    const art = [
-      '┌────────┐          ┌────────┐',
-      '│   A    │          │   B    │',
-      '└─┬────┬─┘          └─┬────┬─┘',
-      '  │    └──────┐   ┌───┘    │',
-      '  │           │   │        │',
-      '  ▼           ▼   ▼        ▼',
-      '┌────────┐        ┌────────┐',
-      '│   X    │        │   Y    │',
-      '└────────┘        └────────┘',
-    ].join('\n');
-    const d = parseAsciiDiagram(art);
-    expect(d.nodes.map((n) => n.id).sort()).toEqual(['a', 'b', 'x', 'y']);
-    // Render never throws and stays byte-idempotent even if edges are lossy.
-    const r1 = renderAsciiDiagram(d);
-    expect(renderAsciiDiagram(parseAsciiDiagram(r1))).toBe(r1);
-  });
-
-  // Boxes whose top and bottom borders are different widths (a very common
-  // AI misalignment) don't trace as boxes — the fence stays plain code
-  // (safe failure) rather than producing a garbled diagram.
-  it('rejects a misaligned container as a non-diagram (stays code)', () => {
-    const art = [
-      '┌───────────────── Cluster ─────────────────┐',
-      '│  ┌─────────┐    ┌─────────┐   │',
-      '│  │  Pod A  │    │  Pod B  │   │',
-      '│  └─────────┘    └─────────┘   │',
-      '└────────────────────────────────────────────┘',
-    ].join('\n');
-    const detection = detectAsciiDiagram(art);
-    // The outer misaligned box is dropped; whatever remains is not a
-    // confident diagram, so it degrades to a plain code block.
-    expect(detection.reasons.length).toBeGreaterThan(0);
-  });
-
-  it('never throws on garbage, empty, or non-diagram fences', () => {
-    for (const junk of ['', '   ', 'hello world', '┌──\n│ x', '|||\n---\n|||', 'a | b | c']) {
-      expect(() => parseAsciiDiagram(junk)).not.toThrow();
-      expect(() => renderAsciiDiagram(parseAsciiDiagram(junk))).not.toThrow();
-    }
-  });
-});
-
-describe('battle test — known limitation: labels on tight splits / cross-box feedback', () => {
-  // The PARSER reads per-branch labels on a shared bus correctly; the
-  // RENDERER can only host one label per tight two-way split, so a
-  // re-render may normalize one away. Documented so the behavior is a
-  // conscious contract, not a silent surprise. (Parse accuracy holds; only
-  // re-render label placement is lossy.)
-  it('parses both labels of a two-way split, even if re-render keeps one', () => {
-    const art = [
-      '        ┌───────────┐',
-      '        │  Check?   │',
-      '        └──┬─────┬──┘',
-      '     yes │       │ no',
-      '         ▼       ▼',
-      '    ┌────────┐ ┌────────┐',
-      '    │ Accept │ │ Reject │',
-      '    └────────┘ └────────┘',
-    ].join('\n');
-    const d = parseAsciiDiagram(art);
-    const labels = d.edges
-      .map((e) => e.label)
-      .filter(Boolean)
-      .sort();
-    expect(labels).toEqual(['no', 'yes']);
-    // The edges themselves are always preserved; only label placement is
-    // best-effort on the tight-split re-render.
-    const reparsed = parseAsciiDiagram(renderAsciiDiagram(d));
-    expect(reparsed.edges.map((e) => `${e.source}->${e.target}`).sort()).toEqual([
-      'check->accept',
-      'check->reject',
-    ]);
-  });
-});

package/src/__tests__/asciiDiagramDetect.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  detectAsciiDiagram,
-  isAsciiDiagramFence,
-  isEligibleAsciiFenceLang,
-  isExplicitDiagramLang,
-} from '../doc/asciiDiagram/index.js';
-import type { MarkdownCodeBlock } from '../markdown/types.js';
-import { NEGATIVE_FIXTURES, POSITIVE_FIXTURES } from './fixtures/asciiDiagrams.js';
-
-/**
- * The negative corpus is the CONTRACT for detection tuning: every entry
- * must stay rejected. False positives hide real code behind a diagram
- * canvas; false negatives merely leave a code block alone.
- */
-
-const EXPECTED_REJECT_REASONS: Record<string, RegExp> = {
-  NEG_MARKDOWN_TABLE: /markdown-table|too-few-corner-candidates/,
-  NEG_PSQL_TABLE: /table-lattice/,
-  NEG_MYSQL_TABLE: /table-lattice/,
-  NEG_SHELL_PIPES: /too-few-corner-candidates|too-few-lines|too-few-boxes/,
-  NEG_TS_UNION: /too-few-corner-candidates|too-few-boxes/,
-  NEG_SQL_DDL: /too-few-corner-candidates|too-few-boxes/,
-  NEG_FILE_TREE: /too-few-corner-candidates|too-few-boxes/,
-  NEG_YAML: /too-few-corner-candidates|too-few-boxes/,
-  NEG_LOG_COLUMNS: /too-few-corner-candidates|too-few-boxes/,
-  NEG_PROSE_HEAVY: /loose-ratio/,
-  SINGLE_BOX: /too-few-boxes|too-few-corner-candidates/,
-};
-
-describe('detectAsciiDiagram — negative corpus (must all reject)', () => {
-  for (const [name, fixture] of Object.entries(NEGATIVE_FIXTURES)) {
-    it(`rejects ${name}`, () => {
-      const detection = detectAsciiDiagram(fixture);
-      expect(detection.isDiagram).toBe(false);
-      const expected = EXPECTED_REJECT_REASONS[name];
-      expect(detection.reasons.join(' ')).toMatch(expected);
-    });
-  }
-
-  it('rejects oversized fences without parsing', () => {
-    const huge = Array.from({ length: 500 }, () => '┌──┐').join('\n');
-    const detection = detectAsciiDiagram(huge);
-    expect(detection.isDiagram).toBe(false);
-    expect(detection.reasons.join(' ')).toMatch(/too-many-lines/);
-  });
-
-  it('rejects tiny fragments', () => {
-    expect(detectAsciiDiagram('┌┐\n└┘').isDiagram).toBe(false);
-  });
-});
-
-describe('detectAsciiDiagram — positive fixtures (must all accept)', () => {
-  for (const [name, fixture] of Object.entries(POSITIVE_FIXTURES)) {
-    it(`accepts ${name}`, () => {
-      const detection = detectAsciiDiagram(fixture);
-      expect(detection.isDiagram).toBe(true);
-      expect(detection.diagram).toBeDefined();
-      expect(detection.diagram?.nodes.length).toBeGreaterThanOrEqual(2);
-    });
-  }
-});
-
-describe('garbled-label guard (over-broken art falls back to code)', () => {
-  // Hand-drawn boxes whose labels overflow their borders AND collide with a
-  // neighbour desync the columns row-to-row, so box-drawing chars leak into
-  // the extracted labels. That's an unrecoverable parse — detection must
-  // decline so the fence renders as a faithful code block, not a garbled
-  // canvas. (This is the shape of real "half-broken" architecture art.)
-  const COLLIDING = [
-    '┌────────┐   ┌────────┐',
-    '│ @scope/kernel  │   │ @scope/client  │',
-    '│ x      │   │ y      │',
-    '└────────┘   └────────┘',
-    '┌────────┐   ┌────────┐',
-    '│ @scope/materls │   │ @scope/schema  │',
-    '│ z      │   │ w      │',
-    '└────────┘   └────────┘',
-  ].join('\n');
-
-  it('rejects a diagram whose labels are structurally garbled', () => {
-    const d = detectAsciiDiagram(COLLIDING);
-    expect(d.isDiagram).toBe(false);
-    expect(d.reasons.join(' ')).toMatch(/garbled-labels/);
-  });
-
-  it('rejects garbled art even when explicitly `diagram`-tagged', () => {
-    expect(detectAsciiDiagram(COLLIDING, { explicit: true }).isDiagram).toBe(false);
-  });
-
-  it('does not flag a clean diagram (no box chars in labels)', () => {
-    // Sanity: clean labels never trip the guard.
-    expect(detectAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL).isDiagram).toBe(true);
-    expect(detectAsciiDiagram(POSITIVE_FIXTURES.NESTED_CONTAINER).isDiagram).toBe(true);
-  });
-});
-
-describe('explicit `diagram` tag (lenient detection)', () => {
-  const ONE_BOX = ['┌────────┐', '│ Solo   │', '└────────┘'].join('\n');
-
-  it('isExplicitDiagramLang matches only the `diagram` tag', () => {
-    for (const lang of ['diagram', ' Diagram ', 'DIAGRAM'])
-      expect(isExplicitDiagramLang(lang)).toBe(true);
-    for (const lang of [undefined, null, '', 'text', 'ascii', 'tree', 'js'])
-      expect(isExplicitDiagramLang(lang)).toBe(false);
-  });
-
-  it('a single-box diagram is rejected untagged but accepted when explicit', () => {
-    expect(detectAsciiDiagram(ONE_BOX).isDiagram).toBe(false);
-    const explicit = detectAsciiDiagram(ONE_BOX, { explicit: true });
-    expect(explicit.isDiagram).toBe(true);
-    expect(explicit.diagram?.nodes).toHaveLength(1);
-  });
-
-  it('still rejects a markdown table even when explicitly tagged', () => {
-    expect(
-      detectAsciiDiagram(NEGATIVE_FIXTURES.NEG_MARKDOWN_TABLE, { explicit: true }).isDiagram,
-    ).toBe(false);
-  });
-
-  it('`diagram` is an eligible fence lang and isAsciiDiagramFence accepts a tagged single box', () => {
-    expect(isEligibleAsciiFenceLang('diagram')).toBe(true);
-    const fence: MarkdownCodeBlock = { type: 'code', lang: 'diagram', value: ONE_BOX };
-    expect(isAsciiDiagramFence(fence)).toBe(true);
-    // The same content in a bare fence is not auto-detected.
-    expect(isAsciiDiagramFence({ type: 'code', value: ONE_BOX })).toBe(false);
-  });
-});
-
-describe('fence language gate', () => {
-  it('allows no language, empty, and the inert allowlist', () => {
-    expect(isEligibleAsciiFenceLang(undefined)).toBe(true);
-    expect(isEligibleAsciiFenceLang(null)).toBe(true);
-    expect(isEligibleAsciiFenceLang('')).toBe(true);
-    expect(isEligibleAsciiFenceLang('text')).toBe(true);
-    expect(isEligibleAsciiFenceLang('TXT')).toBe(true);
-    expect(isEligibleAsciiFenceLang('plaintext')).toBe(true);
-    expect(isEligibleAsciiFenceLang('plain')).toBe(true);
-    expect(isEligibleAsciiFenceLang('ascii')).toBe(true);
-  });
-
-  it('rejects real programming languages', () => {
-    for (const lang of ['js', 'ts', 'python', 'sql', 'mermaid', 'json', 'yaml', 'bash']) {
-      expect(isEligibleAsciiFenceLang(lang)).toBe(false);
-    }
-  });
-
-  it('isAsciiDiagramFence combines the lang gate with content detection', () => {
-    const art = POSITIVE_FIXTURES.TWO_BOX_VERTICAL;
-    const fence = (lang?: string): MarkdownCodeBlock => ({
-      type: 'code',
-      ...(lang !== undefined ? { lang } : {}),
-      value: art,
-    });
-    expect(isAsciiDiagramFence(fence())).toBe(true);
-    expect(isAsciiDiagramFence(fence('text'))).toBe(true);
-    expect(isAsciiDiagramFence(fence('js'))).toBe(false);
-    expect(isAsciiDiagramFence({ type: 'code', value: NEGATIVE_FIXTURES.NEG_PSQL_TABLE })).toBe(
-      false,
-    );
-  });
-});

package/src/__tests__/asciiDiagramMapping.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { asciiDiagramToTemplateData, parseAsciiDiagram } from '../doc/asciiDiagram/index';
-
-const LOAD_BALANCER_FAN_OUT = `           ┌───────────────┐
-           │ Load Balancer │
-           └──┬──┬──┬──┬───┘
-       ┌──────┘  │  │  └──────┐
-       ▼         ▼  ▼         ▼
-    ┌──────┐┌──────┐┌──────┐┌──────┐
-    │ Web1 ││ Web2 ││ Web3 ││ Web4 │
-    └──────┘└──────┘└──────┘└──────┘`;
-
-describe('ASCII diagram canvas mapping', () => {
-  it('maps fan-out arrows to distributed bottom ports and top-center targets', () => {
-    const diagram = parseAsciiDiagram(LOAD_BALANCER_FAN_OUT);
-    const { edges } = asciiDiagramToTemplateData(diagram);
-
-    expect(edges.map((edge) => edge.target)).toEqual(['web1', 'web2', 'web3', 'web4']);
-    expect(edges.map((edge) => edge.routing)).toEqual([
-      'orthogonal',
-      'orthogonal',
-      'orthogonal',
-      'orthogonal',
-    ]);
-    expect(edges.map((edge) => edge.sourceAnchor)).toEqual([
-      { side: 'bottom', offset: 0.2 },
-      { side: 'bottom', offset: 0.4 },
-      { side: 'bottom', offset: 0.6 },
-      { side: 'bottom', offset: 0.8 },
-    ]);
-    expect(edges.map((edge) => edge.targetAnchor)).toEqual([
-      { side: 'top', offset: 0.5 },
-      { side: 'top', offset: 0.5 },
-      { side: 'top', offset: 0.5 },
-      { side: 'top', offset: 0.5 },
-    ]);
-  });
-});