@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/rootExports.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as root from '../index';
-import * as icons from '../icons/index';
-import * as schemas from '../schemas/index';
-import * as transform from '../transform/index';
-
-const transformRuntimeExports = [
-  'applyTransform',
-  'resolveTransformStyle',
-  'getTransformStyleIds',
-  'getTransformStyleSummaries',
-  'createTransformStyleRegistry',
-  'DEFAULT_TRANSFORM_STYLE_ID',
-  'analyzeBlocks',
-  'extractDocImages',
-] as const;
-
-const iconRuntimeExports = [
-  'ICONS',
-  'resolveIcon',
-  'canonicalIconToken',
-  'looksLikeIconToken',
-  'suggestIcons',
-  'iconGlyph',
-] as const;
-
-function expectReExported(
-  rootExports: Record<string, unknown>,
-  subpathExports: Record<string, unknown>,
-  names: readonly string[],
-): void {
-  for (const name of names) {
-    expect(rootExports[name], `root barrel should re-export ${name}`).toBe(subpathExports[name]);
-  }
-}
-
-describe('root barrel exports', () => {
-  it('re-exports transform runtime APIs', () => {
-    expectReExported(root, transform, transformRuntimeExports);
-  });
-
-  it('re-exports icon runtime APIs', () => {
-    expectReExported(root, icons, iconRuntimeExports);
-  });
-
-  it('does not publish process-global registry mutators', () => {
-    for (const name of [
-      'registerTheme',
-      'unregisterTheme',
-      'getRegisteredThemes',
-      'lookupRegisteredTheme',
-    ]) {
-      expect(root).not.toHaveProperty(name);
-      expect(schemas).not.toHaveProperty(name);
-    }
-    for (const name of ['registerTransformStyle', 'unregisterTransformStyle']) {
-      expect(root).not.toHaveProperty(name);
-      expect(transform).not.toHaveProperty(name);
-    }
-  });
-});

package/src/__tests__/scopedContentContainer.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryContentContainer } from '../storage/ContentContainer';
-import { ScopedContentContainer, scopeContainer } from '../storage/ScopedContentContainer';
-
-const enc = (s: string) => new TextEncoder().encode(s);
-const dec = (b: ArrayBuffer | null) => (b ? new TextDecoder().decode(b) : null);
-
-describe('ScopedContentContainer', () => {
-  let parent: MemoryContentContainer;
-
-  beforeEach(() => {
-    parent = new MemoryContentContainer();
-  });
-
-  it('writeFile + readFile route through the prefix', async () => {
-    const scoped = scopeContainer(parent, 'image_files');
-    await scoped.writeFile('state.json', enc('{}'), 'application/json');
-
-    expect(dec(await parent.readFile('image_files/state.json'))).toBe('{}');
-    expect(dec(await scoped.readFile('state.json'))).toBe('{}');
-  });
-
-  it('exists + removeFile honor the prefix', async () => {
-    const scoped = scopeContainer(parent, 'image_files');
-    await scoped.writeFile('a.txt', enc('a'));
-    expect(await scoped.exists('a.txt')).toBe(true);
-    expect(await parent.exists('image_files/a.txt')).toBe(true);
-
-    await scoped.removeFile('a.txt');
-    expect(await scoped.exists('a.txt')).toBe(false);
-    expect(await parent.exists('image_files/a.txt')).toBe(false);
-  });
-
-  it('listFiles returns prefix-stripped paths and ignores siblings', async () => {
-    const scoped = scopeContainer(parent, 'image_files');
-    await parent.writeFile('outside.txt', enc('x'));
-    await parent.writeFile('image_files_sibling/peek.txt', enc('y')); // not in scope
-    await scoped.writeFile('a.txt', enc('1'));
-    await scoped.writeFile('sub/b.txt', enc('2'));
-
-    const list = await scoped.listFiles();
-    const paths = list.map((e) => e.path).sort();
-    expect(paths).toEqual(['a.txt', 'sub/b.txt']);
-  });
-
-  it('listFiles with prefix joins the scope prefix', async () => {
-    const scoped = scopeContainer(parent, 'sidecar');
-    await scoped.writeFile('assets/a.png', enc('a'));
-    await scoped.writeFile('assets/b.png', enc('b'));
-    await scoped.writeFile('state.json', enc('{}'));
-
-    const list = await scoped.listFiles('assets/');
-    expect(list.map((e) => e.path).sort()).toEqual(['assets/a.png', 'assets/b.png']);
-  });
-
-  it('nested scopes compose', async () => {
-    const a = scopeContainer(parent, 'a');
-    const ab = scopeContainer(a, 'b');
-    await ab.writeFile('c.txt', enc('hi'));
-    expect(dec(await parent.readFile('a/b/c.txt'))).toBe('hi');
-    expect(dec(await ab.readFile('c.txt'))).toBe('hi');
-  });
-
-  it('normalizes leading/trailing slashes in prefix and paths', async () => {
-    const scoped = scopeContainer(parent, '/sidecar/');
-    expect(scoped.prefix).toBe('sidecar');
-    await scoped.writeFile('/x.txt', enc('x'));
-    expect(dec(await parent.readFile('sidecar/x.txt'))).toBe('x');
-  });
-
-  it('rejects empty / dotted prefixes', () => {
-    expect(() => scopeContainer(parent, '')).toThrow();
-    expect(() => scopeContainer(parent, '/')).toThrow();
-    expect(() => scopeContainer(parent, 'a/../b')).toThrow();
-    expect(() => scopeContainer(parent, './a')).toThrow();
-    expect(() => scopeContainer(parent, 'a\\b')).toThrow(/forward slashes/);
-  });
-
-  it('rejects traversal, dot segments, and backslashes on every file operation', async () => {
-    const scoped = scopeContainer(parent, 'sidecar');
-    for (const badPath of ['../escape.txt', 'a/../../escape.txt', './same.txt', 'a\\b.txt']) {
-      expect(() => scoped.readFile(badPath)).toThrow();
-      expect(() => scoped.writeFile(badPath, enc('x'))).toThrow();
-      expect(() => scoped.removeFile(badPath)).toThrow();
-      expect(() => scoped.exists(badPath)).toThrow();
-      await expect(scoped.listFiles(badPath)).rejects.toThrow();
-    }
-    expect(await parent.listFiles()).toEqual([]);
-  });
-
-  it('normalizes repeated and leading slashes without changing scope', async () => {
-    const scoped = scopeContainer(parent, '//sidecar//nested//');
-    expect(scoped.prefix).toBe('sidecar/nested');
-    await scoped.writeFile('//assets//x.txt', enc('x'));
-    expect(dec(await parent.readFile('sidecar/nested/assets/x.txt'))).toBe('x');
-  });
-
-  it('getDocumentPath / readDocument always return null', async () => {
-    const scoped = scopeContainer(parent, 'sidecar');
-    await scoped.writeFile('index.md', enc('# hi'));
-    expect(await scoped.getDocumentPath()).toBeNull();
-    expect(await scoped.readDocument()).toBeNull();
-  });
-
-  it('writeDocument throws', async () => {
-    const scoped = new ScopedContentContainer(parent, 'sidecar');
-    await expect(scoped.writeDocument()).rejects.toThrow();
-  });
-});

package/src/__tests__/seededRandom.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { SeededRandom, hashString } from '../random/index.js';
-
-describe('SeededRandom', () => {
-  it('produces deterministic output from the same seed', () => {
-    const a = new SeededRandom(42);
-    const b = new SeededRandom(42);
-    expect(a.next()).toBe(b.next());
-    expect(a.next()).toBe(b.next());
-    expect(a.next()).toBe(b.next());
-  });
-
-  it('produces different output from different seeds', () => {
-    const a = new SeededRandom(1);
-    const b = new SeededRandom(2);
-    expect(a.next()).not.toBe(b.next());
-  });
-
-  it('next() returns values in [0, 1)', () => {
-    const rng = new SeededRandom(123);
-    for (let i = 0; i < 100; i++) {
-      const v = rng.next();
-      expect(v).toBeGreaterThanOrEqual(0);
-      expect(v).toBeLessThan(1);
-    }
-  });
-
-  it('nextInt(max) returns values in [0, max)', () => {
-    const rng = new SeededRandom(99);
-    for (let i = 0; i < 100; i++) {
-      const v = rng.nextInt(10);
-      expect(v).toBeGreaterThanOrEqual(0);
-      expect(v).toBeLessThan(10);
-      expect(Number.isInteger(v)).toBe(true);
-    }
-  });
-
-  it('nextIntRange(min, max) stays in range', () => {
-    const rng = new SeededRandom(77);
-    for (let i = 0; i < 100; i++) {
-      const v = rng.nextIntRange(5, 15);
-      expect(v).toBeGreaterThanOrEqual(5);
-      expect(v).toBeLessThan(15);
-    }
-  });
-
-  it('pick returns undefined for empty array', () => {
-    const rng = new SeededRandom(1);
-    expect(rng.pick([])).toBeUndefined();
-  });
-
-  it('pick returns an element from the array', () => {
-    const rng = new SeededRandom(1);
-    const items = ['a', 'b', 'c'];
-    const picked = rng.pick(items);
-    expect(items).toContain(picked);
-  });
-
-  it('pickRequired throws on empty array', () => {
-    const rng = new SeededRandom(1);
-    expect(() => rng.pickRequired([])).toThrow('Cannot pick from empty array');
-  });
-
-  it('pickMultiple returns correct count', () => {
-    const rng = new SeededRandom(42);
-    const result = rng.pickMultiple([1, 2, 3, 4, 5], 3);
-    expect(result).toHaveLength(3);
-    // All elements should be unique
-    expect(new Set(result).size).toBe(3);
-  });
-
-  it('pickMultiple returns all if count >= length', () => {
-    const rng = new SeededRandom(42);
-    const result = rng.pickMultiple([1, 2, 3], 5);
-    expect(result).toHaveLength(3);
-    expect(new Set(result).size).toBe(3);
-  });
-
-  it('shuffle is deterministic', () => {
-    const a = new SeededRandom(42);
-    const b = new SeededRandom(42);
-    expect(a.shuffle([1, 2, 3, 4, 5])).toEqual(b.shuffle([1, 2, 3, 4, 5]));
-  });
-
-  it('shuffled does not modify original', () => {
-    const rng = new SeededRandom(42);
-    const original = [1, 2, 3, 4, 5];
-    const copy = [...original];
-    rng.shuffled(original);
-    expect(original).toEqual(copy);
-  });
-
-  it('pickWeighted respects weights', () => {
-    // Heavily weight 'a' — over many picks it should dominate
-    const rng = new SeededRandom(42);
-    const items = [
-      { item: 'a', weight: 100 },
-      { item: 'b', weight: 1 },
-    ];
-    let aCount = 0;
-    for (let i = 0; i < 100; i++) {
-      if (rng.pickWeighted(items) === 'a') aCount++;
-    }
-    expect(aCount).toBeGreaterThan(80);
-  });
-
-  it('pickWeighted returns undefined for empty', () => {
-    const rng = new SeededRandom(1);
-    expect(rng.pickWeighted([])).toBeUndefined();
-  });
-
-  it('derive creates independent stream', () => {
-    const rng = new SeededRandom(42);
-    const d1 = rng.derive('stream-a');
-    const d2 = rng.derive('stream-b');
-    expect(d1.next()).not.toBe(d2.next());
-  });
-
-  it('handles seed of 0 gracefully', () => {
-    const rng = new SeededRandom(0);
-    const v = rng.next();
-    expect(v).toBeGreaterThanOrEqual(0);
-    expect(v).toBeLessThan(1);
-  });
-});
-
-describe('hashString', () => {
-  it('returns a positive 32-bit integer', () => {
-    const h = hashString('hello world');
-    expect(h).toBeGreaterThanOrEqual(0);
-    expect(h).toBeLessThanOrEqual(0xffffffff);
-    expect(Number.isInteger(h)).toBe(true);
-  });
-
-  it('is deterministic', () => {
-    expect(hashString('test')).toBe(hashString('test'));
-  });
-
-  it('differs for different strings', () => {
-    expect(hashString('abc')).not.toBe(hashString('xyz'));
-  });
-});

package/src/__tests__/shapeGeometry.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  shapePath,
-  markerPath,
-  connectorPath,
-  clipEndpoints,
-  nearestSnapPoint,
-  lineStyleDasharray,
-  PATH_SHAPE_KINDS,
-  snapEndpoints,
-  snapPoints,
-} from '../doc/utils/shapeGeometry.js';
-
-describe('shapePath', () => {
-  it('returns a non-empty path beginning with M for every path-shape kind', () => {
-    for (const kind of PATH_SHAPE_KINDS) {
-      const d = shapePath(kind, 0, 0, 100, 80);
-      expect(d, kind).toBeTruthy();
-      expect(d?.startsWith('M'), kind).toBe(true);
-    }
-  });
-
-  it('returns null for natively-rendered primitives', () => {
-    for (const kind of ['rect', 'circle', 'line', 'text', 'path', 'arrow']) {
-      expect(shapePath(kind, 0, 0, 10, 10), kind).toBeNull();
-    }
-  });
-
-  it('triangle is a closed 3-point polygon inscribed in the box', () => {
-    expect(shapePath('triangle', 0, 0, 100, 100)).toBe('M 50 0 L 100 100 L 0 100 Z');
-  });
-
-  it('diamond hits the four edge midpoints', () => {
-    expect(shapePath('diamond', 0, 0, 100, 100)).toBe('M 50 0 L 100 50 L 50 100 L 0 50 Z');
-  });
-
-  it('honors the bounding-box offset', () => {
-    expect(shapePath('triangle', 10, 20, 100, 100)).toBe('M 60 20 L 110 120 L 10 120 Z');
-  });
-});
-
-describe('markerPath', () => {
-  it('arrow end is a filled triangle; none is null', () => {
-    expect(markerPath('arrow', 'end')).toEqual({ d: 'M 0 0 L 10 5 L 0 10 z', filled: true });
-    expect(markerPath('none', 'end')).toBeNull();
-  });
-
-  it('open is unfilled; diamond/circle/square are filled', () => {
-    expect(markerPath('open', 'end')?.filled).toBe(false);
-    expect(markerPath('diamond', 'end')?.filled).toBe(true);
-    expect(markerPath('circle', 'end')?.filled).toBe(true);
-    expect(markerPath('square', 'end')?.filled).toBe(true);
-  });
-
-  it('start mirrors the arrow horizontally', () => {
-    expect(markerPath('arrow', 'start')).toEqual({ d: 'M 10 0 L 0 5 L 10 10 z', filled: true });
-  });
-});
-
-describe('connectorPath', () => {
-  const a = { x: 0, y: 0 };
-  const b = { x: 100, y: 50 };
-
-  it('straight is a single line segment', () => {
-    expect(connectorPath('straight', a, b)).toBe('M 0 0 L 100 50');
-  });
-
-  it('orthogonal has a mid elbow', () => {
-    expect(connectorPath('orthogonal', a, b)).toBe('M 0 0 L 50 0 L 50 50 L 100 50');
-  });
-
-  it('orthogonal routing approaches top/bottom ports vertically', () => {
-    expect(
-      connectorPath('orthogonal', { port: 'bottom', x: 80, y: 60 }, { port: 'top', x: 20, y: 140 }),
-    ).toBe('M 80 60 L 80 100 L 20 100 L 20 140');
-  });
-
-  it('curved is a cubic bezier', () => {
-    expect(connectorPath('curved', a, b).startsWith('M 0 0 C')).toBe(true);
-  });
-
-  it('curved routing follows the endpoint port directions', () => {
-    expect(
-      connectorPath('curved', { port: 'bottom', x: 80, y: 60 }, { port: 'top', x: 20, y: 140 }),
-    ).toBe('M 80 60 C 80 110, 20 90, 20 140');
-  });
-});
-
-describe('clipEndpoints', () => {
-  it('clips both endpoints to the box edges', () => {
-    const r = clipEndpoints({ cx: 0, cy: 0, rx: 10, ry: 10 }, { cx: 100, cy: 0, rx: 10, ry: 10 });
-    expect(r.start).toEqual({ x: 10, y: 0 });
-    expect(r.end).toEqual({ x: 90, y: 0 });
-  });
-});
-
-describe('snapEndpoints', () => {
-  const a = { cx: 50, cy: 50, rx: 30, ry: 20 };
-  const b = { cx: 180, cy: 50, rx: 30, ry: 20 };
-
-  it('exposes side and corner ports around a box', () => {
-    expect(snapPoints(a).map((p) => p.port)).toEqual([
-      'top',
-      'right',
-      'bottom',
-      'left',
-      'top-left',
-      'top-right',
-      'bottom-right',
-      'bottom-left',
-    ]);
-  });
-
-  it('snaps horizontal connections to side ports', () => {
-    const r = snapEndpoints(a, b);
-    expect(r.start).toMatchObject({ port: 'right', x: 80, y: 50 });
-    expect(r.end).toMatchObject({ port: 'left', x: 150, y: 50 });
-  });
-
-  it('snaps diagonal connections to nearest corner ports', () => {
-    const r = snapEndpoints(a, { cx: 180, cy: 140, rx: 30, ry: 20 });
-    expect(r.start).toMatchObject({ port: 'bottom-right', x: 80, y: 70 });
-    expect(r.end).toMatchObject({ port: 'top-left', x: 150, y: 120 });
-  });
-
-  it('finds the nearest port toward a free pointer', () => {
-    expect(nearestSnapPoint(a, { x: 100, y: 10 }).port).toBe('top-right');
-  });
-});
-
-describe('lineStyleDasharray', () => {
-  it('maps line styles to dash patterns', () => {
-    expect(lineStyleDasharray('dashed')).toBe('8 6');
-    expect(lineStyleDasharray('dotted')).toBe('2 6');
-    expect(lineStyleDasharray('solid')).toBeUndefined();
-    expect(lineStyleDasharray(undefined)).toBeUndefined();
-  });
-});

package/src/__tests__/shapeVocabulary.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { computeDrawingLayout } from '../doc/templates/drawingLayout.js';
-import { drawingBlock } from '../doc/templates/drawingBlock.js';
-import { diagramBlock } from '../doc/templates/diagramBlock.js';
-import { createTemplateContext } from '../schemas/BlockTemplates.js';
-import { DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import { VIEWPORT_PRESETS } from '../schemas/Viewport.js';
-import type { Block, PathLayer } from '../schemas/Doc.js';
-import type { DiagramBlockInput } from '../schemas/BlockTemplates.js';
-
-function shape(id: string, template: string, overrides: Record<string, string> = {}): Block {
-  return {
-    id,
-    startTime: 0,
-    duration: 0,
-    audioSegment: 0,
-    template,
-    templateOverrides: overrides,
-  } as Block;
-}
-
-function ctx(children: Block[]) {
-  const c = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-  c.children = children;
-  return c;
-}
-
-describe('drawing shape vocabulary', () => {
-  it('recognizes new polygon kinds and aliases', () => {
-    const layout = computeDrawingLayout([
-      shape('s', 'star', { x: '0', y: '0' }),
-      shape('h', 'hexagon', { x: '0', y: '0' }),
-      shape('r', 'rhombus', { x: '0', y: '0' }), // alias → diamond
-      shape('a', 'rightarrow', { x: '0', y: '0' }), // alias → arrow-right
-    ]);
-    const kinds = layout.shapes.map((s) => s.kind);
-    expect(kinds).toEqual(['star', 'hexagon', 'diamond', 'arrow-right']);
-  });
-
-  it('renders a polygon kind as a PathLayer in the block', () => {
-    const layers = drawingBlock(
-      { template: 'drawing', id: 'd', duration: 0, audioSegment: 0 },
-      ctx([shape('s', 'star', { x: '10', y: '10', width: '100', height: '100' })]),
-    );
-    const star = layers.find((l) => l.id === 'shape-s');
-    expect(star?.type).toBe('path');
-  });
-});
-
-describe('drawing connector semantics', () => {
-  function conn(overrides: Record<string, string>) {
-    return computeDrawingLayout([
-      shape('a', 'rect', { x: '0', y: '0', width: '50', height: '50' }),
-      shape('b', 'rect', { x: '0', y: '200', width: '50', height: '50' }),
-      shape('c', 'arrow', { from: 'a', to: 'b', ...overrides }),
-    ]).connectors[0];
-  }
-
-  it('parses end/start markers, line style, and routing', () => {
-    expect(
-      conn({
-        endStyle: 'diamond',
-        startStyle: 'circle',
-        lineStyle: 'dashed',
-        routing: 'orthogonal',
-      }),
-    ).toMatchObject({
-      endMarker: 'diamond',
-      startMarker: 'circle',
-      dasharray: '8 6',
-      routing: 'orthogonal',
-    });
-  });
-
-  it('defaults arrow → end arrow, line → no marker, straight routing', () => {
-    expect(conn({})).toMatchObject({
-      endMarker: 'arrow',
-      startMarker: 'none',
-      routing: 'straight',
-    });
-    const line = computeDrawingLayout([
-      shape('a', 'rect', { x: '0', y: '0', width: '50', height: '50' }),
-      shape('b', 'rect', { x: '0', y: '200', width: '50', height: '50' }),
-      shape('l', 'line', { from: 'a', to: 'b' }),
-    ]).connectors[0];
-    expect(line.endMarker).toBe('none');
-  });
-
-  it('emits the marker + dash on the rendered connector PathLayer', () => {
-    const layers = drawingBlock(
-      { template: 'drawing', id: 'd', duration: 0, audioSegment: 0 },
-      ctx([
-        shape('a', 'rect', { x: '0', y: '0', width: '50', height: '50' }),
-        shape('b', 'rect', { x: '0', y: '200', width: '50', height: '50' }),
-        shape('c', 'arrow', { from: 'a', to: 'b', endStyle: 'diamond', lineStyle: 'dashed' }),
-      ]),
-    );
-    const connector = layers.find((l) => l.id === 'connector-c') as PathLayer | undefined;
-    expect(connector?.content.endMarker).toBe('diamond');
-    expect(connector?.content.dasharray).toBe('8 6');
-  });
-});
-
-describe('diagram edge styles', () => {
-  function node(id: string, x: number, y: number, connectsTo?: string): Block {
-    return {
-      id,
-      startTime: 0,
-      duration: 0,
-      audioSegment: 0,
-      x,
-      y,
-      ...(connectsTo ? { connectsTo: [{ target: connectsTo }] } : {}),
-    } as Block;
-  }
-
-  it('applies endStyle and lineStyle to all edges', () => {
-    const c = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    c.children = [node('a', 0, 0, 'b'), node('b', 300, 0)];
-    const input: DiagramBlockInput = {
-      template: 'diagram',
-      id: 'g',
-      duration: 0,
-      audioSegment: 0,
-      endStyle: 'circle',
-      lineStyle: 'dashed',
-    };
-    const layers = diagramBlock(input, c);
-    const edge = layers.find((l) => l.id.startsWith('edge-')) as PathLayer | undefined;
-    expect(edge?.content.endMarker).toBe('circle');
-    expect(edge?.content.dasharray).toBe('8 6');
-  });
-});

package/src/__tests__/storage.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryStorageAdapter } from '../storage/MemoryStorageAdapter';
-
-describe('MemoryStorageAdapter', () => {
-  let storage: MemoryStorageAdapter;
-
-  beforeEach(() => {
-    storage = new MemoryStorageAdapter();
-  });
-
-  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']);
-  });
-});