@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/getLayers.test.ts

@@ -1,243 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import type { MaterializeBlockLayersOptions } from '../doc/materializeBlockLayers.js';
-import { materializeLayers } from './materializeTestUtils.js';
-import { DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import { TemplateBlock, PersistentLayerConfig } from '../schemas/BlockTemplates.js';
-import { VIEWPORT_PRESETS } from '../schemas/Viewport.js';
-import type { Block, Layer, TextLayer, ShapeLayer } from '../schemas/Doc.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeTemplateBlock(overrides: Partial<TemplateBlock> = {}): TemplateBlock {
-  return {
-    template: 'title',
-    id: 'test-title-1',
-    duration: 5,
-    audioSegment: 0,
-    title: 'Hello World',
-    ...overrides,
-  } as TemplateBlock;
-}
-
-function makeRawBlock(layers: Layer[]): Block {
-  return {
-    id: 'raw-block-1',
-    duration: 5,
-    startTime: 0,
-    audioSegment: 0,
-    layers,
-  };
-}
-
-const defaultContext: MaterializeBlockLayersOptions = {
-  theme: DEFAULT_THEME,
-  viewport: VIEWPORT_PRESETS.landscape,
-  blockIndex: 0,
-  totalBlocks: 5,
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('materializeBlockLayers', () => {
-  it('generates layers for a known template block', () => {
-    const block = makeTemplateBlock({ template: 'title', title: 'Test Title' });
-    const layers = materializeLayers(block, defaultContext);
-
-    expect(Array.isArray(layers)).toBe(true);
-    expect(layers.length).toBeGreaterThan(0);
-
-    // titleBlock always produces at least a text layer with the title
-    const textLayer = layers.find((l) => l.type === 'text');
-    expect(textLayer).toBeDefined();
-    expect((textLayer as TextLayer).content.text).toContain('Test Title');
-  });
-
-  it('generates layers for statHighlight template', () => {
-    const block = makeTemplateBlock({
-      template: 'statHighlight',
-      stat: '42%',
-      description: 'of users',
-    });
-    const layers = materializeLayers(block, defaultContext);
-
-    expect(layers.length).toBeGreaterThan(0);
-    const texts = layers.filter((l) => l.type === 'text');
-    expect(texts.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('returns raw block layers when block has pre-computed layers', () => {
-    const existingLayers: Layer[] = [
-      {
-        type: 'shape',
-        id: 'test-shape',
-        content: { shape: 'rect', fill: '#ff0000' },
-        position: { x: 0, y: 0, width: 100, height: 100 },
-      } as ShapeLayer,
-    ];
-    const block = makeRawBlock(existingLayers);
-    const layers = materializeLayers(block, defaultContext);
-
-    expect(layers).toEqual(existingLayers);
-    expect(layers).not.toBe(existingLayers);
-    expect(layers[0]).not.toBe(existingLayers[0]);
-    (layers[0] as ShapeLayer).content.fill = '#000000';
-    expect((existingLayers[0] as ShapeLayer).content.fill).toBe('#ff0000');
-  });
-
-  it('resolves legacy template aliases through TEMPLATE_ALIASES', () => {
-    // Regression: the old resolver used `block.template in templateRegistry`
-    // without alias resolution, so docs authored with the legacy long ids
-    // (`titleBlock`, `quoteBlock`, `mapBlock`, `listBlock`) rendered as
-    // empty SVG cards in the linear/document view — `hasTemplate()` accepts
-    // the alias, so `isAnnotatedBlock` returns true and the card wrapper
-    // renders, but the registry lookup below would miss the alias and the
-    // layer array came back empty.
-    const aliasedToCanonical: Array<[string, string]> = [
-      ['titleBlock', 'title'],
-      ['quoteBlock', 'quote'],
-      ['listBlock', 'list'],
-    ];
-    for (const [alias] of aliasedToCanonical) {
-      const block = makeTemplateBlock({
-        template: alias as TemplateBlock['template'],
-        title: 'Aliased',
-        items: ['a', 'b', 'c'],
-        quote: 'q',
-      } as Partial<TemplateBlock>);
-      const layers = materializeLayers(block, defaultContext);
-      expect(layers.length).toBeGreaterThan(0);
-    }
-  });
-
-  it('renders a visible fallback card for unknown templates (never blank)', () => {
-    const block = {
-      template: 'totally_nonexistent',
-      id: 'unknown-1',
-      duration: 5,
-      audioSegment: 0,
-    } as unknown as TemplateBlock;
-    const layers = materializeLayers(block, defaultContext);
-
-    expect(layers.length).toBeGreaterThan(0);
-    const noticeText = layers
-      .map((l) => (l.type === 'text' ? ((l.content as { text?: string }).text ?? '') : ''))
-      .join('\n');
-    expect(noticeText).toContain('Unknown template "totally_nonexistent"');
-  });
-
-  it('returns empty array for block with no template and no layers', () => {
-    const block: Block = { id: 'empty-1', duration: 5, startTime: 0, audioSegment: 0 };
-    const layers = materializeLayers(block, defaultContext);
-
-    expect(layers).toEqual([]);
-  });
-
-  it('uses default context values when context is omitted', () => {
-    const block = makeTemplateBlock({ template: 'title', title: 'Defaults' });
-    const layers = materializeLayers(block);
-
-    expect(Array.isArray(layers)).toBe(true);
-    expect(layers.length).toBeGreaterThan(0);
-  });
-
-  it('handles template that throws an error gracefully', () => {
-    // We spy on console.error to suppress noise and verify it was called
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    // comparisonBar requires numeric values; passing invalid data may throw
-    // but materialization should degrade without throwing
-    const block = makeTemplateBlock({
-      template: 'comparisonBar',
-      // Missing required fields
-    });
-    const layers = materializeLayers(block, defaultContext);
-
-    expect(Array.isArray(layers)).toBe(true);
-    consoleSpy.mockRestore();
-  });
-
-  describe('persistent layers injection', () => {
-    const bottomLayer: Layer = {
-      type: 'shape',
-      id: 'bottom',
-      content: { shape: 'rect', fill: '#000' },
-      position: { x: 0, y: 0, width: 100, height: 100 },
-    } as ShapeLayer;
-
-    const topLayer: Layer = {
-      type: 'shape',
-      id: 'top',
-      content: { shape: 'rect', fill: '#fff' },
-      position: { x: 0, y: 0, width: 100, height: 100 },
-    } as ShapeLayer;
-
-    const persistentConfig: PersistentLayerConfig = {
-      bottomLayers: [bottomLayer],
-      topLayers: [topLayer],
-    };
-
-    it('injects persistent bottom and top layers around block layers', () => {
-      const block = makeTemplateBlock({ template: 'title', title: 'With Persistent' });
-      const layers = materializeLayers(block, {
-        ...defaultContext,
-        persistentLayers: persistentConfig,
-      });
-
-      // First layer should be the bottom persistent layer
-      expect(layers[0]).toEqual(bottomLayer);
-      // Last layer should be the top persistent layer
-      expect(layers[layers.length - 1]).toEqual(topLayer);
-      // Middle layers (from template) should exist
-      expect(layers.length).toBeGreaterThan(2);
-    });
-
-    it('respects useBottomLayer: false opt-out', () => {
-      const block = makeTemplateBlock({
-        template: 'title',
-        title: 'No Bottom',
-        useBottomLayer: false,
-      });
-      const layers = materializeLayers(block, {
-        ...defaultContext,
-        persistentLayers: persistentConfig,
-      });
-
-      // Should NOT start with the bottom persistent layer
-      expect(layers[0]).not.toEqual(bottomLayer);
-      // Should still end with the top persistent layer
-      expect(layers[layers.length - 1]).toEqual(topLayer);
-    });
-
-    it('respects useTopLayer: false opt-out', () => {
-      const block = makeTemplateBlock({
-        template: 'title',
-        title: 'No Top',
-        useTopLayer: false,
-      });
-      const layers = materializeLayers(block, {
-        ...defaultContext,
-        persistentLayers: persistentConfig,
-      });
-
-      // Should start with the bottom persistent layer
-      expect(layers[0]).toEqual(bottomLayer);
-      // Should NOT end with the top persistent layer
-      expect(layers[layers.length - 1]).not.toEqual(topLayer);
-    });
-
-    it('skips injection when no persistent layers are configured', () => {
-      const block = makeTemplateBlock({ template: 'title', title: 'No Persistent' });
-      const withoutPersistent = materializeLayers(block, defaultContext);
-      const withEmptyPersistent = materializeLayers(block, {
-        ...defaultContext,
-        persistentLayers: { bottomLayers: [], topLayers: [] },
-      });
-
-      expect(withoutPersistent).toEqual(withEmptyPersistent);
-    });
-  });
-});

package/src/__tests__/getLayersFallback.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { parseMarkdown } from '../markdown/parse.js';
-import { markdownToDoc } from '../doc/markdownToDoc.js';
-import { materializeLayers } from './materializeTestUtils.js';
-import { templateRegistry } from '../doc/templates/index.js';
-import type { Block, Layer } from '../schemas/Doc.js';
-
-function textOf(layers: Layer[]): string {
-  return layers
-    .map((l) => (l.type === 'text' ? ((l.content as { text?: string }).text ?? '') : ''))
-    .join('\n');
-}
-
-function firstBlock(md: string): Block {
-  return markdownToDoc(parseMarkdown(md)).blocks[0];
-}
-
-describe('materializeBlockLayers — graceful degradation', () => {
-  it('renders an unknown template as a plain card with title, body, and notice', () => {
-    const block = firstBlock('## My Section {[photGrid]}\n\nSome body prose here.');
-    const layers = materializeLayers(block);
-    expect(layers.length).toBeGreaterThan(0);
-    const text = textOf(layers);
-    expect(text).toContain('My Section');
-    expect(text).toContain('Some body prose here.');
-    expect(text).toContain('Unknown template "photGrid"');
-  });
-
-  it('renders a fallback card when a template function throws', () => {
-    (templateRegistry as Record<string, unknown>)['__boom'] = () => {
-      throw new Error('kaboom');
-    };
-    try {
-      const block: Block = {
-        id: 'b1',
-        startTime: 0,
-        duration: 5,
-        audioSegment: 0,
-        template: '__boom',
-        title: 'Exploding block',
-      };
-      const layers = materializeLayers(block);
-      expect(layers.length).toBeGreaterThan(0);
-      expect(textOf(layers)).toContain('Template "__boom" failed');
-      expect(textOf(layers)).toContain('Exploding block');
-    } finally {
-      delete (templateRegistry as Record<string, unknown>)['__boom'];
-    }
-  });
-
-  it('blocks with no template at all still return empty layers', () => {
-    const block: Block = { id: 'raw', startTime: 0, duration: 5, audioSegment: 0 };
-    expect(materializeLayers(block)).toEqual([]);
-  });
-});
-
-describe('materializeBlockLayers — structured data feeds templates', () => {
-  afterEach(() => {
-    delete (templateRegistry as Record<string, unknown>)['__capture'];
-  });
-
-  it('merges templateData and templateOverrides into the template input', () => {
-    let received: Record<string, unknown> | null = null;
-    (templateRegistry as Record<string, unknown>)['__capture'] = (
-      input: Record<string, unknown>,
-    ) => {
-      received = input;
-      return [];
-    };
-    const block: Block = {
-      id: 'b1',
-      startTime: 0,
-      duration: 5,
-      audioSegment: 0,
-      template: '__capture',
-      templateData: { rows: [['a', 'b']], zoom: 12 },
-      templateOverrides: { zoom: '14' },
-    };
-    materializeLayers(block);
-    expect(received).not.toBeNull();
-    expect(received!['rows']).toEqual([['a', 'b']]);
-    // String overrides from {[…]} params win last.
-    expect(received!['zoom']).toBe('14');
-  });
-
-  it('renders a dataTable from a GFM table in the markdown body', () => {
-    const md = [
-      '## People {[dataTable]}',
-      '',
-      '| Name | Age |',
-      '| --- | --- |',
-      '| Alice | 30 |',
-    ].join('\n');
-    const block = firstBlock(md);
-    const layers = materializeLayers(block);
-    expect(layers.length).toBeGreaterThan(0);
-    const tableLayer = layers.find((l) => l.type === 'table');
-    expect(tableLayer).toBeDefined();
-    const content = tableLayer!.content as { headers?: string[]; rows?: string[][] };
-    expect(content.headers).toEqual(['Name', 'Age']);
-    expect(content.rows).toEqual([['Alice', '30']]);
-  });
-});

package/src/__tests__/haversine.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { haversineDistance, calculateBearing } from '../spatial/Haversine';
-
-describe('haversineDistance', () => {
-  it('returns 0 for same point', () => {
-    const p = { lat: 47.6062, lng: -122.3321 };
-    expect(haversineDistance(p, p)).toBe(0);
-  });
-
-  it('calculates Seattle to Portland (~233 km)', () => {
-    const seattle = { lat: 47.6062, lng: -122.3321 };
-    const portland = { lat: 45.5152, lng: -122.6784 };
-    const dist = haversineDistance(seattle, portland);
-    expect(dist).toBeGreaterThan(230);
-    expect(dist).toBeLessThan(240);
-  });
-
-  it('calculates London to Paris (~344 km)', () => {
-    const london = { lat: 51.5074, lng: -0.1278 };
-    const paris = { lat: 48.8566, lng: 2.3522 };
-    const dist = haversineDistance(london, paris);
-    expect(dist).toBeGreaterThan(340);
-    expect(dist).toBeLessThan(350);
-  });
-
-  it('calculates antipodal points (~20,000 km)', () => {
-    const p1 = { lat: 0, lng: 0 };
-    const p2 = { lat: 0, lng: 180 };
-    const dist = haversineDistance(p1, p2);
-    expect(dist).toBeGreaterThan(20000);
-    expect(dist).toBeLessThan(20100);
-  });
-});
-
-describe('calculateBearing', () => {
-  it('returns ~0 for due north', () => {
-    const from = { lat: 0, lng: 0 };
-    const to = { lat: 10, lng: 0 };
-    const bearing = calculateBearing(from, to);
-    expect(bearing).toBeCloseTo(0, 0);
-  });
-
-  it('returns ~90 for due east', () => {
-    const from = { lat: 0, lng: 0 };
-    const to = { lat: 0, lng: 10 };
-    const bearing = calculateBearing(from, to);
-    expect(bearing).toBeCloseTo(90, 0);
-  });
-
-  it('returns ~180 for due south', () => {
-    const from = { lat: 10, lng: 0 };
-    const to = { lat: 0, lng: 0 };
-    const bearing = calculateBearing(from, to);
-    expect(bearing).toBeCloseTo(180, 0);
-  });
-
-  it('returns ~270 for due west', () => {
-    const from = { lat: 0, lng: 10 };
-    const to = { lat: 0, lng: 0 };
-    const bearing = calculateBearing(from, to);
-    expect(bearing).toBeCloseTo(270, 0);
-  });
-});

package/src/__tests__/iconResolve.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  resolveIcon,
-  canonicalIconToken,
-  looksLikeIconToken,
-  suggestIcons,
-} from '../icons/resolve';
-
-describe('resolveIcon — bare tokens', () => {
-  it('resolves a name that is unique across families', () => {
-    // `github` only exists in fa-brands.
-    const icon = resolveIcon('github');
-    expect(icon).not.toBeNull();
-    expect(icon!.family).toBe('brands');
-    expect(icon!.name).toBe('github');
-  });
-
-  it('returns null for a name that collides across families', () => {
-    // `user` ships in both solid and regular — bare form is ambiguous.
-    const icon = resolveIcon('user');
-    expect(icon).toBeNull();
-  });
-
-  it('returns null for unknown names', () => {
-    expect(resolveIcon('totallyMadeUp_____Name')).toBeNull();
-  });
-});
-
-describe('resolveIcon — qualified tokens', () => {
-  it('resolves an ambiguous name with the fa-solid: prefix', () => {
-    const icon = resolveIcon('fa-solid:user');
-    expect(icon).not.toBeNull();
-    expect(icon!.family).toBe('solid');
-    expect(icon!.name).toBe('user');
-  });
-
-  it('resolves the same name in the other family', () => {
-    const icon = resolveIcon('fa-regular:user');
-    expect(icon).not.toBeNull();
-    expect(icon!.family).toBe('regular');
-  });
-
-  it('accepts short family prefixes too', () => {
-    const icon = resolveIcon('brands:github');
-    expect(icon).not.toBeNull();
-    expect(icon!.family).toBe('brands');
-  });
-
-  it('returns null for an unknown family prefix', () => {
-    expect(resolveIcon('fa-foo:github')).toBeNull();
-  });
-
-  it('returns null for a qualified token whose name does not exist in that family', () => {
-    expect(resolveIcon('fa-brands:user')).toBeNull();
-  });
-});
-
-describe('canonicalIconToken', () => {
-  it('emits the bare form for unique names', () => {
-    const icon = resolveIcon('github')!;
-    expect(canonicalIconToken(icon)).toBe('github');
-  });
-
-  it('emits the qualified form for ambiguous names', () => {
-    const icon = resolveIcon('fa-solid:user')!;
-    expect(canonicalIconToken(icon)).toBe('fa-solid:user');
-  });
-});
-
-describe('suggestIcons', () => {
-  it('ranks "starts with" matches above "contains" matches', () => {
-    const results = suggestIcons('git');
-    // `github` (brands) starts with "git" → score 0; `digital-tachograph`
-    // contains "git" → score 1. The first must outrank the latter.
-    const githubIdx = results.findIndex((r) => r.entry.name === 'github');
-    const containsIdx = results.findIndex(
-      (r) => r.entry.name.includes('git') && !r.entry.name.startsWith('git'),
-    );
-    expect(githubIdx).toBeGreaterThanOrEqual(0);
-    if (containsIdx >= 0) {
-      expect(githubIdx).toBeLessThan(containsIdx);
-    }
-  });
-
-  it('returns canonical tokens (bare when unique, qualified otherwise)', () => {
-    const results = suggestIcons('user');
-    const userTokens = results.filter((r) => r.entry.name === 'user').map((r) => r.token);
-    // `user` is ambiguous — each match must be qualified.
-    expect(userTokens.every((t) => t.startsWith('fa-'))).toBe(true);
-  });
-
-  it('matches by keyword too', () => {
-    const results = suggestIcons('octocat'); // a github keyword
-    expect(results.some((r) => r.entry.name === 'github')).toBe(true);
-  });
-
-  it('honors the limit parameter', () => {
-    expect(suggestIcons('e', 5)).toHaveLength(5);
-  });
-
-  it('returns nothing useful for whitespace-only queries', () => {
-    // Empty / whitespace queries return the first N icons (score 3
-    // bucket) — useful as a "browse the catalog" affordance in pickers.
-    const results = suggestIcons('   ', 10);
-    expect(results).toHaveLength(10);
-    expect(results.every((r) => r.score === 3)).toBe(true);
-  });
-});
-
-describe('looksLikeIconToken', () => {
-  it('accepts alphanumeric tokens with hyphens, underscores, and one colon', () => {
-    expect(looksLikeIconToken('github')).toBe(true);
-    expect(looksLikeIconToken('fa-solid:user')).toBe(true);
-    expect(looksLikeIconToken('face-smile_wink')).toBe(true);
-  });
-
-  it('rejects whitespace and special characters', () => {
-    expect(looksLikeIconToken('hello world')).toBe(false);
-    expect(looksLikeIconToken('with/slash')).toBe(false);
-    expect(looksLikeIconToken('with$dollar')).toBe(false);
-  });
-});

package/src/__tests__/imageEditExportSvg.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildSvgString } from '../imageEdit/export';
-import { createEmptyImageEditDoc, addLayer } from '../imageEdit/state';
-import { MemoryContentContainer } from '../storage/ContentContainer';
-import type { ImageEditLayer } from '../schemas/ImageEditDoc';
-
-const container = new MemoryContentContainer();
-
-describe('buildSvgString — path (drawing shape) layers', () => {
-  it('renders a named shape (shapeKind) as a <path>, deriving d from the box', async () => {
-    let doc = createEmptyImageEditDoc(200, 200);
-    const diamond: ImageEditLayer = {
-      id: 'p1',
-      type: 'path',
-      position: { x: 10, y: 20, width: 100, height: 80 },
-      content: {
-        d: 'M 0 0',
-        shapeKind: 'diamond',
-        fill: '#3399ff',
-        stroke: '#1a4d80',
-        strokeWidth: 2,
-      },
-    };
-    doc = addLayer(doc, diamond);
-
-    const svg = await buildSvgString(doc, container);
-    expect(svg).toContain('<path');
-    expect(svg).toContain('fill="#3399ff"');
-    expect(svg).toContain('stroke="#1a4d80"');
-    // A diamond inscribed in [10,20,100,80] starts at the top-center (60,20).
-    expect(svg).toContain('d="M 60 20');
-    // The seed `d="M 0 0"` must NOT survive — geometry is re-derived.
-    expect(svg).not.toContain('d="M 0 0"');
-  });
-
-  it('renders an arrow path with an end marker def', async () => {
-    let doc = createEmptyImageEditDoc(200, 200);
-    const arrow: ImageEditLayer = {
-      id: 'a1',
-      type: 'path',
-      position: { x: 0, y: 0, width: 100, height: 100 },
-      content: {
-        d: 'M 0 0 L 100 100',
-        stroke: '#000000',
-        strokeWidth: 2,
-        fill: 'none',
-        endMarker: 'arrow',
-      },
-    };
-    doc = addLayer(doc, arrow);
-
-    const svg = await buildSvgString(doc, container);
-    expect(svg).toContain('<marker id="marker-end-a1"');
-    expect(svg).toContain('marker-end="url(#marker-end-a1)"');
-    expect(svg).toContain('fill="none"');
-  });
-
-  it('still renders native rect/circle/line shape layers', async () => {
-    let doc = createEmptyImageEditDoc(100, 100);
-    doc = addLayer(doc, {
-      id: 's1',
-      type: 'shape',
-      position: { x: 5, y: 5, width: 40, height: 30 },
-      content: { shape: 'rect', fill: '#fff', borderRadius: 4 },
-    });
-    const svg = await buildSvgString(doc, container);
-    expect(svg).toContain('<rect x="5" y="5" width="40" height="30"');
-    expect(svg).toContain('rx="4"');
-  });
-});

package/src/__tests__/imageEditState.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  createEmptyImageEditDoc,
-  addLayer,
-  removeLayer,
-  reorderLayer,
-  updateLayer,
-  setCanvas,
-} from '../imageEdit/state';
-import type { ImageEditLayer } from '../schemas/ImageEditDoc';
-
-function textLayer(id: string, text = 'hi'): ImageEditLayer {
-  return {
-    id,
-    type: 'text',
-    position: { x: 0, y: 0, width: 100, height: 30 },
-    content: { text, style: { fontSize: 16, color: '#000' } },
-  };
-}
-
-describe('imageEdit/state helpers', () => {
-  it('createEmptyImageEditDoc seeds canvas + meta', () => {
-    const doc = createEmptyImageEditDoc(800, 600, { sourcePath: 'src.png' });
-    expect(doc.version).toBe(1);
-    expect(doc.canvas).toEqual({ width: 800, height: 600, background: 'transparent' });
-    expect(doc.layers).toEqual([]);
-    expect(doc.meta?.sourcePath).toBe('src.png');
-    expect(doc.meta?.createdAt).toBeDefined();
-    expect(doc.meta?.updatedAt).toBeDefined();
-  });
-
-  it('addLayer appends and assigns id when missing', () => {
-    let doc = createEmptyImageEditDoc(100, 100);
-    doc = addLayer(doc, textLayer('a'));
-    doc = addLayer(doc, { ...textLayer(''), id: '' });
-    expect(doc.layers).toHaveLength(2);
-    expect(doc.layers[0]!.id).toBe('a');
-    expect(doc.layers[1]!.id).toMatch(/^layer-/);
-  });
-
-  it('removeLayer drops by id, no-op when missing', () => {
-    let doc = addLayer(createEmptyImageEditDoc(100, 100), textLayer('a'));
-    doc = addLayer(doc, textLayer('b'));
-    const after = removeLayer(doc, 'a');
-    expect(after.layers.map((l) => l.id)).toEqual(['b']);
-    const noop = removeLayer(after, 'missing');
-    expect(noop).toBe(after);
-  });
-
-  it('reorderLayer moves and clamps index', () => {
-    let doc = createEmptyImageEditDoc(100, 100);
-    for (const id of ['a', 'b', 'c']) doc = addLayer(doc, textLayer(id));
-    const moved = reorderLayer(doc, 'a', 99);
-    expect(moved.layers.map((l) => l.id)).toEqual(['b', 'c', 'a']);
-    const moved2 = reorderLayer(moved, 'a', -10);
-    expect(moved2.layers.map((l) => l.id)).toEqual(['a', 'b', 'c']);
-  });
-
-  it('updateLayer shallow-merges by id', () => {
-    let doc = addLayer(createEmptyImageEditDoc(100, 100), textLayer('a'));
-    doc = updateLayer(doc, 'a', { name: 'Title', opacity: 0.5 });
-    expect(doc.layers[0]!.name).toBe('Title');
-    expect(doc.layers[0]!.opacity).toBe(0.5);
-  });
-
-  it('setCanvas replaces canvas', () => {
-    const doc = setCanvas(createEmptyImageEditDoc(100, 100), {
-      width: 200,
-      height: 300,
-      background: '#fff',
-    });
-    expect(doc.canvas).toEqual({ width: 200, height: 300, background: '#fff' });
-  });
-});