@weasel-js/labkit 1.0.4 → 1.1.0

package/src/layers/AGENTS.md

@@ -31,9 +31,9 @@ The instrument declares layer ids:
 layers: { ids: ['grid', 'plants'] }
 ```
 
-`Workspace.tsx` converts each id into a `LayerDescriptor` (with `label === id` by default) and tracks `visibility` and a derived `layerOrder` in local state. The order produced by `onReorder` is then applied to `instrument.canvas.layers` before they're passed to `<CanvasStack>`.
+`Trial.tsx` converts each id into a `LayerDescriptor` (with `label === id` by default) and tracks `visibility` and a derived `layerOrder` in local state. The order produced by `onReorder` is then applied to `instrument.canvas.layers` before they're passed to `<CanvasStack>`.
 
-There is no transitive coupling between `layers.ids` and `canvas.layers[].id` — the workspace assumes the ids match. If you declare a layer in `canvas` that isn't in `layers.ids`, it stays in default order and is always visible.
+There is no transitive coupling between `layers.ids` and `canvas.layers[].id` — the trial assumes the ids match. If you declare a layer in `canvas` that isn't in `layers.ids`, it stays in default order and is always visible.
 
 ## `alwaysOn` semantics
 
@@ -52,7 +52,7 @@ Pointer capture is acquired on `pointerdown` and released on `pointerup`, so dra
 
 ## Empty state
 
-If `layers.length === 0`, renders `.lk-layer-list__empty` with the text "No layers". Workspace already guards this case (`layerDescriptors.length > 0`) so the empty state is rare in practice.
+If `layers.length === 0`, renders `.lk-layer-list__empty` with the text "No layers". Trial already guards this case (`layerDescriptors.length > 0`) so the empty state is rare in practice.
 
 ## When to fork
 

package/src/primitives/Toolbar.stories.tsx

@@ -12,7 +12,7 @@ type Story = StoryObj<typeof Toolbar>;
 export const Default: Story = {
   render: () => (
     <Toolbar>
-      <Toolbar.Title>My Workspace</Toolbar.Title>
+      <Toolbar.Title>My Trial</Toolbar.Title>
       <Toolbar.Button onClick={() => {}}>Undo</Toolbar.Button>
       <Toolbar.Button onClick={() => {}}>Redo</Toolbar.Button>
       <Toolbar.Spacer />
@@ -24,7 +24,7 @@ export const Default: Story = {
 export const WithDisabled: Story = {
   render: () => (
     <Toolbar>
-      <Toolbar.Title>Empty workspace</Toolbar.Title>
+      <Toolbar.Title>Empty trial</Toolbar.Title>
       <Toolbar.Button onClick={() => {}} disabled>
         Undo
       </Toolbar.Button>

package/src/state/SingletonExperiment.test.tsx

@@ -1,8 +1,9 @@
 import { act, render, renderHook } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { createMemoryAdapter } from './adapters';
+import { labDocumentKey } from './document';
 import { SingletonExperimentProvider } from './SingletonExperiment';
-import { useExperimentState } from './useExperimentState';
+import { useTrialState } from './useTrialState';
 
 interface Config {
   width: number;
@@ -17,7 +18,7 @@ describe('SingletonExperimentProvider', () => {
     vi.useRealTimers();
   });
 
-  it('exposes config and state via useExperimentState', () => {
+  it('exposes config and state via useTrialState', () => {
     const wrapper = ({ children }: { children: React.ReactNode }) => (
       <SingletonExperimentProvider<State, Config>
         id="test"
@@ -29,7 +30,7 @@ describe('SingletonExperimentProvider', () => {
         {children}
       </SingletonExperimentProvider>
     );
-    const { result } = renderHook(() => useExperimentState<State, Config>(), { wrapper });
+    const { result } = renderHook(() => useTrialState<State, Config>(), { wrapper });
     expect(result.current.config).toEqual({ width: 100, bg: '#000' });
     expect(result.current.state).toEqual({ zoom: 1 });
   });
@@ -38,7 +39,7 @@ describe('SingletonExperimentProvider', () => {
     vi.useFakeTimers();
     const storage = createMemoryAdapter();
     const Probe = () => {
-      const h = useExperimentState<State, Config>();
+      const h = useTrialState<State, Config>();
       return (
         <button type="button" onClick={() => h.setConfig('width', 200)}>
           go
@@ -62,15 +63,14 @@ describe('SingletonExperimentProvider', () => {
     act(() => {
       vi.advanceTimersByTime(400);
     });
-    // createLabStore uses labStorageKey which prefixes with "lk:"
-    const raw = storage.read('lk:test:workspaces');
+    const raw = storage.read(labDocumentKey('test'));
     expect(raw).toBeTruthy();
     expect(raw).toContain('"width":200');
   });
 
   it('rehydrates from storage on mount', () => {
     const storage = createMemoryAdapter();
-    // createLabStore uses labStorageKey which prefixes with "lk:"
+    // A pre-document lab, which createLabStore folds forward on hydration.
     storage.write(
       'lk:test:workspaces',
       JSON.stringify([
@@ -94,7 +94,7 @@ describe('SingletonExperimentProvider', () => {
         {children}
       </SingletonExperimentProvider>
     );
-    const { result } = renderHook(() => useExperimentState<State, Config>(), { wrapper });
+    const { result } = renderHook(() => useTrialState<State, Config>(), { wrapper });
     expect(result.current.config).toEqual({ width: 999, bg: '#fff' });
     expect(result.current.state).toEqual({ zoom: 2 });
   });

package/src/state/SingletonExperiment.tsx

@@ -1,5 +1,5 @@
 import { type ReactNode, useRef } from 'react';
-import { LabStoreProvider, WorkspaceIdProvider } from './context';
+import { LabStoreProvider, TrialIdProvider } from './context';
 import { createLabStore, type LabStore } from './store';
 import type { StorageAdapter } from './types';
 
@@ -7,8 +7,8 @@ const SINGLETON_INSTRUMENT = '__singleton__';
 
 /** Props for `<SingletonExperimentProvider>`. */
 export interface SingletonExperimentProviderProps<TS, TC> {
-  /** Stable id for the synthetic workspace; also doubles as the
-   *  WorkspaceIdContext value. */
+  /** Stable id for the synthetic trial; also doubles as the
+   *  TrialIdContext value. */
   id: string;
   initialConfig: TC;
   initialState: TS;
@@ -18,9 +18,9 @@ export interface SingletonExperimentProviderProps<TS, TC> {
 }
 
 /**
- * One-workspace `<Lab>` substitute for single-screen experiments. Mounts
- * a `LabStoreProvider` + `WorkspaceIdProvider` with one synthetic
- * workspace, so `useExperimentState` works without going through the
+ * One-trial `<Lab>` substitute for single-screen experiments. Mounts
+ * a `LabStoreProvider` + `TrialIdProvider` with one synthetic
+ * trial, so `useTrialState` works without going through the
  * full `<Lab instruments={...}>` runtime.
  */
 export function SingletonExperimentProvider<TS, TC>({
@@ -34,8 +34,8 @@ export function SingletonExperimentProvider<TS, TC>({
   const storeRef = useRef<LabStore | null>(null);
   if (storeRef.current === null) {
     const store = createLabStore({ storageKey, storage });
-    if (!store.getState().workspaces.some((w) => w.id === id)) {
-      store.getState().addWorkspace({
+    if (!store.getState().trials.some((w) => w.id === id)) {
+      store.getState().addTrial({
         id,
         instrumentName: SINGLETON_INSTRUMENT,
         config: initialConfig,
@@ -47,7 +47,7 @@ export function SingletonExperimentProvider<TS, TC>({
   }
   return (
     <LabStoreProvider store={storeRef.current}>
-      <WorkspaceIdProvider workspaceId={id}>{children}</WorkspaceIdProvider>
+      <TrialIdProvider trialId={id}>{children}</TrialIdProvider>
     </LabStoreProvider>
   );
 }

package/src/state/context.tsx

@@ -27,25 +27,25 @@ export function useLabStore(): LabStoreState & ReturnType<LabStore['getState']>
   return useStore(ctx.store);
 }
 
-/** Context carrying which workspace the subtree belongs to. */
-export const WorkspaceIdContext = createContext<string | null>(null);
+/** Context carrying which trial the subtree belongs to. */
+export const TrialIdContext = createContext<string | null>(null);
 
-/** Names the workspace its subtree belongs to, so an instrument's hooks can
+/** Names the trial its subtree belongs to, so an instrument's hooks can
  *  find their own record in the store without being passed an id. */
-export function WorkspaceIdProvider({
-  workspaceId,
+export function TrialIdProvider({
+  trialId,
   children,
 }: {
-  workspaceId: string;
+  trialId: string;
   children: ReactNode;
 }): ReactElement {
-  return <WorkspaceIdContext.Provider value={workspaceId}>{children}</WorkspaceIdContext.Provider>;
+  return <TrialIdContext.Provider value={trialId}>{children}</TrialIdContext.Provider>;
 }
 
-/** The id of the workspace this component is inside. Throws outside a
- *  `<WorkspaceIdProvider>`. */
-export function useWorkspaceId(): string {
-  const id = useContext(WorkspaceIdContext);
-  if (!id) throw new Error('[labkit] useWorkspaceId must be used inside <WorkspaceIdProvider>');
+/** The id of the trial this component is inside. Throws outside a
+ *  `<TrialIdProvider>`. */
+export function useTrialId(): string {
+  const id = useContext(TrialIdContext);
+  if (!id) throw new Error('[labkit] useTrialId must be used inside <TrialIdProvider>');
   return id;
 }

package/src/state/document.test.ts

@@ -0,0 +1,369 @@
+import { describe, expect, it } from 'vitest';
+import { createMemoryAdapter } from './adapters';
+import {
+  CURRENT_DOCUMENT_VERSION,
+  deleteLegacyKeys,
+  emptyDocument,
+  labDocumentKey,
+  MIGRATIONS,
+  migrateV0toV1,
+  migrateV1toV2,
+  normalizeDocument,
+  quarantineDocument,
+  quarantineKey,
+  readLegacyDocument,
+  runMigrations,
+} from './document';
+import { labStorageKey } from './helpers';
+
+describe('document keys', () => {
+  it('namespaces the document key by storageKey', () => {
+    expect(labDocumentKey('mylab')).toBe('lk:mylab:doc');
+  });
+
+  it('namespaces the quarantine key by storageKey', () => {
+    expect(quarantineKey('mylab')).toBe('lk:mylab:quarantine');
+  });
+
+  it('cannot collide with a legacy bucket key of another lab', () => {
+    for (const bucket of ['workspaces', 'saves', 'layout', 'theme'] as const) {
+      expect(labDocumentKey(`a:${bucket}`)).not.toBe(labStorageKey('a', bucket));
+      expect(labDocumentKey('a')).not.toBe(labStorageKey('a', bucket));
+    }
+  });
+
+  it('cannot collide with a quarantine key of another lab', () => {
+    expect(labDocumentKey('a:quarantine')).not.toBe(quarantineKey('a'));
+  });
+});
+
+describe('emptyDocument', () => {
+  it('is stamped at the current version with the given mode', () => {
+    const doc = emptyDocument('light');
+    expect(doc.version).toBe(CURRENT_DOCUMENT_VERSION);
+    expect(doc.mode).toBe('light');
+    expect(doc.trials).toEqual([]);
+    expect(doc.saves).toEqual([]);
+    expect(doc.layout).toEqual({});
+  });
+});
+
+const bump = (to: number) => (doc: Record<string, unknown>) => ({ ...doc, version: to });
+
+describe('runMigrations', () => {
+  it('returns a current-version document untouched', () => {
+    const doc = { version: 2, a: 1 };
+    const out = runMigrations(doc, [bump(1), bump(2)], 2);
+    expect(out).toEqual({ ok: true, doc: { version: 2, a: 1 }, migrated: false });
+  });
+
+  it('runs every migration from the stored version to the current one', () => {
+    const out = runMigrations({ version: 0 }, [bump(1), bump(2)], 2);
+    expect(out).toEqual({ ok: true, doc: { version: 2 }, migrated: true });
+  });
+
+  it('refuses a document from a future version', () => {
+    const out = runMigrations({ version: 9 }, [bump(1)], 1);
+    expect(out).toEqual({ ok: false, reason: 'future' });
+  });
+
+  it('reports a throwing migration as failed', () => {
+    const boom = () => {
+      throw new Error('nope');
+    };
+    const out = runMigrations({ version: 0 }, [boom], 1);
+    expect(out.ok).toBe(false);
+    if (!out.ok) expect(out.reason).toBe('failed');
+  });
+
+  it('treats a document with no version as version 0', () => {
+    const out = runMigrations({}, [bump(1)], 1);
+    expect(out).toEqual({ ok: true, doc: { version: 1 }, migrated: true });
+  });
+});
+
+describe('readLegacyDocument', () => {
+  it('returns null when no legacy key is present', () => {
+    expect(readLegacyDocument(createMemoryAdapter(), 'lab', 'auto')).toBeNull();
+  });
+
+  it('assembles a version-0 document from the four buckets', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([{ id: 'w1' }]));
+    storage.write(labStorageKey('lab', 'saves'), JSON.stringify([{ id: 's1' }]));
+    storage.write(labStorageKey('lab', 'layout'), JSON.stringify({ w1: { h: 4 } }));
+    storage.write(labStorageKey('lab', 'theme'), 'dark');
+
+    expect(readLegacyDocument(storage, 'lab', 'auto')).toEqual({
+      version: 0,
+      workspaces: [{ id: 'w1' }],
+      saves: [{ id: 's1' }],
+      layout: { w1: { h: 4 } },
+      mode: 'dark',
+    });
+  });
+
+  it('survives one unparseable bucket without losing the others', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), '{{{not json');
+    storage.write(labStorageKey('lab', 'saves'), JSON.stringify([{ id: 's1' }]));
+
+    const doc = readLegacyDocument(storage, 'lab', 'auto');
+    expect(doc?.workspaces).toEqual([]);
+    expect(doc?.saves).toEqual([{ id: 's1' }]);
+  });
+
+  it('falls back to fallbackMode when the theme key is absent', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([]));
+
+    expect(readLegacyDocument(storage, 'lab', 'dark')?.mode).toBe('dark');
+  });
+
+  it('falls back to fallbackMode when the theme value is unrecognized', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'theme'), 'chartreuse');
+
+    expect(readLegacyDocument(storage, 'lab', 'dark')?.mode).toBe('dark');
+  });
+
+  it('a valid theme value beats the fallback', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'theme'), 'light');
+
+    expect(readLegacyDocument(storage, 'lab', 'dark')?.mode).toBe('light');
+  });
+
+  it('passes interstellar through untouched for migrateV0toV1 to coerce', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'theme'), 'interstellar');
+
+    expect(readLegacyDocument(storage, 'lab', 'dark')?.mode).toBe('interstellar');
+  });
+});
+
+describe('deleteLegacyKeys', () => {
+  it('deletes all four legacy buckets when the document matches', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([{ id: 'w1' }]));
+    storage.write(labStorageKey('lab', 'saves'), JSON.stringify([{ id: 's1' }]));
+    storage.write(labStorageKey('lab', 'layout'), JSON.stringify({ w1: { h: 4 } }));
+    storage.write(labStorageKey('lab', 'theme'), 'dark');
+    storage.write(labDocumentKey('lab'), 'the-document');
+
+    expect(deleteLegacyKeys(storage, 'lab', 'the-document')).toBe(true);
+
+    expect(storage.read(labStorageKey('lab', 'workspaces'))).toBeNull();
+    expect(storage.read(labStorageKey('lab', 'saves'))).toBeNull();
+    expect(storage.read(labStorageKey('lab', 'layout'))).toBeNull();
+    expect(storage.read(labStorageKey('lab', 'theme'))).toBeNull();
+  });
+
+  it('the document key itself survives deletion', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([{ id: 'w1' }]));
+    storage.write(labDocumentKey('lab'), 'the-document');
+
+    deleteLegacyKeys(storage, 'lab', 'the-document');
+
+    expect(storage.read(labDocumentKey('lab'))).toBe('the-document');
+  });
+
+  it('deletes nothing and returns false when the document key is absent', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([{ id: 'w1' }]));
+
+    expect(deleteLegacyKeys(storage, 'lab', 'the-document')).toBe(false);
+    expect(storage.read(labStorageKey('lab', 'workspaces'))).not.toBeNull();
+  });
+
+  it('returns false when the adapter cannot delete, and the keys survive', () => {
+    const mem = createMemoryAdapter();
+    const storage = { read: mem.read, write: mem.write };
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([{ id: 'w1' }]));
+    storage.write(labDocumentKey('lab'), 'the-document');
+
+    expect(deleteLegacyKeys(storage, 'lab', 'the-document')).toBe(false);
+    expect(storage.read(labStorageKey('lab', 'workspaces'))).not.toBeNull();
+  });
+
+  it('deletes nothing and returns false when the document key holds different content', () => {
+    const storage = createMemoryAdapter();
+    storage.write(labStorageKey('lab', 'workspaces'), JSON.stringify([{ id: 'w1' }]));
+    storage.write(labDocumentKey('lab'), 'something-else');
+
+    expect(deleteLegacyKeys(storage, 'lab', 'the-document')).toBe(false);
+    expect(storage.read(labStorageKey('lab', 'workspaces'))).not.toBeNull();
+  });
+});
+
+describe('migrateV0toV1', () => {
+  it('stamps version 1', () => {
+    expect(migrateV0toV1({ version: 0 }).version).toBe(1);
+  });
+
+  it('renames the old interstellar mode to dark', () => {
+    expect(migrateV0toV1({ version: 0, mode: 'interstellar' }).mode).toBe('dark');
+  });
+
+  it('replaces an unrecognized mode with auto', () => {
+    expect(migrateV0toV1({ version: 0, mode: 'chartreuse' }).mode).toBe('auto');
+  });
+
+  it.each(['light', 'dark', 'auto'] as const)('passes mode %s through unchanged', (mode) => {
+    expect(migrateV0toV1({ version: 0, mode }).mode).toBe(mode);
+  });
+
+  it('fills in every missing section', () => {
+    expect(migrateV0toV1({ version: 0 })).toEqual({
+      version: 1,
+      workspaces: [],
+      saves: [],
+      layout: {},
+      mode: 'auto',
+    });
+  });
+
+  it('preserves a populated workspaces array', () => {
+    const workspaces = [{ id: 'w1', instrumentName: 'osc' }];
+    expect(migrateV0toV1({ version: 0, workspaces }).workspaces).toEqual(workspaces);
+  });
+
+  it('preserves a populated saves array', () => {
+    const saves = [{ id: 's1', name: 'my save' }];
+    expect(migrateV0toV1({ version: 0, saves }).saves).toEqual(saves);
+  });
+
+  it('preserves a populated layout object', () => {
+    const layout = { w1: { h: 4 } };
+    expect(migrateV0toV1({ version: 0, layout }).layout).toEqual(layout);
+  });
+
+  it('falls back layout to {} and workspaces/saves to [] without swapping them', () => {
+    const out = migrateV0toV1({ version: 0, workspaces: 'nope', saves: 'nope', layout: 'nope' });
+    expect(out.workspaces).toEqual([]);
+    expect(out.saves).toEqual([]);
+    expect(out.layout).toEqual({});
+  });
+});
+
+describe('migrateV1toV2', () => {
+  it('stamps version 2', () => {
+    expect(migrateV1toV2({ version: 1, workspaces: [] }).version).toBe(2);
+  });
+
+  it('renames workspaces to trials, record for record', () => {
+    const records = [{ id: 'w1', instrumentName: 'osc', state: { n: 1 } }];
+    const out = migrateV1toV2({ version: 1, workspaces: records });
+    expect(out.trials).toEqual(records);
+    expect(out).not.toHaveProperty('workspaces');
+  });
+
+  it('leaves the other sections alone', () => {
+    const out = migrateV1toV2({
+      version: 1,
+      workspaces: [],
+      saves: [{ id: 's1' }],
+      layout: { w1: { h: 4 } },
+      mode: 'dark',
+    });
+    expect(out.saves).toEqual([{ id: 's1' }]);
+    expect(out.layout).toEqual({ w1: { h: 4 } });
+    expect(out.mode).toBe('dark');
+  });
+
+  it('falls back to an empty trials list when workspaces is the wrong shape', () => {
+    expect(migrateV1toV2({ version: 1, workspaces: 'nope' }).trials).toEqual([]);
+  });
+});
+
+describe('MIGRATIONS', () => {
+  it('has one entry per version below the current one', () => {
+    expect(MIGRATIONS).toHaveLength(CURRENT_DOCUMENT_VERSION);
+  });
+
+  it('indexes migrateV0toV1 at position 0', () => {
+    expect(MIGRATIONS[0]).toBe(migrateV0toV1);
+  });
+
+  it('indexes migrateV1toV2 at position 1', () => {
+    expect(MIGRATIONS[1]).toBe(migrateV1toV2);
+  });
+
+  it('walks a version-0 document all the way to trials', () => {
+    const outcome = runMigrations(
+      { version: 0, workspaces: [{ id: 'w1' }] },
+      MIGRATIONS,
+      CURRENT_DOCUMENT_VERSION,
+    );
+    expect(outcome).toMatchObject({ ok: true, migrated: true });
+    expect(outcome.ok && outcome.doc.trials).toEqual([{ id: 'w1' }]);
+  });
+});
+
+describe('quarantineDocument', () => {
+  it('copies the document aside and confirms it landed', () => {
+    const storage = createMemoryAdapter();
+
+    expect(quarantineDocument(storage, 'lab', 'the-bytes')).toBe(true);
+    expect(storage.read(quarantineKey('lab'))).toBe('the-bytes');
+  });
+
+  it('returns false when the quarantine write silently fails', () => {
+    const storage = createMemoryAdapter();
+    storage.write = () => {};
+
+    expect(quarantineDocument(storage, 'lab', 'the-bytes')).toBe(false);
+  });
+});
+
+describe('normalizeDocument', () => {
+  it('fills in every missing section', () => {
+    expect(normalizeDocument({ version: CURRENT_DOCUMENT_VERSION }, 'auto')).toEqual({
+      version: CURRENT_DOCUMENT_VERSION,
+      trials: [],
+      saves: [],
+      layout: {},
+      mode: 'auto',
+    });
+  });
+
+  it('uses the fallback mode when the document has none', () => {
+    expect(normalizeDocument({ version: CURRENT_DOCUMENT_VERSION }, 'light').mode).toBe('light');
+  });
+
+  it('uses the fallback mode when the stored mode is unrecognized', () => {
+    expect(
+      normalizeDocument({ version: CURRENT_DOCUMENT_VERSION, mode: 'chartreuse' }, 'light').mode,
+    ).toBe('light');
+  });
+
+  it('keeps a stored mode over the fallback', () => {
+    expect(
+      normalizeDocument({ version: CURRENT_DOCUMENT_VERSION, mode: 'dark' }, 'light').mode,
+    ).toBe('dark');
+  });
+
+  it('preserves populated sections', () => {
+    const trials = [{ id: 'w1' }];
+    const saves = [{ id: 's1' }];
+    const layout = { w1: { h: 4 } };
+    const out = normalizeDocument(
+      { version: CURRENT_DOCUMENT_VERSION, trials, saves, layout },
+      'auto',
+    );
+    expect(out.trials).toEqual(trials);
+    expect(out.saves).toEqual(saves);
+    expect(out.layout).toEqual(layout);
+  });
+
+  it('replaces wrong-shaped sections without swapping them', () => {
+    const out = normalizeDocument(
+      { version: CURRENT_DOCUMENT_VERSION, trials: 'nope', saves: 'nope', layout: 'nope' },
+      'auto',
+    );
+    expect(out.trials).toEqual([]);
+    expect(out.saves).toEqual([]);
+    expect(out.layout).toEqual({});
+  });
+});