@dxos/plugin-sheet 0.8.4-main.406dc2a → 0.8.4-main.4f23b4e393

package/src/integrations/thread-ranges.ts

@@ -2,29 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
 import { useCallback, useEffect, useMemo } from 'react';
 
-import {
-  LayoutAction,
-  chain,
-  createIntent,
-  createResolver,
-  useIntentDispatcher,
-  useIntentResolver,
-} from '@dxos/app-framework';
+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 { Obj, Relation } from '@dxos/echo';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { ThreadAction, ThreadType } from '@dxos/plugin-thread/types';
-import { Filter, Query, fullyQualifiedId, getSpace, useQuery } from '@dxos/react-client/echo';
-import { type DxGridElement, type GridContentProps } from '@dxos/react-ui-grid';
-import { AnchoredTo } from '@dxos/schema';
+import { type CellAddress, type CompleteCellRange, inRange } from '@dxos/compute-hyperformula';
+import { Filter, Obj, Query, Relation } from '@dxos/echo';
+import { ThreadOperation } from '@dxos/plugin-thread';
+import { useQuery } from '@dxos/react-client/echo';
+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}`;
@@ -43,45 +33,12 @@ export const parseThreadAnchorAsCellRange = (cursor: string): CompleteCellRange
   }
 };
 
-export const useUpdateFocusedCellOnThreadSelection = (grid: DxGridElement | null) => {
-  const { model, setActiveRefs } = useSheetContext();
-  const scrollIntoViewResolver = useMemo(
-    () =>
-      createResolver({
-        intent: LayoutAction.ScrollIntoView,
-        position: 'hoist',
-        filter: (
-          data,
-        ): data is {
-          part: 'current';
-          subject: string;
-          options: { cursor: string; ref: GridContentProps['activeRefs'] };
-        } => {
-          if (!Schema.is(LayoutAction.ScrollIntoView.fields.input)(data)) {
-            return false;
-          }
-
-          return data.subject === fullyQualifiedId(model.sheet) && !!data.options?.cursor;
-        },
-        resolve: ({ options: { cursor, ref } }) => {
-          setActiveRefs(ref);
-          // 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);
-        },
-      }),
-    [model.sheet, setActiveRefs],
-  );
-
-  useIntentResolver(meta.id, scrollIntoViewResolver);
-};
-
 export const useSelectThreadOnCellFocus = () => {
   const { model, cursor } = useSheetContext();
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
 
-  const space = getSpace(model.sheet);
-  const anchors = useQuery(space, Query.select(Filter.ids(model.sheet.id)).targetOf(AnchoredTo));
+  const db = Obj.getDatabase(model.sheet);
+  const anchors = useQuery(db, Query.select(Filter.id(model.sheet.id)).targetOf(AnchoredTo.AnchoredTo));
 
   const selectClosestThread = useCallback(
     (cellAddress: CellAddress) => {
@@ -91,7 +48,7 @@ export const useSelectThreadOnCellFocus = () => {
 
       const closestThread = anchors.find((anchor) => {
         const source = Relation.getSource(anchor);
-        if (anchor.anchor && Obj.instanceOf(ThreadType, source)) {
+        if (anchor.anchor && Obj.instanceOf(Thread.Thread, source)) {
           const range = parseThreadAnchorAsCellRange(anchor.anchor);
           return range ? inRange(range, cellAddress) : false;
         } else {
@@ -100,15 +57,15 @@ export const useSelectThreadOnCellFocus = () => {
       });
 
       if (closestThread) {
-        const primary = fullyQualifiedId(model.sheet);
-        const intent = Function.pipe(
-          createIntent(ThreadAction.Select, { current: fullyQualifiedId(closestThread) }),
-          chain(DeckAction.ChangeCompanion, { primary, companion: `${primary}${ATTENDABLE_PATH_SEPARATOR}comments` }),
-        );
-        void dispatch(intent);
+        void (async () => {
+          await invokePromise(ThreadOperation.Select, { current: Relation.getDXN(closestThread).toString() });
+          await invokePromise(LayoutOperation.UpdateCompanion, {
+            subject: linkedSegment('comments'),
+          });
+        })();
       }
     },
-    [dispatch, anchors],
+    [invokePromise, anchors],
   );
 
   const debounced = useMemo(() => {

package/src/meta.ts

@@ -2,14 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
-  id: 'dxos.org/plugin/sheet',
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.plugin.sheet',
   name: 'Sheet',
-  description:
-    'Sheets in Composer are simple spreadsheets which allow you to leverage custom functions inside of cell grids. Leverage more than 400 pre-built formulas like Sum, Average, Count, Max, Min along with many others. You can also deploy your own custom functions using the Scripts plugin. ',
+  description: trim`
+    Full-featured spreadsheet application with over 400 built-in formulas for calculations and data analysis.
+    Create custom JavaScript functions and integrate with AI agents for advanced automation.
+  `,
   icon: 'ph--grid-nine--regular',
+  iconHue: 'indigo',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-sheet',
   screenshots: ['https://dxos.network/plugin-details-sheet-dark.png'],
 };

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 { FunctionType } 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 { createSheet, 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: [FunctionType], plugins: testFunctionPlugins });
+    testBuilder = new TestBuilder({ types: [Operation.PersistentOperation], plugins: testFunctionPlugins });
     await testBuilder.open();
   });
   afterEach(async () => {
@@ -31,7 +31,7 @@ describe('SheetModel', () => {
     await graph.open();
 
     // TODO(burdon): Create via factory.
-    const sheet = createSheet({ rows: 5, columns: 5 });
+    const sheet = Sheet.make({ rows: 5, columns: 5 });
     const model = new SheetModel(graph, sheet);
     await model.open();
     testBuilder.ctx.onDispose(() => model.close());

package/src/model/sheet-model.ts

@@ -20,10 +20,10 @@ import {
   addressToA1Notation,
   createSheetName,
   isFormula,
-} from '@dxos/compute';
+} from '@dxos/compute-hyperformula';
 import { Resource } from '@dxos/context';
 import { Obj } from '@dxos/echo';
-import { FormatEnum, TypeEnum } from '@dxos/echo/internal';
+import { Format, TypeEnum } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -38,22 +38,22 @@ import {
   insertIndices,
   mapFormulaIndicesToRefs,
   mapFormulaRefsToIndices,
-} from '../types';
-import { type CellValue, type SheetAction, type SheetType } from '../types';
+} from '#types';
+import { type Sheet, type SheetAction } from '#types';
 
 // TODO(burdon): Move to compute.
 // Map sheet types to system types.
 // https://hyperformula.handsontable.com/guide/types-of-values.html
 //  - https://github.com/handsontable/hyperformula/blob/master/src/Cell.ts (CellValueType)
 //  - https://github.com/handsontable/hyperformula/blob/master/src/interpreter/InterpreterValue.ts (NumberType)
-const typeMap: Record<string, { type: TypeEnum; format?: FormatEnum }> = {
+const typeMap: Record<string, { type: TypeEnum; format?: Format.TypeFormat }> = {
   BOOLEAN: { type: TypeEnum.Boolean },
   NUMBER_RAW: { type: TypeEnum.Number },
-  NUMBER_PERCENT: { type: TypeEnum.Number, format: FormatEnum.Percent },
-  NUMBER_CURRENCY: { type: TypeEnum.Number, format: FormatEnum.Currency },
-  NUMBER_DATETIME: { type: TypeEnum.String, format: FormatEnum.DateTime },
-  NUMBER_DATE: { type: TypeEnum.String, format: FormatEnum.Date },
-  NUMBER_TIME: { type: TypeEnum.String, format: FormatEnum.Time },
+  NUMBER_PERCENT: { type: TypeEnum.Number, format: Format.TypeFormat.Percent },
+  NUMBER_CURRENCY: { type: TypeEnum.Number, format: Format.TypeFormat.Currency },
+  NUMBER_DATETIME: { type: TypeEnum.String, format: Format.TypeFormat.DateTime },
+  NUMBER_DATE: { type: TypeEnum.String, format: Format.TypeFormat.Date },
+  NUMBER_TIME: { type: TypeEnum.String, format: Format.TypeFormat.Time },
 };
 
 const getTopLeft = (range: CellRange): CellAddress => {
@@ -92,7 +92,7 @@ export class SheetModel extends Resource {
 
   constructor(
     private readonly _graph: ComputeGraph,
-    private readonly _sheet: SheetType,
+    private readonly _sheet: Sheet.Sheet,
     private readonly _options: SheetModelOptions = {},
   ) {
     super();
@@ -122,7 +122,9 @@ export class SheetModel extends Resource {
    */
   protected override async _open(): Promise<void> {
     log('initialize', { id: this.id });
-    initialize(this._sheet);
+    Obj.update(this._sheet, (obj) => {
+      initialize(obj);
+    });
 
     this._graph.update.on((event) => {
       if (event.type === 'functionsUpdated') {
@@ -181,13 +183,19 @@ export class SheetModel extends Resource {
   }
 
   insertRows(i: number, n = 1): string[] {
-    const idx = insertIndices(this._sheet.rows, i, n, MAX_ROWS);
+    let idx: string[] = [];
+    Obj.update(this._sheet, (obj) => {
+      idx = insertIndices(obj.rows, i, n, MAX_ROWS);
+    });
     this.reset();
     return idx;
   }
 
   insertColumns(i: number, n = 1): string[] {
-    const idx = insertIndices(this._sheet.columns, i, n, MAX_COLS);
+    let idx: string[] = [];
+    Obj.update(this._sheet, (obj) => {
+      idx = insertIndices(obj.columns, i, n, MAX_COLS);
+    });
     this.reset();
     return idx;
   }
@@ -200,8 +208,10 @@ export class SheetModel extends Resource {
     const values = this.getCellValues(range).flat();
     const index = this._sheet.rows.indexOf(rowIndex);
     this.clear(range);
-    this._sheet.rows.splice(index, 1);
-    delete this._sheet.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 };
   }
@@ -214,35 +224,43 @@ export class SheetModel extends Resource {
     const values = this.getCellValues(range).flat();
     const index = this._sheet.columns.indexOf(colIndex);
     this.clear(range);
-    this._sheet.columns.splice(index, 1);
-    delete this._sheet.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 {
-    this._sheet.rows.splice(index, 0, axisIndex);
-    values.forEach((value, col) => {
-      if (value) {
-        this._sheet.cells[`${this._sheet.columns[col]}@${axisIndex}`] = { value };
+    Obj.update(this._sheet, (obj) => {
+      obj.rows.splice(index, 0, axisIndex);
+      values.forEach((value, col) => {
+        if (value) {
+          obj.cells[`${obj.columns[col]}@${axisIndex}`] = { value };
+        }
+      });
+
+      if (axisMeta) {
+        obj.rowMeta[axisIndex] = axisMeta;
       }
     });
-    if (axisMeta) {
-      this._sheet.rowMeta[axisIndex] = axisMeta;
-    }
     this.reset();
   }
 
   restoreColumn({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis): void {
-    this._sheet.columns.splice(index, 0, axisIndex);
-    values.forEach((value, row) => {
-      if (value) {
-        this._sheet.cells[`${axisIndex}@${this._sheet.rows[row]}`] = { value };
+    Obj.update(this._sheet, (obj) => {
+      obj.columns.splice(index, 0, axisIndex);
+      values.forEach((value, row) => {
+        if (value) {
+          obj.cells[`${axisIndex}@${obj.rows[row]}`] = { value };
+        }
+      });
+
+      if (axisMeta) {
+        obj.columnMeta[axisIndex] = axisMeta;
       }
     });
-    if (axisMeta) {
-      this._sheet.columnMeta[axisIndex] = axisMeta;
-    }
     this.reset();
   }
 
@@ -259,18 +277,22 @@ 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);
-    this._iterRange(range, (cell) => {
-      const idx = addressToIndex(this._sheet, cell);
-      delete this._sheet.cells[idx];
+    Obj.update(this._sheet, (obj) => {
+      this._iterRange(range, (cell) => {
+        const idx = addressToIndex(this._sheet, cell);
+        delete obj.cells[idx];
+      });
     });
   }
 
   cut(range: CellRange): void {
     invariant(this._node);
     this._node.graph.hf.cut(toModelRange(this._node.sheetId, range));
-    this._iterRange(range, (cell) => {
-      const idx = addressToIndex(this._sheet, cell);
-      delete this._sheet.cells[idx];
+    Obj.update(this._sheet, (obj) => {
+      this._iterRange(range, (cell) => {
+        const idx = addressToIndex(this._sheet, cell);
+        delete obj.cells[idx];
+      });
     });
   }
 
@@ -283,13 +305,15 @@ 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));
-      for (const change of changes) {
-        if (change instanceof ExportedCellChange) {
-          const { address, newValue } = change;
-          const idx = addressToIndex(this._sheet, { row: address.row, col: address.col });
-          this._sheet.cells[idx] = { value: newValue };
+      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 });
+            obj.cells[idx] = { value: newValue };
+          }
         }
-      }
+      });
     }
   }
 
@@ -361,7 +385,7 @@ export class SheetModel extends Resource {
   /**
    * Get value type.
    */
-  getValueDescription(cell: CellAddress): { type: TypeEnum; format?: FormatEnum } | undefined {
+  getValueDescription(cell: CellAddress): { type: TypeEnum; format?: Format.TypeFormat } | undefined {
     invariant(this._node);
     const addr = toSimpleCellAddress(this._node.sheetId, cell);
     const type = this._node.graph.hf.getCellValueDetailedType(addr);
@@ -380,11 +404,15 @@ export class SheetModel extends Resource {
     // Reallocate if > current bounds.
     let refresh = false;
     if (cell.row >= this._sheet.rows.length) {
-      insertIndices(this._sheet.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) {
-      insertIndices(this._sheet.columns, cell.col, 1, MAX_COLS);
+      Obj.update(this._sheet, (obj) => {
+        insertIndices(obj.columns, cell.col, 1, MAX_COLS);
+      });
       refresh = true;
     }
 
@@ -401,20 +429,24 @@ export class SheetModel extends Resource {
     // Insert into sheet.
     const idx = addressToIndex(this._sheet, cell);
     if (value === undefined || value === null) {
-      delete this._sheet.cells[idx];
+      Obj.update(this._sheet, (obj) => {
+        delete obj.cells[idx];
+      });
     } else {
       if (isFormula(value)) {
         value = this._graph.mapFunctionBindingToId(mapFormulaRefsToIndices(this._sheet, value));
       }
 
-      this._sheet.cells[idx] = { value };
+      Obj.update(this._sheet, (obj) => {
+        obj.cells[idx] = { value };
+      });
     }
   }
 
   /**
    * Sets values from a simple map.
    */
-  setValues(values: Record<string, CellValue>): void {
+  setValues(values: Record<string, Sheet.CellValue>): void {
     Object.entries(values).forEach(([key, { value }]) => {
       this.setValue(addressFromA1Notation(key), value);
     });

package/src/model/testing.ts

@@ -2,16 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { addressToA1Notation } from '@dxos/compute';
+import { addressToA1Notation } from '@dxos/compute-hyperformula';
 
-import { type CellValue, type SheetType, createSheet } from '../types';
+import { Sheet } from '#types';
 
 // TODO(burdon): Create testing endpoint.
 // TODO(burdon): Move to react-ui-sheet.
-export const createTestGrid = ({ cols = 4, rows = 10 }: { cols: number; rows: number }): SheetType => {
+export const createTestGrid = ({ cols = 4, rows = 10 }: { cols: number; rows: number }): Sheet.Sheet => {
   const year = new Date().getFullYear();
 
-  const cells: Record<string, CellValue> = {};
+  const cells: Record<string, Sheet.CellValue> = {};
   for (let col = 1; col <= cols; col++) {
     for (let row = 1; row <= 10; row++) {
       const cell = addressToA1Notation({ col, row });
@@ -27,7 +27,7 @@ export const createTestGrid = ({ cols = 4, rows = 10 }: { cols: number; rows: nu
     }
   }
 
-  const sheet = createSheet({
+  const sheet = Sheet.make({
     name: 'Test',
     cells,
   });

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 SheetType } from '../types';
 
 export type UseSheetModelOptions = {
   readonly?: boolean;
@@ -15,7 +16,7 @@ export type UseSheetModelOptions = {
 
 export const useSheetModel = (
   graph?: ComputeGraph,
-  sheet?: SheetType,
+  sheet?: Sheet.Sheet,
   { readonly }: UseSheetModelOptions = {},
 ): SheetModel | undefined => {
   const [model, setModel] = useState<SheetModel>();

package/src/operations/drop-axis.ts

@@ -0,0 +1,26 @@
+//
+
+import * as Effect from 'effect/Effect';
+// Copyright 2025 DXOS.org
+//
+
+import { Operation } from '@dxos/compute';
+
+import { SheetOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof SheetOperation.DropAxis> = SheetOperation.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,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+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 @@
+//
+
+import * as Effect from 'effect/Effect';
+// Copyright 2025 DXOS.org
+//
+
+import { Operation } from '@dxos/compute';
+
+import { SheetOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof SheetOperation.InsertAxis> = SheetOperation.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 @@
+//
+
+import * as Effect from 'effect/Effect';
+// Copyright 2025 DXOS.org
+//
+
+import { Operation } from '@dxos/compute';
+
+import { SheetOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof SheetOperation.RestoreAxis> = SheetOperation.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,30 @@
+//
+// 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, SheetOperation } from '../types';
+
+const handler: Operation.WithHandler<typeof SheetOperation.ScrollToAnchor> = SheetOperation.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: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,8 @@ 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;
     sheet = new SheetManager(page);
@@ -38,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();

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const SheetPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { SheetOperationHandlerSet } from './operations';