@dxos/plugin-sheet 0.8.4-main.9735255 → 0.8.4-main.abd8ff62ef

package/src/extensions/editor/sheet-extension.ts

@@ -18,8 +18,8 @@ import { type SyntaxNode } from '@lezer/common';
 import { tags } from '@lezer/highlight';
 import { spreadsheet } from 'codemirror-lang-spreadsheet';
 
-import { type FunctionDefinition } from '@dxos/compute';
-import { RANGE_NOTATION } from '@dxos/compute';
+import { type FunctionDefinition } from '@dxos/compute-hyperformula';
+import { RANGE_NOTATION } from '@dxos/compute-hyperformula';
 import { singleValueFacet } from '@dxos/ui-editor';
 import { mx } from '@dxos/ui-theme';
 
@@ -33,30 +33,30 @@ const highlightStyles = HighlightStyle.define([
   // Function.
   {
     tag: tags.name,
-    class: 'text-accentText',
+    class: 'text-accent-text',
   },
   // Range.
   {
     tag: tags.tagName,
-    class: 'text-pinkText',
+    class: 'text-pink-text',
   },
   // Values.
   {
     tag: tags.number,
-    class: 'text-tealText',
+    class: 'text-teal-text',
   },
   {
     tag: tags.bool,
-    class: 'text-tealText',
+    class: 'text-teal-text',
   },
   {
     tag: tags.string,
-    class: 'text-tealText',
+    class: 'text-teal-text',
   },
   // Error.
   {
     tag: tags.invalid,
-    class: 'text-unAccent',
+    class: 'text-un-accent',
   },
 ]);
 
@@ -97,7 +97,7 @@ export const sheetExtension = ({ debug, functions = [] }: SheetExtensionOptions)
 
         const title = document.createElement('h2');
         title.innerText = name;
-        title.className = 'text-lg font-mono text-accentText';
+        title.className = 'text-lg font-mono text-accent-text';
         root.appendChild(title);
 
         if (description) {
@@ -110,7 +110,7 @@ export const sheetExtension = ({ debug, functions = [] }: SheetExtensionOptions)
         if (syntax) {
           const detail = document.createElement('pre');
           detail.innerText = syntax;
-          detail.className = 'whitespace-pre-wrap text-greenText';
+          detail.className = 'whitespace-pre-wrap text-green-text';
           root.appendChild(detail);
         }
 
@@ -169,8 +169,8 @@ export const sheetExtension = ({ debug, functions = [] }: SheetExtensionOptions)
       icons: false,
       tooltipClass: () =>
         mx(
-          '!-left-[1px] !top-[33px] !-m-0 border !border-bs-0 [&>ul]:!min-w-[198px]',
-          '[&>ul>li[aria-selected]]:!bg-accentSurface',
+          '!-left-[1px] !top-[33px] !-m-0 border border-h-0! [&>ul]:!min-w-[198px]',
+          '[&>ul>li[aria-selected]]:!bg-accent-surface',
           'border-separator',
         ),
     }),

package/src/index.ts

@@ -2,6 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-export { SheetCapabilities } from './types';
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const SheetPlugin = Plugin.lazy(meta, () => import('./SheetPlugin'));
+
 export * from './meta';
-export * from './SheetPlugin';
+
+export { SheetCapabilities } from './types';

package/src/integrations/thread-ranges.ts

@@ -2,23 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Effect from 'effect/Effect';
 import { useCallback, useEffect, useMemo } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { useOperationInvoker, useOperationResolver } from '@dxos/app-framework/react';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { debounce } from '@dxos/async';
-import { type CellAddress, type CompleteCellRange, inRange } from '@dxos/compute';
+import { type CellAddress, type CompleteCellRange, inRange } from '@dxos/compute-hyperformula';
 import { Obj, Relation } from '@dxos/echo';
-import { OperationResolver } from '@dxos/operation';
-import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
-import { ThreadOperation } from '@dxos/plugin-thread/types';
+import { ThreadOperation } from '@dxos/plugin-thread/operations';
 import { Filter, Query, useQuery } from '@dxos/react-client/echo';
-import { type DxGridElement, type GridContentProps } from '@dxos/react-ui-grid';
+import { linkedSegment } from '@dxos/react-ui-attention';
 import { AnchoredTo, Thread } from '@dxos/types';
 
-import { useSheetContext } from '../components';
-import { meta } from '../meta';
+import { useSheetContext } from '#components';
 
 export const completeCellRangeToThreadCursor = (range: CompleteCellRange): string => {
   return `${range.from.col},${range.from.row},${range.to.col},${range.to.row}`;
@@ -37,33 +33,6 @@ export const parseThreadAnchorAsCellRange = (cursor: string): CompleteCellRange
   }
 };
 
-export const useUpdateFocusedCellOnThreadSelection = (grid: DxGridElement | null) => {
-  const { model, setActiveRefs } = useSheetContext();
-  const sheetId = Obj.getDXN(model.sheet).toString();
-
-  const scrollIntoViewHandler = useMemo(
-    () =>
-      OperationResolver.make({
-        operation: Common.LayoutOperation.ScrollIntoView,
-        position: 'hoist',
-        filter: (input) => input.subject === sheetId && !!input.cursor,
-        handler: (input) =>
-          Effect.sync(() => {
-            const { cursor, ref } = input;
-            if (cursor) {
-              setActiveRefs(ref as GridContentProps['activeRefs']);
-              // TODO(Zan): Everywhere we refer to the cursor in a thread context should change to `anchor`.
-              const range = parseThreadAnchorAsCellRange(cursor);
-              range && grid?.setFocus({ ...range.to, plane: 'grid' }, true);
-            }
-          }),
-      }),
-    [sheetId, setActiveRefs, grid],
-  );
-
-  useOperationResolver(meta.id, scrollIntoViewHandler);
-};
-
 export const useSelectThreadOnCellFocus = () => {
   const { model, cursor } = useSheetContext();
   const { invokePromise } = useOperationInvoker();
@@ -88,12 +57,10 @@ export const useSelectThreadOnCellFocus = () => {
       });
 
       if (closestThread) {
-        const primary = Obj.getDXN(model.sheet).toString();
         void (async () => {
           await invokePromise(ThreadOperation.Select, { current: Relation.getDXN(closestThread).toString() });
-          await invokePromise(DeckOperation.ChangeCompanion, {
-            primary,
-            companion: `${primary}${ATTENDABLE_PATH_SEPARATOR}comments`,
+          await invokePromise(LayoutOperation.UpdateCompanion, {
+            subject: linkedSegment('comments'),
           });
         })();
       }

package/src/meta.ts

@@ -6,7 +6,7 @@ import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
 export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/sheet',
+  id: 'org.dxos.plugin.sheet',
   name: 'Sheet',
   description: trim`
     Full-featured spreadsheet application with over 400 built-in formulas for calculations and data analysis.

package/src/model/sheet-model.test.ts

@@ -5,12 +5,12 @@
 import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
-import { type CellScalarValue, addressFromA1Notation, isFormula } from '@dxos/compute';
-import { TestBuilder, testFunctionPlugins } from '@dxos/compute/testing';
-import { Function } from '@dxos/functions';
+import { Operation } from '@dxos/compute';
+import { type CellScalarValue, addressFromA1Notation, isFormula } from '@dxos/compute-hyperformula';
+import { TestBuilder, testFunctionPlugins } from '@dxos/compute-hyperformula/testing';
 import { log } from '@dxos/log';
 
-import { Sheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '../types';
+import { Sheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '#types';
 
 import { SheetModel } from './sheet-model';
 import { createTestGrid } from './testing';
@@ -18,7 +18,7 @@ import { createTestGrid } from './testing';
 describe('SheetModel', () => {
   let testBuilder: TestBuilder;
   beforeEach(async () => {
-    testBuilder = new TestBuilder({ types: [Function.Function], plugins: testFunctionPlugins });
+    testBuilder = new TestBuilder({ types: [Operation.PersistentOperation], plugins: testFunctionPlugins });
     await testBuilder.open();
   });
   afterEach(async () => {

package/src/model/sheet-model.ts

@@ -20,7 +20,7 @@ import {
   addressToA1Notation,
   createSheetName,
   isFormula,
-} from '@dxos/compute';
+} from '@dxos/compute-hyperformula';
 import { Resource } from '@dxos/context';
 import { Obj } from '@dxos/echo';
 import { Format, TypeEnum } from '@dxos/echo/internal';
@@ -38,8 +38,8 @@ import {
   insertIndices,
   mapFormulaIndicesToRefs,
   mapFormulaRefsToIndices,
-} from '../types';
-import { type Sheet, type SheetAction } from '../types';
+} from '#types';
+import { type Sheet, type SheetAction } from '#types';
 
 // TODO(burdon): Move to compute.
 // Map sheet types to system types.
@@ -122,8 +122,8 @@ export class SheetModel extends Resource {
    */
   protected override async _open(): Promise<void> {
     log('initialize', { id: this.id });
-    Obj.change(this._sheet, (s) => {
-      initialize(s);
+    Obj.update(this._sheet, (obj) => {
+      initialize(obj);
     });
 
     this._graph.update.on((event) => {
@@ -184,8 +184,8 @@ export class SheetModel extends Resource {
 
   insertRows(i: number, n = 1): string[] {
     let idx: string[] = [];
-    Obj.change(this._sheet, (s) => {
-      idx = insertIndices(s.rows, i, n, MAX_ROWS);
+    Obj.update(this._sheet, (obj) => {
+      idx = insertIndices(obj.rows, i, n, MAX_ROWS);
     });
     this.reset();
     return idx;
@@ -193,8 +193,8 @@ export class SheetModel extends Resource {
 
   insertColumns(i: number, n = 1): string[] {
     let idx: string[] = [];
-    Obj.change(this._sheet, (s) => {
-      idx = insertIndices(s.columns, i, n, MAX_COLS);
+    Obj.update(this._sheet, (obj) => {
+      idx = insertIndices(obj.columns, i, n, MAX_COLS);
     });
     this.reset();
     return idx;
@@ -208,9 +208,9 @@ export class SheetModel extends Resource {
     const values = this.getCellValues(range).flat();
     const index = this._sheet.rows.indexOf(rowIndex);
     this.clear(range);
-    Obj.change(this._sheet, (s) => {
-      s.rows.splice(index, 1);
-      delete s.rowMeta[rowIndex];
+    Obj.update(this._sheet, (obj) => {
+      obj.rows.splice(index, 1);
+      delete obj.rowMeta[rowIndex];
     });
     this.reset();
     return { axis: 'row', index, axisIndex: rowIndex, axisMeta: this._sheet.rowMeta[rowIndex], values };
@@ -224,39 +224,41 @@ export class SheetModel extends Resource {
     const values = this.getCellValues(range).flat();
     const index = this._sheet.columns.indexOf(colIndex);
     this.clear(range);
-    Obj.change(this._sheet, (s) => {
-      s.columns.splice(index, 1);
-      delete s.columnMeta[colIndex];
+    Obj.update(this._sheet, (obj) => {
+      obj.columns.splice(index, 1);
+      delete obj.columnMeta[colIndex];
     });
     this.reset();
     return { axis: 'col', index, axisIndex: colIndex, axisMeta: this._sheet.rowMeta[colIndex], values };
   }
 
   restoreRow({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis): void {
-    Obj.change(this._sheet, (s) => {
-      s.rows.splice(index, 0, axisIndex);
+    Obj.update(this._sheet, (obj) => {
+      obj.rows.splice(index, 0, axisIndex);
       values.forEach((value, col) => {
         if (value) {
-          s.cells[`${s.columns[col]}@${axisIndex}`] = { value };
+          obj.cells[`${obj.columns[col]}@${axisIndex}`] = { value };
         }
       });
+
       if (axisMeta) {
-        s.rowMeta[axisIndex] = axisMeta;
+        obj.rowMeta[axisIndex] = axisMeta;
       }
     });
     this.reset();
   }
 
   restoreColumn({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis): void {
-    Obj.change(this._sheet, (s) => {
-      s.columns.splice(index, 0, axisIndex);
+    Obj.update(this._sheet, (obj) => {
+      obj.columns.splice(index, 0, axisIndex);
       values.forEach((value, row) => {
         if (value) {
-          s.cells[`${axisIndex}@${s.rows[row]}`] = { value };
+          obj.cells[`${axisIndex}@${obj.rows[row]}`] = { value };
         }
       });
+
       if (axisMeta) {
-        s.columnMeta[axisIndex] = axisMeta;
+        obj.columnMeta[axisIndex] = axisMeta;
       }
     });
     this.reset();
@@ -275,10 +277,10 @@ export class SheetModel extends Resource {
     const topLeft = getTopLeft(range);
     const values = this._iterRange(range, () => null);
     this._node.graph.hf.setCellContents(toSimpleCellAddress(this._node.sheetId, topLeft), values);
-    Obj.change(this._sheet, (s) => {
+    Obj.update(this._sheet, (obj) => {
       this._iterRange(range, (cell) => {
         const idx = addressToIndex(this._sheet, cell);
-        delete s.cells[idx];
+        delete obj.cells[idx];
       });
     });
   }
@@ -286,10 +288,10 @@ export class SheetModel extends Resource {
   cut(range: CellRange): void {
     invariant(this._node);
     this._node.graph.hf.cut(toModelRange(this._node.sheetId, range));
-    Obj.change(this._sheet, (s) => {
+    Obj.update(this._sheet, (obj) => {
       this._iterRange(range, (cell) => {
         const idx = addressToIndex(this._sheet, cell);
-        delete s.cells[idx];
+        delete obj.cells[idx];
       });
     });
   }
@@ -303,12 +305,12 @@ export class SheetModel extends Resource {
     invariant(this._node);
     if (!this._node.graph.hf.isClipboardEmpty()) {
       const changes = this._node.graph.hf.paste(toSimpleCellAddress(this._node.sheetId, cell));
-      Obj.change(this._sheet, (s) => {
+      Obj.update(this._sheet, (obj) => {
         for (const change of changes) {
           if (change instanceof ExportedCellChange) {
             const { address, newValue } = change;
             const idx = addressToIndex(this._sheet, { row: address.row, col: address.col });
-            s.cells[idx] = { value: newValue };
+            obj.cells[idx] = { value: newValue };
           }
         }
       });
@@ -402,14 +404,14 @@ export class SheetModel extends Resource {
     // Reallocate if > current bounds.
     let refresh = false;
     if (cell.row >= this._sheet.rows.length) {
-      Obj.change(this._sheet, (s) => {
-        insertIndices(s.rows, cell.row, 1, MAX_ROWS);
+      Obj.update(this._sheet, (obj) => {
+        insertIndices(obj.rows, cell.row, 1, MAX_ROWS);
       });
       refresh = true;
     }
     if (cell.col >= this._sheet.columns.length) {
-      Obj.change(this._sheet, (s) => {
-        insertIndices(s.columns, cell.col, 1, MAX_COLS);
+      Obj.update(this._sheet, (obj) => {
+        insertIndices(obj.columns, cell.col, 1, MAX_COLS);
       });
       refresh = true;
     }
@@ -427,16 +429,16 @@ export class SheetModel extends Resource {
     // Insert into sheet.
     const idx = addressToIndex(this._sheet, cell);
     if (value === undefined || value === null) {
-      Obj.change(this._sheet, (s) => {
-        delete s.cells[idx];
+      Obj.update(this._sheet, (obj) => {
+        delete obj.cells[idx];
       });
     } else {
       if (isFormula(value)) {
         value = this._graph.mapFunctionBindingToId(mapFormulaRefsToIndices(this._sheet, value));
       }
 
-      Obj.change(this._sheet, (s) => {
-        s.cells[idx] = { value };
+      Obj.update(this._sheet, (obj) => {
+        obj.cells[idx] = { value };
       });
     }
   }

package/src/model/testing.ts

@@ -2,9 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { addressToA1Notation } from '@dxos/compute';
+import { addressToA1Notation } from '@dxos/compute-hyperformula';
 
-import { Sheet } from '../types';
+import { Sheet } from '#types';
 
 // TODO(burdon): Create testing endpoint.
 // TODO(burdon): Move to react-ui-sheet.

package/src/model/useSheetModel.ts

@@ -4,10 +4,11 @@
 
 import { useEffect, useState } from 'react';
 
-import { type ComputeGraph } from '@dxos/compute';
+import { type ComputeGraph } from '@dxos/compute-hyperformula';
+
+import { type Sheet } from '#types';
 
 import { SheetModel } from '../model';
-import { type Sheet } from '../types';
 
 export type UseSheetModelOptions = {
   readonly?: boolean;

package/src/operations/definitions.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { meta } from '#meta';
+
+const SHEET_OPERATION = `${meta.id}.operation`;
+
+// TODO(wittjosiah): Factor out. This is `DxGridAxis` from `@dxos/react-ui-grid`.
+const Axis = Schema.Union(Schema.Literal('row'), Schema.Literal('col'));
+
+export const InsertAxis = Operation.make({
+  meta: { key: `${SHEET_OPERATION}.axis-insert`, name: 'Insert Axis' },
+  input: Schema.Struct({
+    model: Schema.Any,
+    axis: Axis,
+    index: Schema.Number,
+    count: Schema.optional(Schema.Number),
+  }),
+  output: Schema.Void,
+});
+
+export const DropAxisOutput = Schema.Struct({
+  axis: Axis.annotations({ description: 'The axis type (row or col).' }),
+  axisIndex: Schema.String.annotations({ description: 'The dropped axis index.' }),
+  index: Schema.Number.annotations({ description: 'The position the axis was at.' }),
+  axisMeta: Schema.Any.annotations({ description: 'The row/column metadata.' }),
+  values: Schema.Array(Schema.Any).annotations({ description: 'The cell values that were dropped.' }),
+});
+
+export type DropAxisOutput = Schema.Schema.Type<typeof DropAxisOutput>;
+
+export const DropAxis = Operation.make({
+  meta: { key: `${SHEET_OPERATION}.axis-drop`, name: 'Drop Axis' },
+  input: Schema.Struct({
+    model: Schema.Any,
+    axis: Axis,
+    axisIndex: Schema.String,
+  }),
+  output: DropAxisOutput,
+});
+
+export const ScrollToAnchor = Operation.make({
+  meta: { key: `${SHEET_OPERATION}.scroll-to-anchor`, name: 'Scroll To Anchor' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    subject: Schema.String.annotations({ description: 'Attendable ID of the sheet.' }),
+    cursor: Schema.String.annotations({ description: 'Cell range coordinates.' }),
+    ref: Schema.optional(Schema.Any.annotations({ description: 'Active refs for highlighting.' })),
+  }),
+  output: Schema.Void,
+});
+
+/**
+ * Restore a dropped axis (inverse of DropAxis).
+ */
+export const RestoreAxis = Operation.make({
+  meta: { key: `${SHEET_OPERATION}.restore-axis`, name: 'Restore Axis' },
+  input: Schema.Struct({
+    model: Schema.Any.annotations({ description: 'The sheet model.' }),
+    axis: Axis.annotations({ description: 'The axis type (row or col).' }),
+    axisIndex: Schema.String.annotations({ description: 'The axis index to restore.' }),
+    index: Schema.Number.annotations({ description: 'The position to restore at.' }),
+    axisMeta: Schema.Any.annotations({ description: 'The row/column metadata.' }),
+    values: Schema.Array(Schema.Any).annotations({ description: 'The cell values to restore.' }),
+  }),
+  output: Schema.Void,
+});

package/src/operations/drop-axis.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { DropAxis } from './definitions';
+
+const handler: Operation.WithHandler<typeof DropAxis> = DropAxis.pipe(
+  Operation.withHandler(({ model, axis, axisIndex }) =>
+    Effect.sync(() => {
+      const undoData = model[axis === 'col' ? 'dropColumn' : 'dropRow'](axisIndex);
+      return {
+        axis: undoData.axis,
+        axisIndex: undoData.axisIndex,
+        index: undoData.index,
+        axisMeta: undoData.axisMeta,
+        values: undoData.values,
+      };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export * as SheetOperation from './definitions';
+
+export const SheetOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./drop-axis'),
+  () => import('./insert-axis'),
+  () => import('./restore-axis'),
+  () => import('./scroll-to-anchor'),
+);

package/src/operations/insert-axis.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { InsertAxis } from './definitions';
+
+const handler: Operation.WithHandler<typeof InsertAxis> = InsertAxis.pipe(
+  Operation.withHandler(({ model, axis, index, count }) =>
+    Effect.sync(() => {
+      model[axis === 'col' ? 'insertColumns' : 'insertRows'](index, count);
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/restore-axis.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { RestoreAxis } from './definitions';
+
+const handler: Operation.WithHandler<typeof RestoreAxis> = RestoreAxis.pipe(
+  Operation.withHandler(({ model, axis, ...restoreData }) =>
+    Effect.sync(() => {
+      model[axis === 'col' ? 'restoreColumn' : 'restoreRow'](restoreData);
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/scroll-to-anchor.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { parseThreadAnchorAsCellRange } from '../integrations/thread-ranges';
+import { SheetCapabilities } from '../types';
+import { ScrollToAnchor } from './definitions';
+
+const handler: Operation.WithHandler<typeof ScrollToAnchor> = ScrollToAnchor.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ subject, cursor, ref }) {
+      const gridInstances = yield* Capability.get(SheetCapabilities.GridInstances);
+      const entry = gridInstances.get(subject);
+      if (!entry) {
+        return;
+      }
+      entry.setActiveRefs(ref);
+      const range = parseThreadAnchorAsCellRange(cursor);
+      if (range) {
+        entry.grid.setFocus({ ...range.to, plane: 'grid' }, true);
+      }
+    }),
+  ),
+);
+
+export default handler;

package/src/playwright/playwright.config.ts

@@ -10,7 +10,7 @@ export default defineConfig({
   ...e2ePreset(import.meta.dirname),
   // TODO(wittjosiah): Avoid hard-coding ports.
   webServer: {
-    command: 'moon run storybook-react:serve-e2e -- --port=9005',
+    command: 'pnpm storybook dev --ci --quiet --port=9005 --config-dir=.storybook',
     port: 9005,
     reuseExistingServer: false,
   },

package/src/playwright/sheet.spec.ts

@@ -4,7 +4,7 @@
 
 import { type Page, expect, test } from '@playwright/test';
 
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { setupPage, storybookUrl } from '@dxos/test-utils/playwright';
 
 import { SheetManager } from './sheet-manager';
@@ -15,7 +15,7 @@ test.describe('plugin-sheet', () => {
 
   test.beforeEach(async ({ browser }) => {
     const setup = await setupPage(browser, {
-      url: storybookUrl('plugins-plugin-sheet-sheetcontainer--spec', 9005),
+      url: storybookUrl('plugins-plugin-sheet-containers-sheetcontainer--spec', 9005),
       viewportSize: { width: 1280, height: 720 },
     });
     page = setup.page;
@@ -39,7 +39,7 @@ test.describe('plugin-sheet', () => {
     // Confirm editor displays
     await expect(sheet.cellEditor()).toBeVisible();
     // Type in a value and press enter
-    const testString = faker.string.uuid();
+    const testString = random.string.uuid();
     await sheet.setFocusedCellValue(testString, 'Enter');
     // Expect that value to now show in the grid
     await expect(sheet.cellByText(testString)).toBeVisible();