@bendyline/squisq 2.1.0 → 2.3.0

package/src/__tests__/asciiDiagramPipeline.test.ts

@@ -1,273 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMarkdown, stringifyMarkdown } from '../markdown/index';
-import { markdownToDoc } from '../doc/markdownToDoc';
-import { docToMarkdown } from '../doc/docToMarkdown';
-import { materializeLayers } from './materializeTestUtils';
-import { profileBlockContents, recommendTemplatesForBlock } from '../recommend/templates';
-import type { Block, Layer } from '../schemas/Doc';
-import type { DiagramTemplateEdge, DiagramTemplateNode } from '../schemas/BlockTemplates';
-import { NESTED_CONTAINER, TWO_BOX_VERTICAL } from './fixtures/asciiDiagrams';
-
-const fenced = (art: string, lang = ''): string => '```' + lang + '\n' + art + '\n```';
-
-const AUTO_DOC = ['# Systems', '', '## Architecture', '', fenced(TWO_BOX_VERTICAL), ''].join('\n');
-
-function convert(md: string, options?: Parameters<typeof markdownToDoc>[1]) {
-  return markdownToDoc(parseMarkdown(md), { generateCoverBlock: false, ...options });
-}
-
-function findBlock(doc: { blocks: Block[] }, title: string): Block | undefined {
-  const walk = (blocks: Block[]): Block | undefined => {
-    for (const b of blocks) {
-      if (b.title === title) return b;
-      const inner = b.children ? walk(b.children) : undefined;
-      if (inner) return inner;
-    }
-    return undefined;
-  };
-  return walk(doc.blocks);
-}
-
-describe('auto-template conversion of ASCII diagram fences', () => {
-  it('converts a heading with a lone eligible fence into an ephemeral diagram block', () => {
-    const doc = convert(AUTO_DOC);
-    const block = findBlock(doc, 'Architecture');
-    expect(block?.template).toBe('diagram');
-    expect(block?.autoTemplate).toBe(true);
-    const nodes = block?.templateData?.nodes as DiagramTemplateNode[];
-    const edges = block?.templateData?.edges as DiagramTemplateEdge[];
-    expect(nodes?.map((n) => n.id)).toEqual(['alpha', 'beta']);
-    expect(nodes?.[0].w).toBeGreaterThan(0);
-    expect(edges).toEqual([
-      {
-        source: 'alpha',
-        target: 'beta',
-        sourceAnchor: { side: 'bottom', offset: 0.5 },
-        targetAnchor: { side: 'top', offset: 0.5 },
-        routing: 'orthogonal',
-      },
-    ]);
-    expect(block?.templateData?.title).toBe('Architecture');
-  });
-
-  it('round-trips losslessly: fence byte-identical, no annotation injected', () => {
-    const doc = convert(AUTO_DOC);
-    const output = stringifyMarkdown(docToMarkdown(doc));
-    expect(output).toContain(TWO_BOX_VERTICAL);
-    expect(output).not.toContain('{[diagram');
-  });
-
-  it('respects the autoTemplates option kill switch', () => {
-    const doc = convert(AUTO_DOC, { autoTemplates: false });
-    const block = findBlock(doc, 'Architecture');
-    expect(block?.template).not.toBe('diagram');
-  });
-
-  it('respects the squisq-auto-templates frontmatter kill switch', () => {
-    const md = `---\nsquisq-auto-templates: false\n---\n\n${AUTO_DOC}`;
-    const doc = convert(md);
-    const block = findBlock(doc, 'Architecture');
-    expect(block?.template).not.toBe('diagram');
-  });
-
-  it('does not convert when the fence has a real language', () => {
-    const md = ['## Architecture', '', fenced(TWO_BOX_VERTICAL, 'js'), ''].join('\n');
-    const block = findBlock(convert(md), 'Architecture');
-    expect(block?.template).not.toBe('diagram');
-  });
-
-  it('does not convert when a table competes with the fence', () => {
-    const md = [
-      '## Architecture',
-      '',
-      '| a | b |',
-      '|---|---|',
-      '| 1 | 2 |',
-      '',
-      fenced(TWO_BOX_VERTICAL),
-      '',
-    ].join('\n');
-    const block = findBlock(convert(md), 'Architecture');
-    expect(block?.template).not.toBe('diagram');
-  });
-
-  it('does not convert when two fences are present', () => {
-    const md = ['## Architecture', '', fenced(TWO_BOX_VERTICAL), '', fenced('plain code'), ''].join(
-      '\n',
-    );
-    const block = findBlock(convert(md), 'Architecture');
-    expect(block?.template).not.toBe('diagram');
-  });
-
-  it('does not convert when heavy prose surrounds the fence', () => {
-    const prose = 'Lots of surrounding explanation text. '.repeat(15);
-    const md = ['## Architecture', '', prose, '', fenced(TWO_BOX_VERTICAL), ''].join('\n');
-    const block = findBlock(convert(md), 'Architecture');
-    expect(block?.template).not.toBe('diagram');
-  });
-});
-
-describe('explicit `diagram`-tagged fence (survives edit → round-trip)', () => {
-  // The `diagram` fence LANGUAGE is the durable "block tag" — it round-trips
-  // through markdown ↔ Tiptap as `class="language-diagram"`, and explicit-lang
-  // detection accepts a degenerate single-box diagram that would otherwise be
-  // rejected (the ≥2-box floor is for UNTAGGED auto-detection only).
-  const ONE_BOX = ['┌────────┐', '│ Solo   │', '└────────┘'].join('\n');
-  const TAGGED_DOC = ['# Systems', '', '## Architecture', '', fenced(ONE_BOX, 'diagram'), ''].join(
-    '\n',
-  );
-
-  it('a bare single-box fence does NOT become a diagram', () => {
-    const md = ['## Architecture', '', fenced(ONE_BOX), ''].join('\n');
-    expect(findBlock(convert(md), 'Architecture')?.template).not.toBe('diagram');
-  });
-
-  it('a `diagram`-tagged single-box fence DOES become a diagram', () => {
-    const block = findBlock(convert(TAGGED_DOC), 'Architecture');
-    expect(block?.template).toBe('diagram');
-    expect(block?.autoTemplate).toBe(true);
-    const nodes = block?.templateData?.nodes as DiagramTemplateNode[];
-    expect(nodes?.map((n) => n.id)).toEqual(['solo']);
-  });
-
-  it('round-trips losslessly: fence + `diagram` lang preserved, no annotation injected', () => {
-    const output = stringifyMarkdown(docToMarkdown(convert(TAGGED_DOC)));
-    expect(output).toContain('```diagram');
-    expect(output).toContain(ONE_BOX);
-    expect(output).not.toContain('{[diagram');
-    // Re-importing keeps it a diagram — the identity is sticky.
-    expect(findBlock(convert(output), 'Architecture')?.template).toBe('diagram');
-  });
-
-  it('profiles a `diagram`-tagged single-box fence as hasAsciiDiagram', () => {
-    const md = parseMarkdown(fenced(ONE_BOX, 'diagram'));
-    const profile = profileBlockContents(md.children as Parameters<typeof profileBlockContents>[0]);
-    expect(profile.hasAsciiDiagram).toBe(true);
-  });
-});
-
-describe('explicit {[diagram]} annotation with an ASCII fence', () => {
-  const EXPLICIT_DOC = ['## Flow {[diagram]}', '', fenced(TWO_BOX_VERTICAL), ''].join('\n');
-
-  it('derives nodes/edges even with autoTemplates off', () => {
-    const doc = convert(EXPLICIT_DOC, { autoTemplates: false });
-    const block = findBlock(doc, 'Flow');
-    expect(block?.template).toBe('diagram');
-    const nodes = block?.templateData?.nodes as DiagramTemplateNode[];
-    expect(nodes?.map((n) => n.id)).toEqual(['alpha', 'beta']);
-  });
-
-  it('keeps the explicit annotation and fence through a round-trip', () => {
-    const doc = convert(EXPLICIT_DOC);
-    const output = stringifyMarkdown(docToMarkdown(doc));
-    expect(output).toContain('{[diagram]}');
-    expect(output).toContain(TWO_BOX_VERTICAL);
-  });
-
-  it('lets an author json data fence win over the ASCII fence', () => {
-    const md = [
-      '## Flow {[diagram]}',
-      '',
-      '```json data',
-      JSON.stringify({
-        nodes: [
-          { id: 'only', label: 'Only', x: 0, y: 0 },
-          { id: 'two', label: 'Two', x: 200, y: 0 },
-        ],
-        edges: [],
-      }),
-      '```',
-      '',
-    ].join('\n');
-    const doc = convert(md);
-    const block = findBlock(doc, 'Flow');
-    const nodes = block?.templateData?.nodes as DiagramTemplateNode[];
-    expect(nodes?.map((n) => n.id)).toEqual(['only', 'two']);
-  });
-
-  it('records a diagnostic when the fence does not parse as a diagram', () => {
-    const md = ['## Flow {[diagram]}', '', fenced('just some text\nnothing else\nhere'), ''].join(
-      '\n',
-    );
-    const doc = convert(md);
-    expect(doc.diagnostics?.some((d) => d.code === 'ascii-diagram-parse')).toBe(true);
-  });
-
-  it('children-driven diagrams win over a stray fence in the body', () => {
-    const md = [
-      '## Flow {[diagram]}',
-      '',
-      fenced(TWO_BOX_VERTICAL),
-      '',
-      '### NodeA {#node-a x=100 y=100}',
-      '',
-      '### NodeB {#node-b x=400 y=100 connectsTo=node-a}',
-      '',
-    ].join('\n');
-    const doc = convert(md);
-    const block = findBlock(doc, 'Flow');
-    expect(block?.children?.length).toBe(2);
-    expect(block?.templateData?.nodes).toBeUndefined();
-  });
-});
-
-describe('rendering derived diagrams through materializeBlockLayers', () => {
-  it('renders container cards behind leaf cards with per-node sizes', () => {
-    const md = ['## Pipeline', '', fenced(NESTED_CONTAINER), ''].join('\n');
-    const doc = convert(md);
-    const block = findBlock(doc, 'Pipeline');
-    expect(block?.template).toBe('diagram');
-    const layers = materializeLayers(block as Block, {});
-    const ids = layers.map((l: Layer) => l.id);
-    // Container card present and drawn before (behind) leaf cards.
-    const containerIdx = ids.indexOf('node-card-data-pipeline');
-    const leafIdx = ids.indexOf('node-card-ingest');
-    expect(containerIdx).toBeGreaterThanOrEqual(0);
-    expect(leafIdx).toBeGreaterThan(containerIdx);
-    // Edges exist.
-    expect(ids.some((id) => id.startsWith('edge-'))).toBe(true);
-  });
-
-  it('renders undirected edges without an end marker', () => {
-    const art = [
-      '┌────────┐     ┌────────┐',
-      '│ Left   │─────│ Right  │',
-      '└────────┘     └────────┘',
-    ].join('\n');
-    const md = ['## Pair', '', fenced(art), ''].join('\n');
-    const block = findBlock(convert(md), 'Pair');
-    const layers = materializeLayers(block as Block, {});
-    const edge = layers.find((l: Layer) => l.id.startsWith('edge-'));
-    expect(edge).toBeDefined();
-    expect((edge as { content: { endMarker?: string } }).content.endMarker).toBeUndefined();
-  });
-});
-
-describe('duration/caption hygiene', () => {
-  it('excludes a consumed fence from reading-time and captions', () => {
-    // The size of the consumed art must not affect the block's duration:
-    // a tiny diagram and a huge one read identically (the fence text is
-    // data, not narration).
-    const small = findBlock(convert(AUTO_DOC), 'Architecture');
-    const bigDoc = convert(
-      ['# Systems', '', '## Architecture', '', fenced(NESTED_CONTAINER), ''].join('\n'),
-    );
-    const big = findBlock(bigDoc, 'Architecture');
-    expect(small?.template).toBe('diagram');
-    expect(big?.template).toBe('diagram');
-    expect(big?.duration).toBe(small?.duration);
-    const captionText = (bigDoc.captions?.phrases ?? []).map((p) => p.text).join(' ');
-    expect(captionText).not.toContain('┌');
-    expect(captionText).not.toContain('│');
-  });
-});
-
-describe('template picker recommendation', () => {
-  it('surfaces diagram for a fence-bearing profile', () => {
-    const md = parseMarkdown(fenced(TWO_BOX_VERTICAL));
-    const profile = profileBlockContents(md.children as Parameters<typeof profileBlockContents>[0]);
-    expect(profile.hasAsciiDiagram).toBe(true);
-    const { recommended } = recommendTemplatesForBlock(profile, ['diagram', 'title', 'quote']);
-    expect(recommended).toContain('diagram');
-  });
-});

package/src/__tests__/asciiDiagramRender.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  asciiDiagramFromTemplateData,
-  asciiDiagramToTemplateData,
-  parseAsciiDiagram,
-  renderAsciiDiagram,
-  type AsciiDiagram,
-} from '../doc/asciiDiagram/index.js';
-import { POSITIVE_FIXTURES } from './fixtures/asciiDiagrams.js';
-
-/** Semantic equality: node ids/labels/containment + edge tuple sets. */
-function semanticSnapshot(d: AsciiDiagram): {
-  nodes: Array<{ id: string; label: string; containerId?: string }>;
-  edges: Array<{ source: string; target: string; label?: string; directed: boolean }>;
-} {
-  return {
-    nodes: [...d.nodes]
-      .map((n) => ({
-        id: n.id,
-        label: n.label,
-        ...(n.containerId ? { containerId: n.containerId } : {}),
-      }))
-      .sort((a, b) => a.id.localeCompare(b.id)),
-    edges: [...d.edges]
-      .map((e) => ({
-        source: e.source,
-        target: e.target,
-        ...(e.label ? { label: e.label } : {}),
-        directed: e.directed,
-      }))
-      .sort(
-        (a, b) =>
-          a.source.localeCompare(b.source) ||
-          a.target.localeCompare(b.target) ||
-          (a.label ?? '').localeCompare(b.label ?? ''),
-      ),
-  };
-}
-
-describe('renderAsciiDiagram — output shape', () => {
-  it('renders a simple two-node diagram with box borders and an arrow', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL);
-    const art = renderAsciiDiagram(d);
-    expect(art).toContain('┌');
-    expect(art).toContain('Alpha');
-    expect(art).toContain('Beta');
-    expect(art).toContain('▼');
-    expect(art).toContain('┬'); // junction on the source's bottom border
-    expect(art).toContain('┴'); // junction on the target's top border
-  });
-
-  it('emits ASCII vocabulary for ascii-style diagrams', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL_ASCII);
-    const art = renderAsciiDiagram(d);
-    expect(art).toContain('+--');
-    expect(art).toContain('v');
-    expect(art).not.toMatch(/[┌─│▼]/u);
-  });
-
-  it('honours a style override', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL);
-    const art = renderAsciiDiagram(d, { style: 'ascii' });
-    expect(art).not.toMatch(/[┌─│▼]/u);
-  });
-
-  it('grows a box when its label no longer fits', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL);
-    d.nodes[0] = { ...d.nodes[0], label: 'A much longer label than before' };
-    const art = renderAsciiDiagram(d);
-    expect(art).toContain('A much longer label than before');
-    const reparsed = parseAsciiDiagram(art);
-    expect(reparsed.nodes.map((n) => n.label)).toContain('A much longer label than before');
-  });
-
-  it('never shrinks a parsed box (visual stability)', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL);
-    const art = renderAsciiDiagram(d);
-    const reparsed = parseAsciiDiagram(art);
-    for (const node of reparsed.nodes) {
-      const original = d.nodes.find((n) => n.id === node.id);
-      expect(node.wCols).toBeGreaterThanOrEqual(original?.wCols ?? 0);
-      expect(node.hRows).toBeGreaterThanOrEqual(original?.hRows ?? 0);
-    }
-  });
-
-  it('renders containers with an embedded top-border title around their children', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.NESTED_CONTAINER);
-    const art = renderAsciiDiagram(d);
-    expect(art).toContain(' Data Pipeline ');
-    const reparsed = parseAsciiDiagram(art);
-    const children = reparsed.nodes.filter((n) => n.containerId === 'data-pipeline');
-    expect(children).toHaveLength(6);
-  });
-
-  it('merges a reciprocal directed pair into one double-arrow line', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.BIDIRECTIONAL);
-    const art = renderAsciiDiagram(d);
-    expect(art).toContain('◄');
-    expect(art).toContain('►');
-    // One line, not two.
-    const arrowRows = art.split('\n').filter((l) => l.includes('◄') || l.includes('►'));
-    expect(arrowRows).toHaveLength(1);
-  });
-
-  it('writes edge labels into a horizontal segment', () => {
-    const d = parseAsciiDiagram(POSITIVE_FIXTURES.EDGE_LABEL);
-    const art = renderAsciiDiagram(d);
-    expect(art).toContain(' auth ');
-  });
-
-  it('returns empty output for an empty diagram', () => {
-    expect(renderAsciiDiagram({ nodes: [], edges: [], style: 'unicode', warnings: [] })).toBe('');
-  });
-});
-
-describe('renderAsciiDiagram ↔ parseAsciiDiagram fixpoint', () => {
-  for (const [name, fixture] of Object.entries(POSITIVE_FIXTURES)) {
-    it(`semantic fixpoint + byte idempotence: ${name}`, () => {
-      const d1 = parseAsciiDiagram(fixture);
-      const t1 = renderAsciiDiagram(d1);
-      const d2 = parseAsciiDiagram(t1);
-      expect(semanticSnapshot(d2)).toEqual(semanticSnapshot(d1));
-      const t2 = renderAsciiDiagram(d2);
-      expect(t2).toBe(t1);
-      // Three full cycles stay byte-stable.
-      const d3 = parseAsciiDiagram(t2);
-      const t3 = renderAsciiDiagram(d3);
-      expect(t3).toBe(t1);
-    });
-  }
-
-  it('anti-churn: nudging one node by one column only changes locally', () => {
-    const d1 = parseAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL);
-    const t1 = renderAsciiDiagram(d1);
-    const d2 = parseAsciiDiagram(t1);
-    d2.nodes[1] = { ...d2.nodes[1], col: d2.nodes[1].col + 1 };
-    const t2 = renderAsciiDiagram(d2);
-    const d3 = parseAsciiDiagram(t2);
-    expect(semanticSnapshot(d3)).toEqual(semanticSnapshot(d1));
-    // Byte-stable after the nudge normalizes.
-    expect(renderAsciiDiagram(d3)).toBe(t2);
-  });
-});
-
-describe('templateData mapping round-trip', () => {
-  for (const [name, fixture] of Object.entries(POSITIVE_FIXTURES)) {
-    it(`grid → canvas → grid preserves semantics: ${name}`, () => {
-      const d1 = parseAsciiDiagram(fixture);
-      const { nodes, edges } = asciiDiagramToTemplateData(d1);
-      const d2 = asciiDiagramFromTemplateData(nodes, edges, { style: d1.style });
-      expect(semanticSnapshot(d2)).toEqual(semanticSnapshot(d1));
-      // Positions survive exactly (the mapping is scale + round).
-      for (const node of d2.nodes) {
-        const original = d1.nodes.find((n) => n.id === node.id);
-        expect({ col: node.col, row: node.row }).toEqual({
-          col: original?.col,
-          row: original?.row,
-        });
-      }
-    });
-  }
-});

package/src/__tests__/asciiDiagramRepair.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  repairAsciiDiagram,
-  isRepairableDiagram,
-  detectAsciiDiagram,
-  parseAsciiDiagram,
-} from '../doc/asciiDiagram/index.js';
-import { POSITIVE_FIXTURES } from './fixtures/asciiDiagrams.js';
-
-/**
- * Broken box art: package-name labels overflow their boxes and collide with
- * neighbours, so the columns desync row-to-row. Conservative detection
- * declines it (`garbled-labels`) — the opt-in repair pass reconstructs it.
- * (A shorter second label line keeps a real `│` on one interior row, which is
- * how real "half-broken" art still gives the tracer border evidence.)
- */
-const BROKEN = [
-  '┌──────────┐   ┌──────────┐',
-  '│ @scope/alpha-svc  │   │ @scope/beta-svc   │',
-  '│ one      │   │ two      │',
-  '└────┬─────┘   └────┬─────┘',
-  '     │              │',
-  '     ▼              ▼',
-  '┌────────────────────────────┐',
-  '│ @scope/gamma-store         │',
-  '│ persists                   │',
-  '└────────────────────────────┘',
-].join('\n');
-
-describe('isRepairableDiagram', () => {
-  it('is true for broken box art that conservative detection declines', () => {
-    expect(detectAsciiDiagram(BROKEN).isDiagram).toBe(false);
-    expect(isRepairableDiagram(BROKEN)).toBe(true);
-  });
-
-  it('is false for a clean diagram (the canvas already handles it)', () => {
-    expect(detectAsciiDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL).isDiagram).toBe(true);
-    expect(isRepairableDiagram(POSITIVE_FIXTURES.TWO_BOX_VERTICAL)).toBe(false);
-  });
-
-  it('is false for non-box art (prose, file trees)', () => {
-    expect(isRepairableDiagram('just some\nplain prose\nwith no boxes')).toBe(false);
-    expect(isRepairableDiagram('src/\n├── index.ts\n└── utils/')).toBe(false);
-  });
-});
-
-describe('repairAsciiDiagram', () => {
-  it('recovers clean labels from overflowing/colliding boxes (band-segment matching)', () => {
-    const r = repairAsciiDiagram(BROKEN);
-    expect(r).not.toBeNull();
-    const firstLines = r!.diagram.nodes.map((n) => n.label.split('\n')[0]);
-    expect(firstLines).toEqual(['@scope/alpha-svc', '@scope/beta-svc', '@scope/gamma-store']);
-    // Hyphens/slashes in labels survive (they're not box-drawing chars).
-    expect(firstLines.every((l) => l.includes('/') && l.includes('-'))).toBe(true);
-  });
-
-  it('recovers the fan-in edges', () => {
-    const r = repairAsciiDiagram(BROKEN)!;
-    const edgeSet = new Set(r.diagram.edges.map((e) => `${e.source}->${e.target}`));
-    expect(edgeSet.has('scope-alpha-svc->scope-gamma-store')).toBe(true);
-    expect(edgeSet.has('scope-beta-svc->scope-gamma-store')).toBe(true);
-    // No phantom edge between the two horizontally-adjacent source boxes.
-    expect(edgeSet.has('scope-alpha-svc->scope-beta-svc')).toBe(false);
-  });
-
-  it('produces art that re-parses cleanly as a diagram (repair is a real fixpoint entry)', () => {
-    const r = repairAsciiDiagram(BROKEN)!;
-    const redetect = detectAsciiDiagram(r.art);
-    expect(redetect.isDiagram).toBe(true);
-    // Same box count, and labels are no longer garbled.
-    const reparsed = parseAsciiDiagram(r.art);
-    expect(reparsed.nodes.length).toBe(r.diagram.nodes.length);
-    expect(redetect.reasons.join(' ')).not.toMatch(/garbled/);
-  });
-
-  it('returns null when fewer than two boxes can be recovered', () => {
-    expect(repairAsciiDiagram('just prose\nno boxes here')).toBeNull();
-    expect(repairAsciiDiagram('┌───┐\n│ A │\n└───┘')).toBeNull();
-  });
-
-  it('marks the diagram as repaired', () => {
-    expect(repairAsciiDiagram(BROKEN)!.diagram.warnings).toContain('repaired');
-  });
-});

package/src/__tests__/asciiTimelineDetect.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  detectAsciiTimeline,
-  isAsciiTimelineFence,
-  isEligibleAsciiTimelineFenceLang,
-  isExplicitTimelineLang,
-  renderAsciiTimeline,
-  type AsciiTimeline,
-} from '../doc/asciiTimeline/index.js';
-import { detectAsciiDiagram } from '../doc/asciiDiagram/index.js';
-import { detectTree } from '../doc/treeview/index.js';
-import type { MarkdownCodeBlock } from '../markdown/types.js';
-import {
-  MULTI_TRACK_BRANCH_TIMELINE,
-  SINGLE_POINT_ASCII_TIMELINE,
-  TICK_INTERPOLATION_TIMELINE,
-  WRAPPED_CLIENT_KERNEL_TIMELINE,
-} from './fixtures/asciiTimelines.js';
-
-describe('detectAsciiTimeline', () => {
-  it('recognizes the exact tick/interpolation example as an untagged timeline', () => {
-    const detection = detectAsciiTimeline(TICK_INTERPOLATION_TIMELINE);
-    expect(detection.isTimeline).toBe(true);
-    expect(detection.timeline?.tracks).toHaveLength(2);
-    expect(detection.reasons).toContain('strong-markers');
-  });
-
-  it('recognizes multiple tracks and an explicit branch declaration', () => {
-    const detection = detectAsciiTimeline(MULTI_TRACK_BRANCH_TIMELINE);
-    expect(detection.isTimeline).toBe(true);
-    expect(detection.timeline?.tracks).toHaveLength(2);
-    expect(detection.timeline?.links).toEqual([
-      { source: 't29', target: 'f29', label: 'interpolation path' },
-    ]);
-  });
-
-  it('conservatively recognizes a multi-lane flow with a wrapped return edge', () => {
-    const detection = detectAsciiTimeline(WRAPPED_CLIENT_KERNEL_TIMELINE);
-    expect(detection.isTimeline).toBe(true);
-    expect(detection.reasons).toContain('wrapped-flow');
-    expect(detection.timeline?.tracks).toHaveLength(2);
-    expect(detectAsciiDiagram(WRAPPED_CLIENT_KERNEL_TIMELINE).isDiagram).toBe(false);
-
-    const withoutReturn = WRAPPED_CLIENT_KERNEL_TIMELINE.replace(/┐/gu, '│').replace(/┘/gu, '│');
-    expect(detectAsciiTimeline(withoutReturn).isTimeline).toBe(false);
-  });
-
-  it('only accepts a sparse ASCII track when author intent is explicit', () => {
-    expect(detectAsciiTimeline(SINGLE_POINT_ASCII_TIMELINE).isTimeline).toBe(false);
-    const explicit = detectAsciiTimeline(SINGLE_POINT_ASCII_TIMELINE, { explicit: true });
-    expect(explicit.isTimeline).toBe(true);
-    expect(explicit.timeline?.tracks[0].events).toMatchObject([
-      { id: 'alpha', label: 'Alpha', marker: 'filled' },
-    ]);
-  });
-
-  it('accepts a cadence-only track through an explicit timeline fence', () => {
-    const cadence = 'client frames (120 Hz): f f f f f';
-    expect(detectAsciiTimeline(cadence).isTimeline).toBe(false);
-    expect(detectAsciiTimeline(cadence, { explicit: true }).isTimeline).toBe(true);
-    const fence: MarkdownCodeBlock = { type: 'code', lang: 'timeline', value: cadence };
-    expect(isAsciiTimelineFence(fence)).toBe(true);
-  });
-
-  it('keeps the exact sample mutually exclusive with tree and box-diagram codecs', () => {
-    expect(detectTree(TICK_INTERPOLATION_TIMELINE).isTree).toBe(false);
-    expect(detectAsciiDiagram(TICK_INTERPOLATION_TIMELINE).isDiagram).toBe(false);
-  });
-
-  it('does not steal a tree item whose label happens to contain a marker rail', () => {
-    const tree = ['root/', '├── ●────────● benchmark.txt', '└── notes.md'].join('\n');
-    expect(detectAsciiTimeline(tree).isTimeline).toBe(false);
-    expect(detectTree(tree).isTree).toBe(true);
-  });
-
-  it('does not steal marker rails inside deeply nested tree items', () => {
-    const tree = [
-      'root/',
-      '│   └── child/',
-      '│       └── grandchild/',
-      '│           └── ●────────● benchmark.txt',
-    ].join('\n');
-    expect(detectAsciiTimeline(tree).isTimeline).toBe(false);
-    expect(detectTree(tree).isTree).toBe(true);
-  });
-
-  it('leaves a single closed box as authored code instead of treating its top as an axis', () => {
-    const box = ['┌──●────●──┐', '│ content  │', '└──────────┘'].join('\n');
-    expect(detectAsciiTimeline(box).isTimeline).toBe(false);
-  });
-
-  it('allows a lone top elbow to act as an above-axis callout', () => {
-    const callout = ['     ┌─ warmup', '────●────●────►'].join('\n');
-    expect(detectAsciiTimeline(callout).isTimeline).toBe(true);
-  });
-
-  it('uses an inert-language allowlist and a durable explicit tag', () => {
-    for (const lang of [undefined, null, '', 'text', 'txt', 'plain', 'ascii', 'timeline']) {
-      expect(isEligibleAsciiTimelineFenceLang(lang)).toBe(true);
-    }
-    for (const lang of ['js', 'typescript', 'python', 'yaml', 'json', 'bash']) {
-      expect(isEligibleAsciiTimelineFenceLang(lang)).toBe(false);
-    }
-    for (const lang of ['timeline', ' Timeline ', 'TIMELINE']) {
-      expect(isExplicitTimelineLang(lang)).toBe(true);
-    }
-    expect(isExplicitTimelineLang('text')).toBe(false);
-  });
-
-  it('combines the language gate with explicit detection for code fences', () => {
-    const fence = (lang?: string): MarkdownCodeBlock => ({
-      type: 'code',
-      ...(lang !== undefined ? { lang } : {}),
-      value: SINGLE_POINT_ASCII_TIMELINE,
-    });
-    expect(isAsciiTimelineFence(fence())).toBe(false);
-    expect(isAsciiTimelineFence(fence('timeline'))).toBe(true);
-    expect(isAsciiTimelineFence(fence('js'))).toBe(false);
-  });
-
-  it('rejects over-wide art before running the grid parsers', () => {
-    const tooWide = `●${'─'.repeat(401)}●`;
-    expect(detectAsciiTimeline(tooWide)).toMatchObject({
-      isTimeline: false,
-      reasons: [expect.stringMatching(/^too-wide\(/)],
-    });
-  });
-
-  it('allows long canonical callout form while retaining the ordinary line cap', () => {
-    const timeline: AsciiTimeline = {
-      tracks: Array.from({ length: 150 }, (_, index) => ({
-        id: `track-${index}`,
-        label: `Track ${index}`,
-        row: index,
-        startColumn: 0,
-        endColumn: 10,
-        events: [
-          { id: `start-${index}`, label: 'Start', column: 0, side: 'above' as const },
-          { id: `end-${index}`, label: 'End', column: 10, side: 'below' as const },
-        ],
-      })),
-      links: [],
-      width: 11,
-      height: 150,
-      style: 'unicode',
-      warnings: [],
-    };
-    const canonical = renderAsciiTimeline(timeline);
-    expect(canonical.split('\n').length).toBeGreaterThan(400);
-    expect(detectAsciiTimeline(canonical, { explicit: true }).isTimeline).toBe(true);
-
-    const arbitrary = Array.from({ length: 401 }, () => '●────────●').join('\n');
-    expect(detectAsciiTimeline(arbitrary, { explicit: true }).reasons[0]).toMatch(
-      /^too-many-lines\(/,
-    );
-  });
-});