@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/jsonForm.pointer.test.ts

@@ -1,149 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  escapePointerSegment,
-  appendPointer,
-  toPointer,
-  pointerSegments,
-  getByPointer,
-  setByPointer,
-  resolveRef,
-} from '../jsonForm/index.js';
-
-describe('pointer composition', () => {
-  it('escapes arbitrary member names and appends them safely', () => {
-    expect(escapePointerSegment('a~/b')).toBe('a~0~1b');
-    expect(appendPointer('/properties', 'a~/b')).toBe('/properties/a~0~1b');
-    expect(appendPointer('', '')).toBe('/');
-    expect(appendPointer('/', 'child')).toBe('//child');
-  });
-
-  it('validates an explicit base pointer before appending', () => {
-    expect(() => appendPointer('/bad~2base', 'child')).toThrow(/Invalid JSON Pointer/);
-  });
-});
-
-describe('toPointer', () => {
-  it('keeps pointer-form paths intact', () => {
-    expect(toPointer('/a/b')).toBe('/a/b');
-    expect(toPointer('/0/1')).toBe('/0/1');
-  });
-  it('converts dotted-form to pointer-form', () => {
-    expect(toPointer('user.role')).toBe('/user/role');
-    expect(toPointer('a')).toBe('/a');
-  });
-  it('returns empty for root', () => {
-    expect(toPointer('')).toBe('');
-    expect(toPointer('/')).toBe('/');
-  });
-  it('escapes ~ and / per RFC 6901', () => {
-    // dotted form does not allow / inside a segment; we test pointer-form decoding instead.
-    expect(pointerSegments('/a~1b')).toEqual(['a/b']);
-    expect(pointerSegments('/a~0b')).toEqual(['a~b']);
-  });
-  it('rejects malformed pointer syntax and escape sequences', () => {
-    expect(() => pointerSegments('not/a/pointer')).toThrow(/Invalid JSON Pointer/);
-    expect(() => pointerSegments('/bad~2escape')).toThrow(/Invalid JSON Pointer/);
-    expect(() => pointerSegments('/dangling~')).toThrow(/Invalid JSON Pointer/);
-  });
-});
-
-describe('getByPointer', () => {
-  const data = { user: { role: 'admin', tags: ['a', 'b'] } };
-  it('resolves nested object paths', () => {
-    expect(getByPointer(data, '/user/role')).toBe('admin');
-    expect(getByPointer(data, 'user.role')).toBe('admin');
-  });
-  it('resolves array indices', () => {
-    expect(getByPointer(data, '/user/tags/1')).toBe('b');
-  });
-  it('returns undefined for missing paths', () => {
-    expect(getByPointer(data, '/user/missing')).toBeUndefined();
-    expect(getByPointer(data, '/user/tags/9')).toBeUndefined();
-  });
-  it('returns the data itself for empty pointer', () => {
-    expect(getByPointer(data, '')).toBe(data);
-  });
-  it('treats "/" as the empty-string member per RFC 6901', () => {
-    expect(getByPointer({ '': 'empty key' }, '/')).toBe('empty key');
-  });
-  it('requires canonical array indices', () => {
-    expect(getByPointer({ values: ['a'] }, '/values/00')).toBeUndefined();
-    expect(getByPointer({ values: ['a'] }, '/values/-')).toBeUndefined();
-  });
-});
-
-describe('setByPointer', () => {
-  it('writes a leaf value immutably', () => {
-    const before = { a: 1, b: 2 };
-    const after = setByPointer(before, '/a', 99);
-    expect(after).toEqual({ a: 99, b: 2 });
-    expect(before).toEqual({ a: 1, b: 2 });
-  });
-  it('clones intermediate objects, shares siblings', () => {
-    const before = { x: { y: 1 }, z: { w: 2 } };
-    const after = setByPointer(before, '/x/y', 7);
-    expect(after).toEqual({ x: { y: 7 }, z: { w: 2 } });
-    expect(after.z).toBe(before.z);
-    expect(after.x).not.toBe(before.x);
-  });
-  it('writes into array indices', () => {
-    const before = { items: ['a', 'b', 'c'] };
-    const after = setByPointer(before, '/items/1', 'B');
-    expect(after.items).toEqual(['a', 'B', 'c']);
-    expect(after.items).not.toBe(before.items);
-  });
-  it('creates intermediate containers when missing', () => {
-    const after = setByPointer({}, '/a/b/0/c', 'leaf');
-    expect(after).toEqual({ a: { b: [{ c: 'leaf' }] } });
-  });
-  it('round-trips with getByPointer', () => {
-    const before = { a: { b: [{ c: 1 }, { c: 2 }] } };
-    const after = setByPointer(before, '/a/b/1/c', 42);
-    expect(getByPointer(after, '/a/b/1/c')).toBe(42);
-    expect(getByPointer(after, '/a/b/0/c')).toBe(1);
-  });
-  it('writes the empty-string member for "/"', () => {
-    expect(setByPointer({}, '/', 'value')).toEqual({ '': 'value' });
-  });
-  it('rejects non-canonical array indices instead of creating NaN properties', () => {
-    expect(() => setByPointer({ items: [] }, '/items/nope', 'x')).toThrow(/array index/i);
-    expect(() => setByPointer({ items: [] }, '/items/01', 'x')).toThrow(/array index/i);
-  });
-  it('writes prototype-shaped keys as safe own data properties', () => {
-    const before = {};
-    const after = setByPointer(before, '/__proto__/polluted', true) as Record<string, unknown>;
-    expect(Object.getPrototypeOf(after)).toBe(Object.prototype);
-    expect(Object.prototype).not.toHaveProperty('polluted');
-    expect(Object.prototype.hasOwnProperty.call(after, '__proto__')).toBe(true);
-    expect(getByPointer(after, '/__proto__/polluted')).toBe(true);
-
-    const constructorPath = setByPointer({}, '/constructor/prototype/polluted', true);
-    expect(getByPointer(constructorPath, '/constructor/prototype/polluted')).toBe(true);
-    expect(Object.prototype).not.toHaveProperty('polluted');
-  });
-});
-
-describe('resolveRef', () => {
-  const root = {
-    type: 'object',
-    properties: {
-      pet: { $ref: '#/$defs/Pet' },
-    },
-    $defs: {
-      Pet: { type: 'object', properties: { name: { type: 'string' } } },
-    },
-  };
-  it('returns referenced subschema for a local $ref', () => {
-    const ref = { $ref: '#/$defs/Pet' };
-    const resolved = resolveRef(ref, root);
-    expect(resolved?.type).toBe('object');
-    expect(resolved?.properties?.name?.type).toBe('string');
-  });
-  it('returns the schema unchanged when no $ref present', () => {
-    const node = { type: 'string' };
-    expect(resolveRef(node, root)).toBe(node);
-  });
-  it('returns undefined for unknown refs', () => {
-    expect(resolveRef({ $ref: '#/$defs/Nope' }, root)).toBeUndefined();
-  });
-});

package/src/__tests__/jsonForm.tokens.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildJsonFormTokens, resolveJsonFormTheme } from '../jsonForm/index.js';
-import { DARK_SURFACE, LIGHT_SURFACE, DEFAULT_THEME, applySurface } from '../schemas/index.js';
-
-const EXPECTED_SUFFIXES = [
-  'bg',
-  'text',
-  'muted',
-  'primary',
-  'accent',
-  'warning',
-  'border',
-  'input-bg',
-  'title-font',
-  'body-font',
-  'mono-font',
-  'radius',
-];
-
-describe('buildJsonFormTokens', () => {
-  it('emits the full token set for the viewer prefix', () => {
-    const tokens = buildJsonFormTokens(DEFAULT_THEME, LIGHT_SURFACE, { prefix: '--squisq-json' });
-    for (const suffix of EXPECTED_SUFFIXES) {
-      expect(tokens).toHaveProperty(`--squisq-json-${suffix}`);
-    }
-    expect(Object.keys(tokens)).toHaveLength(EXPECTED_SUFFIXES.length);
-  });
-
-  it('emits the full token set for the editor prefix', () => {
-    const tokens = buildJsonFormTokens(DEFAULT_THEME, LIGHT_SURFACE, {
-      prefix: '--squisq-jsonform',
-    });
-    for (const suffix of EXPECTED_SUFFIXES) {
-      expect(tokens).toHaveProperty(`--squisq-jsonform-${suffix}`);
-    }
-    expect(Object.keys(tokens)).toHaveLength(EXPECTED_SUFFIXES.length);
-  });
-
-  it('resolves colors from the applied surface (light vs dark differ)', () => {
-    const light = buildJsonFormTokens(DEFAULT_THEME, LIGHT_SURFACE, { prefix: '--squisq-json' });
-    const dark = buildJsonFormTokens(DEFAULT_THEME, DARK_SURFACE, { prefix: '--squisq-json' });
-    const lightTheme = applySurface(DEFAULT_THEME, LIGHT_SURFACE);
-    const darkTheme = applySurface(DEFAULT_THEME, DARK_SURFACE);
-    expect(light['--squisq-json-bg']).toBe(lightTheme.colors.background);
-    expect(dark['--squisq-json-bg']).toBe(darkTheme.colors.background);
-    // The two surfaces should not produce an identical background.
-    expect(light['--squisq-json-bg']).not.toBe(dark['--squisq-json-bg']);
-  });
-
-  it('falls back to DEFAULT_THEME when theme is undefined', () => {
-    const tokens = buildJsonFormTokens(undefined, undefined, { prefix: '--squisq-json' });
-    expect(tokens['--squisq-json-bg']).toBe(DEFAULT_THEME.colors.background);
-  });
-
-  it('does not apply surface when surface is undefined', () => {
-    const tokens = buildJsonFormTokens(DEFAULT_THEME, undefined, { prefix: '--squisq-json' });
-    expect(tokens['--squisq-json-bg']).toBe(DEFAULT_THEME.colors.background);
-    expect(tokens['--squisq-json-radius']).toBe(`${DEFAULT_THEME.style.borderRadius ?? 8}px`);
-  });
-
-  it('is pure — no window/matchMedia access required', () => {
-    // Runs fine even if window is momentarily undefined-like; the function
-    // never touches globals.
-    expect(() =>
-      buildJsonFormTokens(DEFAULT_THEME, DARK_SURFACE, { prefix: '--squisq-json' }),
-    ).not.toThrow();
-  });
-});
-
-describe('resolveJsonFormTheme', () => {
-  it('applies the surface to the theme', () => {
-    expect(resolveJsonFormTheme(DEFAULT_THEME, DARK_SURFACE)).toEqual(
-      applySurface(DEFAULT_THEME, DARK_SURFACE),
-    );
-  });
-
-  it('returns the base theme untouched when surface is undefined', () => {
-    expect(resolveJsonFormTheme(DEFAULT_THEME, undefined)).toBe(DEFAULT_THEME);
-  });
-
-  it('falls back to DEFAULT_THEME when theme is undefined', () => {
-    expect(resolveJsonFormTheme(undefined, undefined)).toBe(DEFAULT_THEME);
-  });
-});

package/src/__tests__/layoutBlock.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutBlock } from '../doc/templates/layoutBlock.js';
-import { createTemplateContext } from '../schemas/BlockTemplates.js';
-import { DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import { VIEWPORT_PRESETS } from '../schemas/Viewport.js';
-import { isContainerTemplate } from '../doc/templates/index.js';
-import { parseMarkdown } from '../markdown/parse.js';
-import type { Block, Layer, TextLayer } from '../schemas/Doc.js';
-import type { RawLayersInput } from '../schemas/BlockTemplates.js';
-
-function child(
-  id: string,
-  template: string,
-  overrides: Record<string, string> = {},
-  bodyMd = '',
-): Block {
-  return {
-    id,
-    startTime: 0,
-    duration: 0,
-    audioSegment: 0,
-    template,
-    templateOverrides: overrides,
-    ...(bodyMd ? { contents: parseMarkdown(bodyMd).children } : {}),
-  } as Block;
-}
-
-function ctxWith(children: Block[]) {
-  const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-  ctx.children = children;
-  return ctx;
-}
-
-const INPUT: RawLayersInput = { template: 'layout', id: 'lay', duration: 0, audioSegment: 0 };
-
-describe('layoutBlock template', () => {
-  it('returns a single hint layer for an empty layout', () => {
-    const layers = layoutBlock(INPUT, ctxWith([]));
-    expect(layers).toHaveLength(1);
-    expect(layers[0].type).toBe('text');
-    expect((layers[0] as TextLayer).content.text).toBe('Empty layout');
-  });
-
-  it('emits one layer per child, in document order, at absolute positions', () => {
-    const layers = layoutBlock(
-      INPUT,
-      ctxWith([
-        child('box-1', 'rectangle', { x: '760', y: '390', width: '400', height: '300' }),
-        child('text-1', 'text', { x: '360', y: '380', width: '1200', height: '320' }, 'Welcome'),
-      ]),
-    );
-    expect(layers.map((l) => l.id)).toEqual(['box-1', 'text-1']);
-    expect(layers[0].type).toBe('shape');
-    expect(layers[1].type).toBe('text');
-    expect((layers[1] as TextLayer).content.text).toBe('Welcome');
-    expect(layers[0].position).toMatchObject({ x: 760, y: 390 });
-  });
-});
-
-describe('layout container behavior', () => {
-  it('marks layout as a children-consuming container template', () => {
-    expect(isContainerTemplate('layout')).toBe(true);
-  });
-
-  it('renders a layout block through the template registry', async () => {
-    const { materializeBlockLayers } = await import('../doc/materializeBlockLayers.js');
-    const parent: Block = {
-      id: 'lay',
-      startTime: 0,
-      duration: 0,
-      audioSegment: 0,
-      template: 'layout',
-      children: [
-        child('text-1', 'text', { x: '360', y: '380', width: '1200', height: '320' }, 'Title'),
-        child('box-1', 'rectangle', { x: '760', y: '390', width: '400', height: '300' }),
-      ],
-    };
-    const layers = materializeBlockLayers(parent, { persistentLayers: false }).layers;
-    const types = new Set(layers.map((l: Layer) => l.type));
-    expect(types.has('text')).toBe(true);
-    expect(types.has('shape')).toBe(true);
-  });
-});

package/src/__tests__/layoutLayout.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { computeLayoutLayers } from '../doc/templates/layoutLayout.js';
-import { parseMarkdown } from '../markdown/parse.js';
-import type { ShapeLayer, TextLayer, ImageLayer, PathLayer } from '../schemas/Doc.js';
-
-const VP = { width: 1920, height: 1080 };
-
-function child(id: string, template: string, params: Record<string, string> = {}, bodyMd = '') {
-  return {
-    id,
-    template,
-    templateOverrides: params,
-    ...(bodyMd ? { contents: parseMarkdown(bodyMd).children } : {}),
-  };
-}
-
-describe('computeLayoutLayers', () => {
-  it('maps a text child to an absolutely-positioned TextLayer (body text + style)', () => {
-    const { layers } = computeLayoutLayers(
-      [
-        child(
-          'text-1',
-          'text',
-          {
-            x: '100',
-            y: '200',
-            width: '600',
-            height: '120',
-            fontSize: '48',
-            align: 'center',
-            valign: 'middle',
-            color: '#1e293b',
-          },
-          'Hello **world**',
-        ),
-      ],
-      VP,
-    );
-    expect(layers).toHaveLength(1);
-    const t = layers[0] as TextLayer;
-    expect(t.type).toBe('text');
-    expect(t.id).toBe('text-1');
-    expect(t.position).toMatchObject({ x: 100, y: 200, width: 600, height: 120 });
-    expect(t.content.text).toBe('Hello world'); // plain projection of the body
-    expect(t.content.style.fontSize).toBe(48);
-    expect(t.content.style.textAlign).toBe('center');
-    expect(t.content.style.verticalAlign).toBe('middle');
-    expect(t.content.style.color).toBe('#1e293b');
-  });
-
-  it('maps rectangle/circle children to ShapeLayers', () => {
-    const { layers } = computeLayoutLayers(
-      [
-        child('box-1', 'rectangle', {
-          x: '10',
-          y: '10',
-          width: '200',
-          height: '100',
-          fill: '#e0e7ff',
-          stroke: '#6366f1',
-          strokeWidth: '2',
-          borderRadius: '8',
-        }),
-        child('c-1', 'circle', { x: '300', y: '10', width: '120', height: '120' }),
-      ],
-      VP,
-    );
-    const shapes = layers.filter((l): l is ShapeLayer => l.type === 'shape');
-    expect(shapes.map((s) => s.content.shape)).toEqual(['rect', 'circle']);
-    expect(shapes[0].content.fill).toBe('#e0e7ff');
-    expect(shapes[0].content.borderRadius).toBe(8);
-    expect(shapes[0].position).toMatchObject({ x: 10, y: 10, width: 200, height: 100 });
-  });
-
-  it('maps an image child to an ImageLayer and skips one missing src', () => {
-    const { layers, warnings } = computeLayoutLayers(
-      [
-        child('img-1', 'image', {
-          x: '0',
-          y: '0',
-          width: '320',
-          height: '240',
-          src: 'pic.png',
-          alt: 'A pic',
-          fit: 'cover',
-        }),
-        child('img-2', 'image', { x: '0', y: '0' }),
-      ],
-      VP,
-    );
-    const imgs = layers.filter((l): l is ImageLayer => l.type === 'image');
-    expect(imgs).toHaveLength(1);
-    expect(imgs[0].content.src).toBe('pic.png');
-    expect(imgs[0].content.alt).toBe('A pic');
-    expect(imgs[0].content.fit).toBe('cover');
-    expect(warnings.some((w) => w.includes('img-2'))).toBe(true);
-  });
-
-  it('maps a named polygon to a PathLayer via shapePath', () => {
-    const { layers } = computeLayoutLayers(
-      [child('star-1', 'star', { x: '0', y: '0', width: '100', height: '100' })],
-      VP,
-    );
-    const p = layers[0] as PathLayer;
-    expect(p.type).toBe('path');
-    expect(p.content.d.startsWith('M')).toBe(true);
-  });
-
-  it('uses absolute positions (no fit-scaling) regardless of viewport', () => {
-    const children = [
-      child('text-1', 'text', { x: '100', y: '100', width: '200', height: '50' }, 'x'),
-    ];
-    const small = computeLayoutLayers(children, { width: 200, height: 200 }).layers[0];
-    const large = computeLayoutLayers(children, { width: 4000, height: 4000 }).layers[0];
-    expect(small.position.x).toBe(100);
-    expect(large.position.x).toBe(100);
-  });
-
-  it('preserves child document order as z-order', () => {
-    const { layers } = computeLayoutLayers(
-      [child('a', 'rectangle', { x: '0', y: '0' }), child('b', 'text', {}, 'top')],
-      VP,
-    );
-    expect(layers.map((l) => l.id)).toEqual(['a', 'b']);
-  });
-
-  it('warns and skips a child whose annotation is not a layer kind', () => {
-    const { layers, warnings } = computeLayoutLayers(
-      [child('weird', 'banana', { x: '0', y: '0' })],
-      VP,
-    );
-    expect(layers).toHaveLength(0);
-    expect(warnings.some((w) => w.includes('weird'))).toBe(true);
-  });
-
-  it('uses the supplied ink default for un-styled text and strokes', () => {
-    const { layers } = computeLayoutLayers(
-      [
-        child('t', 'text', { x: '0', y: '0' }, 'plain'),
-        child('l', 'line', { x: '0', y: '0', width: '100', height: '0' }),
-      ],
-      VP,
-      { ink: '#e0e0e0' },
-    );
-    const t = layers[0] as TextLayer;
-    const l = layers[1] as PathLayer;
-    expect(t.content.style.color).toBe('#e0e0e0');
-    expect(l.content.stroke).toBe('#e0e0e0');
-  });
-
-  it('keeps the dark-slate ink default when no defaults are supplied (editor scene canvas)', () => {
-    const { layers } = computeLayoutLayers([child('t', 'text', { x: '0', y: '0' }, 'plain')], VP);
-    const t = layers[0] as TextLayer;
-    expect(t.content.style.color).toBe('#1e293b');
-  });
-
-  it('never overrides author-specified color/stroke with the ink default', () => {
-    const { layers } = computeLayoutLayers(
-      [
-        child('t', 'text', { x: '0', y: '0', color: '#112233' }, 'styled'),
-        child('l', 'line', { x: '0', y: '0', width: '100', height: '0', stroke: '#445566' }),
-      ],
-      VP,
-      { ink: '#e0e0e0' },
-    );
-    expect((layers[0] as TextLayer).content.style.color).toBe('#112233');
-    expect((layers[1] as PathLayer).content.stroke).toBe('#445566');
-  });
-});

package/src/__tests__/localForageAdapter.test.ts

@@ -1,155 +0,0 @@
-/**
- * LocalForageAdapter tests
- *
- * Uses the localforage library (which falls back to an in-memory driver
- * in jsdom/Node environments) to verify the adapter contract.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { LocalForageAdapter } from '../storage/LocalForageAdapter';
-
-describe('LocalForageAdapter', () => {
-  let storage: LocalForageAdapter;
-
-  beforeEach(async () => {
-    storage = new LocalForageAdapter({ name: 'test-db', storeName: 'test-store' });
-    await storage.clear();
-  });
-
-  it('supports enumeration', () => {
-    expect(storage.supportsEnumeration).toBe(true);
-  });
-
-  it('get returns null for missing key', async () => {
-    expect(await storage.get('nonexistent')).toBeNull();
-  });
-
-  it('set and get round-trip', async () => {
-    await storage.set('key', { hello: 'world' });
-    expect(await storage.get('key')).toEqual({ hello: 'world' });
-  });
-
-  it('stores primitives', async () => {
-    await storage.set('str', 'hello');
-    await storage.set('num', 42);
-    await storage.set('bool', true);
-    expect(await storage.get('str')).toBe('hello');
-    expect(await storage.get('num')).toBe(42);
-    expect(await storage.get('bool')).toBe(true);
-  });
-
-  it('overwrites existing values', async () => {
-    await storage.set('key', 'first');
-    await storage.set('key', 'second');
-    expect(await storage.get('key')).toBe('second');
-  });
-
-  it('remove deletes a key', async () => {
-    await storage.set('key', 'value');
-    await storage.remove('key');
-    expect(await storage.get('key')).toBeNull();
-  });
-
-  it('clear removes all keys', async () => {
-    await storage.set('a', 1);
-    await storage.set('b', 2);
-    await storage.clear();
-    expect(await storage.get('a')).toBeNull();
-    expect(await storage.get('b')).toBeNull();
-    expect(await storage.keys()).toEqual([]);
-  });
-
-  it('keys returns all stored keys', async () => {
-    await storage.set('alpha', 1);
-    await storage.set('beta', 2);
-    const keys = await storage.keys();
-    expect(keys.sort()).toEqual(['alpha', 'beta']);
-  });
-
-  it('stores binary data (ArrayBuffer)', async () => {
-    const buffer = new Uint8Array([1, 2, 3, 4]).buffer;
-    await storage.set('binary', buffer);
-    const result = await storage.get<ArrayBuffer>('binary');
-    expect(result).toBeInstanceOf(ArrayBuffer);
-    expect(new Uint8Array(result!)).toEqual(new Uint8Array([1, 2, 3, 4]));
-  });
-
-  it('stores Uint8Array', async () => {
-    const data = new Uint8Array([10, 20, 30]);
-    await storage.set('bytes', data);
-    const result = await storage.get<Uint8Array>('bytes');
-    expect(new Uint8Array(result!)).toEqual(new Uint8Array([10, 20, 30]));
-  });
-});
-
-describe('LocalForageAdapter with prefix', () => {
-  let storage: LocalForageAdapter;
-
-  beforeEach(async () => {
-    storage = new LocalForageAdapter({
-      name: 'test-db-prefix',
-      storeName: 'test-store',
-      prefix: 'slot1:',
-    });
-    await storage.clear();
-  });
-
-  it('get/set respects prefix', async () => {
-    await storage.set('doc', { title: 'My Doc' });
-    expect(await storage.get('doc')).toEqual({ title: 'My Doc' });
-  });
-
-  it('keys strips prefix', async () => {
-    await storage.set('alpha', 1);
-    await storage.set('beta', 2);
-    const keys = await storage.keys();
-    expect(keys.sort()).toEqual(['alpha', 'beta']);
-  });
-
-  it('clear only removes prefixed keys', async () => {
-    // Write directly to a separate adapter (no prefix) to verify isolation
-    const other = new LocalForageAdapter({
-      name: 'test-db-prefix',
-      storeName: 'test-store',
-      prefix: 'slot2:',
-    });
-    await other.set('other-key', 'should-survive');
-    await storage.set('my-key', 'will-be-cleared');
-
-    await storage.clear();
-
-    expect(await storage.get('my-key')).toBeNull();
-    expect(await other.get('other-key')).toBe('should-survive');
-
-    // Cleanup
-    await other.clear();
-  });
-
-  it('different prefixes are isolated', async () => {
-    const slot1 = new LocalForageAdapter({
-      name: 'test-isolation',
-      storeName: 'test-store',
-      prefix: 'slot1:',
-    });
-    const slot2 = new LocalForageAdapter({
-      name: 'test-isolation',
-      storeName: 'test-store',
-      prefix: 'slot2:',
-    });
-
-    await slot1.set('doc', 'slot1-doc');
-    await slot2.set('doc', 'slot2-doc');
-
-    expect(await slot1.get('doc')).toBe('slot1-doc');
-    expect(await slot2.get('doc')).toBe('slot2-doc');
-
-    const keys1 = await slot1.keys();
-    const keys2 = await slot2.keys();
-    expect(keys1).toEqual(['doc']);
-    expect(keys2).toEqual(['doc']);
-
-    // Cleanup
-    await slot1.clear();
-    await slot2.clear();
-  });
-});

package/src/__tests__/majorApiTypes.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { PathLayer } from '../schemas/Doc';
-
-describe('major-version core API types', () => {
-  it('requires endpoint markers instead of the removed arrow field', () => {
-    const layer: PathLayer = {
-      id: 'path',
-      type: 'path',
-      position: { x: 0, y: 0, width: 10, height: 10 },
-      content: {
-        d: 'M 0 0 L 10 10',
-        // @ts-expect-error Old documents are read tolerantly, but new code uses endMarker.
-        arrow: 'end',
-      },
-    };
-    expect(layer.content).toHaveProperty('arrow', 'end');
-  });
-});