@happyvertical/smrt-ui 0.53.0 → 0.53.2

package/dist/components/data/__tests__/mounted-data-surface.test.js

@@ -1,794 +0,0 @@
-import { render, screen } from '@testing-library/svelte';
-import userEvent from '@testing-library/user-event';
-import { describe, expect, it, vi } from 'vitest';
-import CollectionToolbar from '../CollectionToolbar.svelte';
-import DataTable from '../DataTable.svelte';
-import { createDataTableController } from '../DataTableController.js';
-import { createDataSurfaceRegistry, } from '../data-surface.js';
-const columns = [
-    { id: 'name', label: 'Name', accessor: 'name', sortable: true },
-    { id: 'age', label: 'Age', accessor: 'age', sortable: true },
-];
-const rows = [
-    { name: 'Ada', age: 36 },
-    { name: 'Grace', age: 85 },
-];
-function descriptor(identity, controls) {
-    return {
-        version: 1,
-        identity,
-        schemaVersion: 1,
-        label: identity.surfaceId,
-        rowKey: 'name',
-        columns: columns.map((column) => ({
-            id: column.id,
-            label: column.label,
-            capabilities: ['read', 'search', 'filter', 'sort', 'project'],
-        })),
-        query: { modes: ['rows', 'count'], projectableColumnIds: ['name', 'age'] },
-        controls: controls.map((id) => ({ id, label: id })),
-        actions: [],
-        limits: { maxQueryRows: 100, maxQueryBytes: 10_000, maxSelectionSize: 10 },
-    };
-}
-describe('mounted data surfaces', () => {
-    it('registers a DataTable explicitly and acknowledges the same controller state used by a header click', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'people-table',
-            kind: 'table',
-        };
-        const controller = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                sortable: true,
-                controller,
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, ['toggle-sorting', 'set-search']),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        await userEvent.click(screen.getByRole('button', { name: 'Sort Name ascending' }));
-        const humanSnapshot = registry.inspect(identity);
-        expect(humanSnapshot).toMatchObject({
-            revision: 1,
-            state: {
-                table: { state: { sorting: [{ columnId: 'name', direction: 'asc' }] } },
-            },
-        });
-        const result = await registry.execute({
-            version: 1,
-            commandId: 'sort-age',
-            identity,
-            expectedRevision: humanSnapshot?.revision ?? -1,
-            controlId: 'toggle-sorting',
-            payload: { columnId: 'age', multi: true },
-        });
-        expect(result).toMatchObject({ ok: true, revision: 2 });
-        expect(controller.getState().sorting).toEqual([
-            { columnId: 'name', direction: 'asc' },
-            { columnId: 'age', direction: 'asc' },
-        ]);
-    });
-    it('focuses a normal mounted table through its programmatic focus target', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'focusable-people-table',
-            kind: 'table',
-        };
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, ['focus']),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'focus-table',
-            identity,
-            expectedRevision: 0,
-            controlId: 'focus',
-        })).resolves.toMatchObject({ ok: true });
-        expect(document.activeElement).toBe(document.querySelector('.data-table-container'));
-    });
-    it('enforces descriptor membership and filter/sort capabilities before dispatch', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'policy-filtered-people-table',
-            kind: 'table',
-        };
-        const controller = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller,
-                dataSurface: {
-                    registry,
-                    descriptor: {
-                        ...descriptor(identity, [
-                            'set-filters',
-                            'set-sorting',
-                            'toggle-sorting',
-                            'set-column-order',
-                            'set-column-visibility',
-                        ]),
-                        columns: [
-                            {
-                                id: 'name',
-                                label: 'Name',
-                                capabilities: ['read', 'sort'],
-                            },
-                        ],
-                        query: { modes: ['rows'], projectableColumnIds: ['name'] },
-                    },
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        for (const [commandId, controlId, payload] of [
-            [
-                'hidden-age-filter',
-                'set-filters',
-                { filters: [{ columnId: 'age', operator: 'equals', value: 36 }] },
-            ],
-            [
-                'hidden-age-sort',
-                'set-sorting',
-                { sorting: [{ columnId: 'age', direction: 'asc' }] },
-            ],
-            ['hidden-age-toggle', 'toggle-sorting', { columnId: 'age' }],
-            ['hidden-age-order', 'set-column-order', { columnIds: ['name', 'age'] }],
-            [
-                'hidden-age-visibility',
-                'set-column-visibility',
-                { columns: [{ columnId: 'age', visible: true }] },
-            ],
-            [
-                'non-filterable-name',
-                'set-filters',
-                { filters: [{ columnId: 'name', operator: 'equals', value: 'Ada' }] },
-            ],
-        ]) {
-            await expect(registry.execute({
-                version: 1,
-                commandId,
-                identity,
-                expectedRevision: 0,
-                controlId,
-                payload,
-            })).resolves.toMatchObject({ ok: false, reason: 'denied' });
-        }
-        expect(controller.getState().filters).toEqual([]);
-        expect(controller.getState().sorting).toEqual([]);
-    });
-    it('preserves page and all-matching selection scopes in mounted snapshots', async () => {
-        const registry = createDataSurfaceRegistry();
-        const pageIdentity = {
-            surfaceId: 'page-selection-table',
-            kind: 'table',
-        };
-        const allMatchingIdentity = {
-            surfaceId: 'all-matching-selection-table',
-            kind: 'table',
-        };
-        const props = {
-            data: rows,
-            columns,
-            rowKey: 'name',
-            dataSurface: {
-                registry,
-                descriptor: descriptor(pageIdentity, []),
-            },
-        };
-        render(DataTable, {
-            props: {
-                ...props,
-                controller: createDataTableController({
-                    initialState: { selection: { scope: 'page', rowIds: ['Ada'] } },
-                }),
-            },
-        });
-        render(DataTable, {
-            props: {
-                ...props,
-                controller: createDataTableController({
-                    initialState: {
-                        selection: {
-                            scope: 'allMatching',
-                            expectedCount: 42,
-                            queryFingerprint: 'people-query',
-                            queryRevision: 'revision-1',
-                        },
-                    },
-                    columnIds: columns.map((column) => column.id),
-                }),
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(allMatchingIdentity, []),
-                },
-            },
-        });
-        await vi.waitFor(() => {
-            expect(registry.inspect(pageIdentity)?.selection).toEqual({
-                scope: 'current-page',
-            });
-            expect(registry.inspect(allMatchingIdentity)?.selection).toEqual({
-                scope: 'all-matching',
-                queryFingerprint: 'people-query',
-            });
-        });
-    });
-    it('rejects visibility commands that would hide declared surface columns', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'visible-columns-table',
-            kind: 'table',
-        };
-        const controller = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller,
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, ['set-column-visibility']),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'hide-age',
-            identity,
-            expectedRevision: 0,
-            controlId: 'set-column-visibility',
-            payload: {
-                columns: [
-                    { columnId: 'name', visible: true },
-                    { columnId: 'age', visible: false },
-                ],
-            },
-        })).resolves.toMatchObject({ ok: false, reason: 'denied' });
-        expect(controller.getState().columnVisibility).toEqual([
-            { columnId: 'age', visible: true },
-            { columnId: 'name', visible: true },
-        ]);
-    });
-    it('restores declared columns after an external controller visibility transition', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'external-visible-columns-table',
-            kind: 'table',
-        };
-        const controller = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller,
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, []),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        controller.dispatch({
-            type: 'setColumnVisibility',
-            columns: [
-                { columnId: 'name', visible: true },
-                { columnId: 'age', visible: false },
-            ],
-        });
-        expect(controller.getState().columnVisibility).toEqual([
-            { columnId: 'age', visible: true },
-            { columnId: 'name', visible: true },
-        ]);
-        expect(registry.inspect(identity)?.descriptor.columns).toHaveLength(2);
-    });
-    it('turns malformed table command payloads into bounded denials', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'malformed-command-table',
-            kind: 'table',
-        };
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, [
-                        'set-filters',
-                        'set-sorting',
-                        'set-column-visibility',
-                    ]),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        for (const [commandId, controlId, payload] of [
-            [
-                'bad-filter',
-                'set-filters',
-                { filters: [{ columnId: 'name', operator: 'unknown' }] },
-            ],
-            [
-                'bad-sort',
-                'set-sorting',
-                { sorting: [{ columnId: 'name', direction: 'sideways' }] },
-            ],
-            [
-                'bad-visibility',
-                'set-column-visibility',
-                { columns: [{ columnId: 'name', visible: 'yes' }] },
-            ],
-        ]) {
-            await expect(registry.execute({
-                version: 1,
-                commandId,
-                identity,
-                expectedRevision: 0,
-                controlId,
-                payload,
-            })).resolves.toMatchObject({ ok: false, reason: 'denied' });
-        }
-    });
-    it('waits for a controlled DataTable host to settle candidate state before acknowledgement', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'controlled-people-table',
-            kind: 'table',
-        };
-        const initial = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        }).getState();
-        const controller = createDataTableController({
-            state: initial,
-            columnIds: columns.map((column) => column.id),
-        });
-        const applyControlledState = vi.fn((state) => state);
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller,
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, ['set-search']),
-                    applyControlledState,
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        const result = await registry.execute({
-            version: 1,
-            commandId: 'search-grace',
-            identity,
-            expectedRevision: 0,
-            controlId: 'set-search',
-            payload: { search: 'Grace' },
-        });
-        expect(applyControlledState).toHaveBeenCalledOnce();
-        expect(result).toMatchObject({
-            ok: true,
-            revision: 1,
-            snapshot: { state: { table: { state: { search: 'Grace' } } } },
-        });
-    });
-    it('denies or fails controlled commands when the host does not settle them', async () => {
-        const registry = createDataSurfaceRegistry();
-        const initial = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        }).getState();
-        const deniedIdentity = {
-            surfaceId: 'denied-controlled-table',
-            kind: 'table',
-        };
-        const failedIdentity = {
-            surfaceId: 'failed-controlled-table',
-            kind: 'table',
-        };
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller: createDataTableController({
-                    state: initial,
-                    columnIds: columns.map((column) => column.id),
-                }),
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(deniedIdentity, ['set-search']),
-                    applyControlledState: () => undefined,
-                },
-            },
-        });
-        render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller: createDataTableController({
-                    state: initial,
-                    columnIds: columns.map((column) => column.id),
-                }),
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(failedIdentity, ['set-search']),
-                    applyControlledState: () => {
-                        throw new Error('host rejected state');
-                    },
-                },
-            },
-        });
-        await vi.waitFor(() => {
-            expect(registry.inspect(deniedIdentity)).toBeDefined();
-            expect(registry.inspect(failedIdentity)).toBeDefined();
-        });
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'denied-search',
-            identity: deniedIdentity,
-            expectedRevision: 0,
-            controlId: 'set-search',
-            payload: { search: 'Ada' },
-        })).resolves.toMatchObject({ ok: false, reason: 'denied' });
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'failed-search',
-            identity: failedIdentity,
-            expectedRevision: 0,
-            controlId: 'set-search',
-            payload: { search: 'Ada' },
-        })).resolves.toMatchObject({ ok: false, reason: 'execution_failed' });
-    });
-    it('unregisters a mounted DataTable when the component unmounts', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'unmounted-table',
-            kind: 'table',
-        };
-        const { unmount } = render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, ['set-search']),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        unmount();
-        expect(registry.inspect(identity)).toBeUndefined();
-    });
-    it('reactively registers delayed and replacement DataTable surface props', async () => {
-        const registry = createDataSurfaceRegistry();
-        const firstIdentity = {
-            surfaceId: 'first-people-table',
-            kind: 'table',
-        };
-        const nextIdentity = {
-            surfaceId: 'next-people-table',
-            kind: 'table',
-        };
-        const firstController = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        const nextController = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        const { rerender } = render(DataTable, {
-            props: {
-                data: rows,
-                columns,
-                rowKey: 'name',
-                controller: firstController,
-            },
-        });
-        expect(registry.inspect(firstIdentity)).toBeUndefined();
-        await rerender({
-            data: rows,
-            columns,
-            rowKey: 'name',
-            controller: firstController,
-            dataSurface: {
-                registry,
-                descriptor: descriptor(firstIdentity, ['set-search']),
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(firstIdentity)).toBeDefined());
-        await rerender({
-            data: rows,
-            columns,
-            rowKey: 'name',
-            controller: nextController,
-            dataSurface: {
-                registry,
-                descriptor: descriptor(nextIdentity, ['set-search']),
-            },
-        });
-        await vi.waitFor(() => {
-            expect(registry.inspect(firstIdentity)).toBeUndefined();
-            expect(registry.inspect(nextIdentity)).toBeDefined();
-        });
-        await registry.execute({
-            version: 1,
-            commandId: 'next-search',
-            identity: nextIdentity,
-            expectedRevision: 0,
-            controlId: 'set-search',
-            payload: { search: 'Grace' },
-        });
-        expect(firstController.getState().search).toBe('');
-        expect(nextController.getState().search).toBe('Grace');
-    });
-    it('allows a stable row key that is not a rendered column', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'hidden-id-table',
-            kind: 'table',
-        };
-        render(DataTable, {
-            props: {
-                data: [{ id: 'ada', name: 'Ada' }],
-                columns: [{ id: 'name', label: 'Name', accessor: 'name' }],
-                rowKey: 'id',
-                dataSurface: {
-                    registry,
-                    descriptor: {
-                        ...descriptor(identity, []),
-                        rowKey: 'id',
-                        columns: [
-                            { id: 'id', label: 'ID', capabilities: ['read'] },
-                            { id: 'name', label: 'Name', capabilities: ['read'] },
-                        ],
-                        query: {
-                            modes: ['rows'],
-                            projectableColumnIds: ['id', 'name'],
-                        },
-                    },
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-    });
-    it('registers a CollectionToolbar without a hidden automation path and shares its controller search', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'people-toolbar',
-            kind: 'custom',
-        };
-        const controller = createDataTableController();
-        render(CollectionToolbar, {
-            props: {
-                controller,
-                views: ['list', 'grid', 'table'],
-                dataSurface: {
-                    registry,
-                    descriptor: descriptor(identity, ['set-search', 'set-view']),
-                },
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        const search = await registry.execute({
-            version: 1,
-            commandId: 'toolbar-search',
-            identity,
-            expectedRevision: 0,
-            controlId: 'set-search',
-            payload: { search: 'Ada' },
-        });
-        const view = await registry.execute({
-            version: 1,
-            commandId: 'toolbar-grid',
-            identity,
-            expectedRevision: search.revision ?? -1,
-            controlId: 'set-view',
-            payload: { view: 'grid' },
-        });
-        expect(controller.getState().search).toBe('Ada');
-        expect(view).toMatchObject({
-            ok: true,
-            snapshot: { state: { search: 'Ada', view: 'grid' } },
-        });
-    });
-    it('reactively registers delayed and replacement CollectionToolbar surface props', async () => {
-        const registry = createDataSurfaceRegistry();
-        const firstIdentity = {
-            surfaceId: 'first-people-toolbar',
-            kind: 'custom',
-        };
-        const nextIdentity = {
-            surfaceId: 'next-people-toolbar',
-            kind: 'custom',
-        };
-        const firstController = createDataTableController();
-        const nextController = createDataTableController();
-        const { rerender } = render(CollectionToolbar, {
-            props: { controller: firstController },
-        });
-        expect(registry.inspect(firstIdentity)).toBeUndefined();
-        await rerender({
-            controller: firstController,
-            dataSurface: {
-                registry,
-                descriptor: descriptor(firstIdentity, ['set-search']),
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(firstIdentity)).toBeDefined());
-        await rerender({
-            controller: nextController,
-            dataSurface: {
-                registry,
-                descriptor: descriptor(nextIdentity, ['set-search']),
-            },
-        });
-        await vi.waitFor(() => {
-            expect(registry.inspect(firstIdentity)).toBeUndefined();
-            expect(registry.inspect(nextIdentity)).toBeDefined();
-        });
-        await registry.execute({
-            version: 1,
-            commandId: 'next-toolbar-search',
-            identity: nextIdentity,
-            expectedRevision: 0,
-            controlId: 'set-search',
-            payload: { search: 'Grace' },
-        });
-        expect(firstController.getState().search).toBe('');
-        expect(nextController.getState().search).toBe('Grace');
-    });
-    it('revisions externally changed uncontrolled toolbar state', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'externally-controlled-toolbar',
-            kind: 'custom',
-        };
-        const dataSurface = {
-            registry,
-            descriptor: descriptor(identity, ['set-search', 'set-view']),
-        };
-        const { rerender } = render(CollectionToolbar, {
-            props: {
-                search: 'Ada',
-                view: 'list',
-                dataSurface,
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        await rerender({
-            search: 'Grace',
-            view: 'grid',
-            dataSurface,
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toMatchObject({
-            revision: 1,
-            state: { search: 'Grace', view: 'grid' },
-        }));
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'stale-toolbar-command',
-            identity,
-            expectedRevision: 0,
-            controlId: 'set-view',
-            payload: { view: 'list' },
-        })).resolves.toMatchObject({ ok: false, reason: 'stale_revision' });
-    });
-    it('preserves toolbar revisions for equivalent surface bindings', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'equivalent-toolbar-binding',
-            kind: 'custom',
-        };
-        const surface = () => ({
-            registry,
-            descriptor: descriptor(identity, ['set-view']),
-        });
-        const { rerender } = render(CollectionToolbar, {
-            props: { dataSurface: surface() },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'change-toolbar-view',
-            identity,
-            expectedRevision: 0,
-            controlId: 'set-view',
-            payload: { view: 'grid' },
-        })).resolves.toMatchObject({ ok: true, revision: 1 });
-        await rerender({ dataSurface: surface() });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toMatchObject({
-            revision: 1,
-            state: { search: '', view: 'grid' },
-        }));
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'stale-equivalent-toolbar-command',
-            identity,
-            expectedRevision: 0,
-            controlId: 'set-view',
-            payload: { view: 'list' },
-        })).resolves.toMatchObject({ ok: false, reason: 'stale_revision' });
-    });
-    it('preserves DataTable registration and replay state for equivalent bindings', async () => {
-        const registry = createDataSurfaceRegistry();
-        const identity = {
-            surfaceId: 'equivalent-table-binding',
-            kind: 'table',
-        };
-        const equivalentColumns = () => columns.map((column) => ({ ...column }));
-        const surface = () => ({
-            registry,
-            descriptor: descriptor(identity, ['toggle-sorting']),
-        });
-        const controller = createDataTableController({
-            columnIds: columns.map((column) => column.id),
-        });
-        const { rerender } = render(DataTable, {
-            props: {
-                data: rows,
-                columns: equivalentColumns(),
-                rowKey: 'name',
-                sortable: true,
-                controller,
-                dataSurface: surface(),
-            },
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toBeDefined());
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'table-sort',
-            identity,
-            expectedRevision: 0,
-            controlId: 'toggle-sorting',
-            payload: { columnId: 'name' },
-        })).resolves.toMatchObject({ ok: true, revision: 1 });
-        await rerender({
-            data: rows,
-            columns: equivalentColumns(),
-            rowKey: 'name',
-            sortable: true,
-            controller,
-            dataSurface: surface(),
-        });
-        await vi.waitFor(() => expect(registry.inspect(identity)).toMatchObject({ revision: 1 }));
-        await expect(registry.execute({
-            version: 1,
-            commandId: 'stale-table-sort',
-            identity,
-            expectedRevision: 0,
-            controlId: 'toggle-sorting',
-            payload: { columnId: 'name' },
-        })).resolves.toMatchObject({ ok: false, reason: 'stale_revision' });
-    });
-});