@bendyline/squisq 2.1.0 → 2.2.0

package/src/__tests__/asciiTimelineParse.test.ts

@@ -1,205 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { asciiTimelineToTemplateData, parseAsciiTimeline } from '../doc/asciiTimeline/index.js';
-import {
-  MULTI_TRACK_BRANCH_TIMELINE,
-  TICK_INTERPOLATION_TIMELINE,
-  WRAPPED_CLIENT_KERNEL_TIMELINE,
-} from './fixtures/asciiTimelines.js';
-
-describe('parseAsciiTimeline', () => {
-  it('extracts tick labels, delta callouts, and fractional pointer events from the exact sample', () => {
-    const timeline = parseAsciiTimeline(TICK_INTERPOLATION_TIMELINE);
-    expect(timeline.tracks).toHaveLength(2);
-
-    const [kernel, client] = timeline.tracks;
-    expect(kernel.label).toBe('kernel ticks (30 Hz)');
-    expect(kernel.endLabel).toBe('sim time');
-    expect(client.label).toBe('client frames (e.g. 120 Hz)');
-
-    const events = kernel.events;
-    const milestones = events.filter((event) => event.marker === 'filled');
-    expect(milestones.map((event) => event.label)).toEqual(['T28', 'T29', 'T30', 'T31']);
-    expect(milestones.map((event) => event.description)).toEqual([
-      'deltas sent: Δ28',
-      'Δ29',
-      'Δ30',
-      'Δ31',
-    ]);
-    expect(milestones.map((event) => event.side)).toEqual(['above', 'above', 'above', 'above']);
-    expect(milestones.map((event) => event.descriptionSide)).toEqual([
-      'below',
-      'below',
-      'below',
-      'below',
-    ]);
-
-    const cadence = client.events.filter((event) => event.callout === false);
-    expect(cadence).toHaveLength(16);
-    expect(cadence.every((event) => event.marker === 'hollow')).toBe(true);
-    expect(client.events).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          label: 'estimated kernel clock',
-          description: 'estTick ≈ 30.4',
-          marker: 'hollow',
-        }),
-        expect.objectContaining({
-          label: 'render position',
-          description: expect.stringContaining('interpolate between snapshot T28 and T29'),
-          marker: 'hollow',
-        }),
-      ]),
-    );
-  });
-
-  it('parses multiple tracks and resolves explicit branch declarations by stable event id', () => {
-    const timeline = parseAsciiTimeline(MULTI_TRACK_BRANCH_TIMELINE);
-    expect(timeline.tracks.map((track) => track.label)).toEqual(['Kernel', 'Client']);
-    expect(timeline.tracks.map((track) => track.events.map((event) => event.id))).toEqual([
-      ['t28', 't29'],
-      ['f28', 'f29'],
-    ]);
-    expect(timeline.links).toEqual([{ source: 't29', target: 'f29', label: 'interpolation path' }]);
-    expect(timeline.warnings).toEqual([]);
-  });
-
-  it('maps a wrapped client/kernel flow into tracks, events, and a return branch', () => {
-    const timeline = parseAsciiTimeline(WRAPPED_CLIENT_KERNEL_TIMELINE);
-    expect(timeline.warnings).toEqual([]);
-    expect(timeline.tracks.map((track) => track.label)).toEqual([
-      'CLIENT (main thread)',
-      'KERNEL (Web Worker / Node)',
-    ]);
-
-    const events = timeline.tracks.flatMap((track) => track.events);
-    expect(events.map((event) => event.label)).toEqual(
-      expect.arrayContaining([
-        'input events',
-        'InputMap',
-        'command',
-        'validate (schema)',
-        'command-rejected event',
-        'queue at tick T',
-        'dirty-tracked per-tick delta',
-        'delta {tick T}',
-        'interpolation buffer',
-        'keyframe',
-        'error surfaced to user/agent',
-      ]),
-    );
-    expect(events.find((event) => event.id === 'interpolation-buffer')?.description).toBe(
-      '(render ~1.5 ticks behind, lerp/slerp)',
-    );
-    expect(timeline.tracks[0].events.map((event) => event.id)).toEqual(
-      expect.arrayContaining(['input-events', 'inputmap', 'command', 'delta-tick-t', 'keyframe']),
-    );
-    expect(timeline.links).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ source: 'command', target: 'validate-schema' }),
-        expect.objectContaining({ source: 'dirty-tracked-per-tick-delta', target: 'delta-tick-t' }),
-        expect.objectContaining({
-          source: 'command-rejected-event',
-          target: 'error-surfaced-to-user-agent',
-        }),
-      ]),
-    );
-  });
-
-  it('normalizes every track against one shared horizontal scale', () => {
-    const timeline = parseAsciiTimeline(MULTI_TRACK_BRANCH_TIMELINE);
-    const { tracks, links } = asciiTimelineToTemplateData(timeline);
-    expect(tracks).toHaveLength(2);
-    expect(tracks[0].events.map((event) => event.position)).toEqual(
-      tracks[1].events.map((event) => event.position),
-    );
-    for (const event of tracks.flatMap((track) => track.events)) {
-      expect(event.position).toBeGreaterThanOrEqual(0);
-      expect(event.position).toBeLessThanOrEqual(1);
-    }
-    expect(links).toEqual(timeline.links);
-  });
-
-  it('is deterministic and never throws on empty or malformed input', () => {
-    expect(parseAsciiTimeline('')).toMatchObject({ tracks: [], links: [], warnings: [] });
-    expect(() => parseAsciiTimeline('not a timeline\nfunction x() {}')).not.toThrow();
-    expect(parseAsciiTimeline(MULTI_TRACK_BRANCH_TIMELINE)).toEqual(
-      parseAsciiTimeline(MULTI_TRACK_BRANCH_TIMELINE.replace(/\n/g, '\r\n')),
-    );
-  });
-
-  it('keeps prose arrows and double hyphens inside inline event descriptions', () => {
-    const timeline = parseAsciiTimeline(
-      'Flow: ● Compare :: A > B; release--candidate {#compare side=above} ───►',
-    );
-
-    expect(timeline.tracks[0].events[0]).toMatchObject({
-      id: 'compare',
-      label: 'Compare',
-      description: 'A > B; release--candidate',
-    });
-  });
-
-  it('keeps leading CLI flags, negative values, and rail-like prose in authored labels', () => {
-    const timeline = parseAsciiTimeline('Flags: ● --watch ─────● -1.5 ─────● ─phase ─────►');
-
-    expect(timeline.tracks[0].events.map((event) => event.label)).toEqual([
-      '--watch',
-      '-1.5',
-      '─phase',
-    ]);
-  });
-
-  it('keeps direct-source arrow prose, pointer offsets, and end-label punctuation', () => {
-    const arrow = parseAsciiTimeline('Flow: ●────● Result :: A -> B');
-    expect(arrow.tracks[0].events[1].description).toBe('A -> B');
-
-    const pointer = parseAsciiTimeline(['●────────●────────►', '     ▲ -1.5'].join('\n'));
-    expect(pointer.tracks[0].events.map((event) => event.label)).toContain('-1.5');
-
-    const endLabel = parseAsciiTimeline('Track: ● A ─────● B ───► --phase');
-    expect(endLabel.tracks[0].endLabel).toBe('--phase');
-  });
-
-  it('does not duplicate a suffix-only axis label at the left edge', () => {
-    const track = parseAsciiTimeline('────●────●────► sim time').tracks[0];
-    expect(track.label).toBeUndefined();
-    expect(track.endLabel).toBe('sim time');
-  });
-
-  it('promotes a cadence point when an authored elbow adds a callout', () => {
-    const timeline = parseAsciiTimeline(['Client: f f f f', '        └─ dropped frame'].join('\n'));
-    expect(timeline.tracks[0].events).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ label: 'dropped frame', callout: true, side: 'below' }),
-      ]),
-    );
-  });
-
-  it('preserves a leading minus in an elbow callout', () => {
-    const timeline = parseAsciiTimeline(['●────────●────────►', '└─-1.5'].join('\n'));
-    expect(timeline.tracks[0].events[0].description).toBe('-1.5');
-  });
-
-  it('keeps trailing prose braces when they are not timeline metadata', () => {
-    const timeline = parseAsciiTimeline('Flow: ● Deploy {phase} ───►');
-    expect(timeline.tracks[0].events[0].label).toBe('Deploy {phase}');
-  });
-
-  it('segments multiple fractional pointers on the same row', () => {
-    const timeline = parseAsciiTimeline(
-      ['●────────●────────●────────►', '  ▲ A         ▲ B'].join('\n'),
-    );
-    const pointerLabels = timeline.tracks[0].events
-      .filter((event) => event.marker === 'hollow')
-      .map((event) => event.label);
-    expect(pointerLabels).toEqual(['A', 'B']);
-  });
-
-  it('does not turn hyphenated Unicode event labels into phantom ASCII markers', () => {
-    const timeline = parseAsciiTimeline('Flow: ● Go-live {#go} ─────● Done {#done} ─────►');
-
-    expect(timeline.style).toBe('unicode');
-    expect(timeline.tracks[0].events.map((event) => event.label)).toEqual(['Go-live', 'Done']);
-    expect(timeline.tracks[0].events.map((event) => event.id)).toEqual(['go', 'done']);
-  });
-});

package/src/__tests__/asciiTimelinePipeline.test.ts

@@ -1,349 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMarkdown, stringifyMarkdown } from '../markdown/index.js';
-import { markdownToDoc } from '../doc/markdownToDoc.js';
-import { docToMarkdown } from '../doc/docToMarkdown.js';
-import { materializeLayers } from './materializeTestUtils.js';
-import { profileBlockContents, recommendTemplatesForBlock } from '../recommend/templates.js';
-import type { Block, Layer } from '../schemas/Doc.js';
-import type { TimelineBlockInput, TimelineTemplateTrack } from '../schemas/BlockTemplates.js';
-import {
-  MULTI_TRACK_BRANCH_TIMELINE,
-  SINGLE_POINT_ASCII_TIMELINE,
-  TICK_INTERPOLATION_TIMELINE,
-  WRAPPED_CLIENT_KERNEL_TIMELINE,
-} from './fixtures/asciiTimelines.js';
-
-const fenced = (art: string, lang = ''): string => '```' + lang + '\n' + art + '\n```';
-const AUTO_DOC = [
-  '# Timing',
-  '',
-  '## Tick interpolation',
-  '',
-  fenced(TICK_INTERPOLATION_TIMELINE),
-  '',
-].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 block of blocks) {
-      if (block.title === title) return block;
-      const nested = block.children ? walk(block.children) : undefined;
-      if (nested) return nested;
-    }
-    return undefined;
-  };
-  return walk(doc.blocks);
-}
-
-describe('auto-template conversion of ASCII timeline fences', () => {
-  it('converts the exact sample into an ephemeral timeline block', () => {
-    const block = findBlock(convert(AUTO_DOC), 'Tick interpolation');
-    expect(block?.template).toBe('timeline');
-    expect(block?.autoTemplate).toBe(true);
-    const tracks = block?.templateData?.tracks as TimelineTemplateTrack[];
-    expect(tracks).toHaveLength(2);
-    expect(
-      tracks[0].events.filter((event) => event.marker === 'filled').map((event) => event.label),
-    ).toEqual(['T28', 'T29', 'T30', 'T31']);
-    expect(tracks[1].events.filter((event) => event.callout === false)).toHaveLength(16);
-    expect(block?.templateData?.title).toBe('Tick interpolation');
-  });
-
-  it('respects both auto-template kill switches', () => {
-    expect(
-      findBlock(convert(AUTO_DOC, { autoTemplates: false }), 'Tick interpolation')?.template,
-    ).not.toBe('timeline');
-    const frontmatter = `---\nsquisq-auto-templates: false\n---\n\n${AUTO_DOC}`;
-    expect(findBlock(convert(frontmatter), 'Tick interpolation')?.template).not.toBe('timeline');
-  });
-
-  it('does not claim the same art when it is tagged as a real programming language', () => {
-    const md = [
-      '## Tick interpolation',
-      '',
-      fenced(TICK_INTERPOLATION_TIMELINE, 'typescript'),
-      '',
-    ].join('\n');
-    expect(findBlock(convert(md), 'Tick interpolation')?.template).not.toBe('timeline');
-  });
-
-  it('round-trips the exact fence byte content without injecting an annotation', () => {
-    const output = stringifyMarkdown(docToMarkdown(convert(AUTO_DOC)));
-    expect(output).toContain(TICK_INTERPOLATION_TIMELINE);
-    expect(output).not.toContain('{[timeline');
-    expect(findBlock(convert(output), 'Tick interpolation')?.template).toBe('timeline');
-  });
-
-  it('auto-templates a wrapped client/kernel flow without changing its authored bytes', () => {
-    const markdown = ['## Client/kernel loop', '', fenced(WRAPPED_CLIENT_KERNEL_TIMELINE), ''].join(
-      '\n',
-    );
-    const doc = convert(markdown);
-    const block = findBlock(doc, 'Client/kernel loop');
-    expect(block?.template).toBe('timeline');
-    expect(block?.templateData?.tracks as TimelineTemplateTrack[]).toHaveLength(2);
-    expect(stringifyMarkdown(docToMarkdown(doc))).toContain(WRAPPED_CLIENT_KERNEL_TIMELINE);
-  });
-});
-
-describe('explicit timeline authoring', () => {
-  const TAGGED_DOC = ['## Release', '', fenced(SINGLE_POINT_ASCII_TIMELINE, 'timeline'), ''].join(
-    '\n',
-  );
-
-  it('uses the durable `timeline` language for a sparse one-point track', () => {
-    const block = findBlock(convert(TAGGED_DOC), 'Release');
-    expect(block?.template).toBe('timeline');
-    expect(block?.autoTemplate).toBe(true);
-    const tracks = block?.templateData?.tracks as TimelineTemplateTrack[];
-    expect(tracks[0].events).toMatchObject([{ id: 'alpha', label: 'Alpha' }]);
-
-    const output = stringifyMarkdown(docToMarkdown(convert(TAGGED_DOC)));
-    expect(output).toContain('```timeline');
-    expect(output).toContain(SINGLE_POINT_ASCII_TIMELINE);
-    expect(output).not.toContain('{[timeline');
-  });
-
-  it('derives timeline data from an explicit heading annotation even when auto templates are off', () => {
-    const md = [
-      '## Release {[timeline]}',
-      '',
-      fenced(SINGLE_POINT_ASCII_TIMELINE, 'text'),
-      '',
-    ].join('\n');
-    const block = findBlock(convert(md, { autoTemplates: false }), 'Release');
-    expect(block?.template).toBe('timeline');
-    expect((block?.templateData?.tracks as TimelineTemplateTrack[])[0].events).toMatchObject([
-      { id: 'alpha', label: 'Alpha' },
-    ]);
-  });
-
-  it('round-trips an explicit cadence-only timeline as marker-only events', () => {
-    const cadence = 'client frames (120 Hz): f f f f f';
-    const md = ['## Frames', '', fenced(cadence, 'timeline'), ''].join('\n');
-    const block = findBlock(convert(md), 'Frames');
-    expect(block?.template).toBe('timeline');
-    const tracks = block?.templateData?.tracks as TimelineTemplateTrack[];
-    expect(tracks[0].events).toHaveLength(5);
-    expect(tracks[0].events.every((event) => event.callout === false)).toBe(true);
-    const output = stringifyMarkdown(docToMarkdown(convert(md)));
-    expect(output).toContain('```timeline');
-    expect(output).toContain(cadence);
-  });
-
-  it('renders an authored callout attached to an otherwise marker-only cadence', () => {
-    const cadence = ['Client: f f f f', '        └─ dropped frame'].join('\n');
-    const md = ['## Frames', '', fenced(cadence, 'timeline'), ''].join('\n');
-    const block = findBlock(convert(md), 'Frames') as Block;
-    const layers = materializeLayers(block, {});
-    expect(
-      layers.some(
-        (layer: Layer) => layer.type === 'text' && layer.content.text === 'dropped frame',
-      ),
-    ).toBe(true);
-  });
-});
-
-describe('timeline rendering and narration hygiene', () => {
-  it('materializes track, marker, callout, and branch primitives', () => {
-    const md = ['## Runtime paths', '', fenced(MULTI_TRACK_BRANCH_TIMELINE), ''].join('\n');
-    const block = findBlock(convert(md), 'Runtime paths') as Block;
-    expect(block.template).toBe('timeline');
-    const layers = materializeLayers(block, {});
-    const ids = layers.map((layer: Layer) => layer.id);
-    expect(ids.filter((id) => /^timeline-track-(?!label-)/.test(id))).toHaveLength(2);
-    expect(ids.filter((id) => id.startsWith('timeline-marker-'))).toHaveLength(4);
-    expect(ids.some((id) => id.startsWith('timeline-event-label-'))).toBe(true);
-    expect(ids.some((id) => id.startsWith('timeline-event-description-'))).toBe(true);
-    expect(ids.some((id) => id.startsWith('timeline-link-t29-f29-'))).toBe(true);
-  });
-
-  it('renders cadence points without callout spam and keeps opposite-side descriptions', () => {
-    const block = findBlock(convert(AUTO_DOC), 'Tick interpolation') as Block;
-    const layers = materializeLayers(block, {});
-    const markers = layers.filter((layer: Layer) => layer.id.startsWith('timeline-marker-'));
-    const calloutText = layers
-      .filter((layer: Layer) => layer.type === 'text')
-      .map((layer) => (layer.type === 'text' ? layer.content.text : ''));
-
-    // 4 kernel milestones + 16 cadence points + 2 fractional client events.
-    expect(markers).toHaveLength(22);
-    expect(calloutText).not.toContain('f');
-    expect(calloutText).toContain('sim time');
-
-    const t28Label = layers.find((layer: Layer) =>
-      layer.id.startsWith('timeline-event-label-t28-'),
-    );
-    const t28Description = layers.find((layer: Layer) =>
-      layer.id.startsWith('timeline-event-description-t28-'),
-    );
-    const kernelTrack = layers.find(
-      (layer: Layer) => layer.id === 'timeline-track-kernel-ticks-30-hz-0',
-    );
-    expect(t28Label?.position.y).toEqual(expect.any(Number));
-    expect(t28Description?.position.y).toEqual(expect.any(Number));
-    expect(kernelTrack?.type).toBe('path');
-    if (
-      typeof t28Label?.position.y === 'number' &&
-      typeof t28Description?.position.y === 'number' &&
-      kernelTrack?.type === 'path'
-    ) {
-      const axisY = Number(/^M\s+\S+\s+(\S+)/.exec(kernelTrack.content.d)?.[1]);
-      expect(t28Label.position.y).toBeLessThan(axisY);
-      expect(t28Description.position.y).toBeGreaterThan(axisY);
-    }
-  });
-
-  it('surfaces unresolved branch declarations as document diagnostics', () => {
-    const art = [
-      'Main: ● Start {#start} ─────● Finish {#finish} ─────►',
-      'branch: start -> missing : typo',
-    ].join('\n');
-    const doc = convert(['## Broken branch', '', fenced(art), ''].join('\n'));
-    expect(doc.diagnostics).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          code: 'timeline-unresolved-link',
-          blockId: 'broken-branch',
-        }),
-      ]),
-    );
-  });
-
-  it('keeps endpoint callout boxes inside the viewport', () => {
-    const endpointBlock: TimelineBlockInput = {
-      id: 'endpoint-timeline',
-      template: 'timeline',
-      duration: 5,
-      audioSegment: 0,
-      tracks: [
-        {
-          id: 'edge',
-          events: [
-            { id: 'left', label: 'Left endpoint', position: 0, side: 'above' },
-            { id: 'right', label: 'Right endpoint', position: 1, side: 'below' },
-          ],
-        },
-      ],
-    };
-    const layers = materializeLayers(endpointBlock, {
-      viewport: { name: 'test-landscape', width: 1920, height: 1080 },
-    });
-    const labels = layers.filter(
-      (layer: Layer) => layer.type === 'text' && layer.id.startsWith('timeline-event-label-'),
-    );
-    expect(labels).toHaveLength(2);
-    for (const label of labels) {
-      const x = label.position.x;
-      const width = label.position.width;
-      expect(typeof x).toBe('number');
-      expect(typeof width).toBe('number');
-      if (typeof x === 'number' && typeof width === 'number') {
-        expect(x - width / 2).toBeGreaterThanOrEqual(0);
-        expect(x + width / 2).toBeLessThanOrEqual(1920);
-      }
-    }
-  });
-
-  it('does not repeat the title in an empty timeline hint', () => {
-    const empty: TimelineBlockInput = {
-      id: 'empty-timeline',
-      template: 'timeline',
-      duration: 5,
-      audioSegment: 0,
-      title: 'Release history',
-      tracks: [],
-    };
-    const text = materializeLayers(empty, {})
-      .filter((layer: Layer) => layer.type === 'text')
-      .map((layer) => (layer.type === 'text' ? layer.content.text : ''));
-    expect(text.filter((value) => value === 'Release history')).toHaveLength(1);
-    expect(text).toContain('No timeline events');
-  });
-
-  it('renders every public input event even when ids are duplicated across tracks', () => {
-    const duplicateIds: TimelineBlockInput = {
-      id: 'duplicate-event-ids',
-      template: 'timeline',
-      duration: 5,
-      audioSegment: 0,
-      tracks: [
-        { id: 'a', events: [{ id: 'start', label: 'A starts', position: 0.2 }] },
-        { id: 'b', events: [{ id: 'start', label: 'B starts', position: 0.8 }] },
-      ],
-    };
-
-    const layers = materializeLayers(duplicateIds, {});
-    expect(
-      layers.filter((layer: Layer) => layer.id.startsWith('timeline-marker-start-')),
-    ).toHaveLength(2);
-    expect(
-      layers
-        .filter(
-          (layer: Layer) =>
-            layer.type === 'text' && layer.id.startsWith('timeline-event-label-start-'),
-        )
-        .map((layer) => (layer.type === 'text' ? layer.content.text : '')),
-    ).toEqual(['A starts', 'B starts']);
-  });
-
-  it('routes a same-track branch opposite the source callout', () => {
-    const sameTrack: TimelineBlockInput = {
-      id: 'same-track-branch',
-      template: 'timeline',
-      duration: 5,
-      audioSegment: 0,
-      tracks: [
-        {
-          id: 'main',
-          events: [
-            { id: 'a', label: 'A', position: 0.2, side: 'above' },
-            { id: 'b', label: 'B', position: 0.8, side: 'below' },
-          ],
-        },
-      ],
-      links: [{ source: 'a', target: 'b' }],
-    };
-    const link = materializeLayers(sameTrack, {}).find(
-      (layer: Layer) => layer.type === 'path' && layer.id.startsWith('timeline-link-a-b-'),
-    );
-    expect(link?.type).toBe('path');
-    if (link?.type === 'path') {
-      const match = /^M\s+\S+\s+([-\d.]+)\s+C\s+\S+\s+([-\d.]+)/.exec(link.content.d);
-      expect(match).not.toBeNull();
-      if (match) expect(Number(match[2])).toBeGreaterThan(Number(match[1]));
-    }
-  });
-
-  it('excludes consumed ASCII art and callouts from captions', () => {
-    const doc = convert(AUTO_DOC);
-    const captionText = (doc.captions?.phrases ?? []).map((phrase) => phrase.text).join(' ');
-    expect(captionText).not.toContain('T28');
-    expect(captionText).not.toContain('Δ28');
-    expect(captionText).not.toContain('interpolate between snapshot');
-    expect(captionText).not.toContain('●');
-  });
-});
-
-describe('timeline recommendation', () => {
-  it('profiles the exact sample as timeline content, not tree content', () => {
-    const markdown = parseMarkdown(fenced(TICK_INTERPOLATION_TIMELINE));
-    const profile = profileBlockContents(
-      markdown.children as Parameters<typeof profileBlockContents>[0],
-    );
-    expect(profile.hasTimeline).toBe(true);
-    expect(profile.hasTree).toBe(false);
-    const { recommended } = recommendTemplatesForBlock(profile, [
-      'timeline',
-      'tree',
-      'diagram',
-      'title',
-    ]);
-    expect(recommended).toContain('timeline');
-    expect(recommended).not.toContain('tree');
-  });
-});