@dxos/plugin-sheet 0.8.4-main.f9ba587 → 0.8.4-staging.60fe92afc8

package/src/containers/SheetArticle/SheetArticle.tsx

@@ -0,0 +1,57 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type ComputeGraphRegistry } from '@dxos/compute-hyperformula';
+import { type Space } from '@dxos/react-client/echo';
+import { Panel } from '@dxos/react-ui';
+
+import { ComputeGraphContextProvider, Sheet, useComputeGraph } from '#components';
+import { type Sheet as SheetType } from '#types';
+
+export type SheetArticleProps = AppSurface.ObjectArticleProps<
+  SheetType.Sheet,
+  {
+    space: Space;
+    registry: ComputeGraphRegistry;
+    ignoreAttention?: boolean;
+  }
+>;
+
+export const SheetArticle = ({ registry, ...props }: SheetArticleProps) => (
+  <ComputeGraphContextProvider registry={registry}>
+    <SheetArticleInner {...props} />
+  </ComputeGraphContextProvider>
+);
+
+const SheetArticleInner = ({
+  role,
+  subject: sheet,
+  attendableId,
+  space,
+  ignoreAttention,
+}: Omit<SheetArticleProps, 'registry'>) => {
+  const graph = useComputeGraph(space);
+  if (!graph) {
+    return null;
+  }
+
+  return (
+    <Sheet.Root graph={graph} sheet={sheet} attendableId={attendableId!} ignoreAttention={ignoreAttention}>
+      <Panel.Root classNames={role === 'section' && 'aspect-aquare'}>
+        <Panel.Toolbar asChild>
+          <Sheet.Toolbar />
+        </Panel.Toolbar>
+        <Panel.Content asChild>
+          <Sheet.Content />
+        </Panel.Content>
+        <Panel.Statusbar asChild>
+          <Sheet.Statusbar />
+        </Panel.Statusbar>
+      </Panel.Root>
+    </Sheet.Root>
+  );
+};

package/src/containers/SheetArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export { SheetArticle as default } from './SheetArticle';

package/src/containers/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const RangeList: ComponentType<any> = lazy(() => import('./RangeList'));
+export const SheetArticle: ComponentType<any> = lazy(() => import('./SheetArticle'));

package/src/extensions/compute.stories.tsx

@@ -2,31 +2,32 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
-
-import { type Meta } from '@storybook/react-vite';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useEffect, useMemo } from 'react';
 
+import { ProcessManagerPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
 import { PublicKey } from '@dxos/keys';
-import { useSpace } from '@dxos/react-client/echo';
+import { useSpaces } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { useThemeContext } from '@dxos/react-ui';
+import { useTextEditor } from '@dxos/react-ui-editor';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
 import {
   createBasicExtensions,
   createMarkdownExtensions,
   createThemeExtensions,
   decorateMarkdown,
   documentId,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
-import { withTheme, withLayout } from '@dxos/storybook-utils';
+} from '@dxos/ui-editor';
 import { isNonNullable } from '@dxos/util';
 
-import { compute, computeGraphFacet } from './compute';
-import { GridSheet, SheetProvider, useComputeGraph } from '../components';
+import { Sheet, useComputeGraph } from '#components';
+import { useTestSheet, withComputeGraphDecorator } from '#testing';
+import { Sheet as SheetType } from '#types';
+
 import { useSheetModel } from '../model';
-import { useTestSheet, withComputeGraphDecorator } from '../testing';
-import { SheetType } from '../types';
+import { compute, computeGraphFacet } from './compute';
 
 const str = (...lines: string[]) => lines.join('\n');
 
@@ -41,17 +42,17 @@ type EditorProps = {
 
 const SHEET_NAME = 'Test Sheet';
 
-const EditorStory = ({ text }: EditorProps) => {
+const DefaultStory = ({ text }: EditorProps) => {
   const id = useMemo(() => PublicKey.random(), []);
   const { themeMode } = useThemeContext();
-  const space = useSpace();
+  const [space] = useSpaces();
   const computeGraph = useComputeGraph(space);
   const { parentRef, focusAttributes } = useTextEditor(
     () => ({
       initialValue: text,
       extensions: [
         createBasicExtensions(),
-        createMarkdownExtensions({ themeMode }),
+        createMarkdownExtensions(),
         createThemeExtensions({ themeMode, syntaxHighlighting: true }),
         documentId.of(id.toHex()),
         computeGraph && computeGraphFacet.of(computeGraph),
@@ -66,13 +67,18 @@ const EditorStory = ({ text }: EditorProps) => {
 };
 
 const Grid = () => {
-  const space = useSpace();
+  const [space] = useSpaces();
   const graph = useComputeGraph(space);
   const sheet = useTestSheet(space, graph, { name: SHEET_NAME });
   const model = useSheetModel(graph, sheet);
   useEffect(() => {
     if (model) {
-      model.setValues({ A1: { value: 100 }, A2: { value: 200 }, A3: { value: 300 }, A5: { value: '=SUM(A1:A3)' } });
+      model.setValues({
+        A1: { value: 100 },
+        A2: { value: 200 },
+        A3: { value: 300 },
+        A5: { value: '=SUM(A1:A3)' },
+      });
     }
   }, [model]);
 
@@ -82,9 +88,9 @@ const Grid = () => {
 
   return (
     <div className='flex w-[40rem] overflow-hidden'>
-      <SheetProvider graph={graph} sheet={sheet}>
-        <GridSheet />
-      </SheetProvider>
+      <Sheet.Root graph={graph} sheet={sheet} attendableId='test'>
+        <Sheet.Content />
+      </Sheet.Root>
     </div>
   );
 };
@@ -92,15 +98,36 @@ const Grid = () => {
 const GraphStory = (props: EditorProps) => {
   return (
     <div className='grid grid-rows-2'>
-      <EditorStory {...props} />
+      <DefaultStory {...props} />
       <Grid />
     </div>
   );
 };
 
+const meta = {
+  title: 'plugins/plugin-sheet/extensions/compute',
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withClientProvider({
+      types: [SheetType.Sheet],
+      createIdentity: true,
+      createSpace: true,
+    }),
+    // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
+    withPluginManager({ plugins: [ProcessManagerPlugin()] }),
+    withComputeGraphDecorator(),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta;
+
+export default meta;
+
 // TODO(burdon): Inline formulae.
-export const Default = {
-  render: EditorStory,
+export const Default: StoryObj<typeof DefaultStory> = {
+  render: DefaultStory,
   args: {
     text: str(
       //
@@ -123,7 +150,7 @@ export const Default = {
   },
 };
 
-export const Graph = {
+export const Graph: StoryObj<typeof GraphStory> = {
   render: GraphStory,
   args: {
     text: str(
@@ -140,16 +167,3 @@ export const Graph = {
     ),
   },
 };
-
-const meta: Meta = {
-  title: 'plugins/plugin-sheet/extensions',
-  decorators: [
-    withClientProvider({ types: [SheetType], createIdentity: true, createSpace: true }),
-    withComputeGraphDecorator(),
-    withTheme,
-    withLayout({ fullscreen: true, classNames: 'justify-center' }),
-  ],
-  parameters: { layout: 'fullscreen' },
-};
-
-export default meta;

package/src/extensions/compute.ts

@@ -16,14 +16,14 @@ import { Decoration, EditorView, ViewPlugin, WidgetType } from '@codemirror/view
 
 import { type CleanupFn, debounce } from '@dxos/async';
 import {
-  createSheetName,
   type CellAddress,
   type CellScalarValue,
   type ComputeGraph,
   type ComputeNode,
-} from '@dxos/compute';
+  createSheetName,
+} from '@dxos/compute-hyperformula';
 import { invariant } from '@dxos/invariant';
-import { documentId, singleValueFacet } from '@dxos/react-ui-editor';
+import { documentId, singleValueFacet } from '@dxos/ui-editor';
 
 const LANGUAGE_TAG = 'dx';
 
@@ -34,7 +34,7 @@ export const computeGraphFacet = singleValueFacet<ComputeGraph>();
 
 export type ComputeOptions = {};
 
-export const compute = (options: ComputeOptions = {}): Extension => {
+export const compute = (_options: ComputeOptions = {}): Extension => {
   let computeNode: ComputeNode | undefined;
 
   const update = (state: EditorState, current?: RangeSet<Decoration>) => {
@@ -53,7 +53,6 @@ export const compute = (options: ComputeOptions = {}): Extension => {
                   const text = node.node.getChild('CodeText');
                   if (type === LANGUAGE_TAG && text) {
                     const formula = state.sliceDoc(text.from, text.to);
-
                     const iter = current?.iter(node.node.from);
                     if (iter?.value && iter?.value.spec.formula === formula) {
                       // Add existing widget.

package/src/extensions/editor/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './extension';
+export * from './sheet-extension';

package/src/extensions/editor/{extension.test.ts → sheet-extension.test.ts}

@@ -8,9 +8,9 @@ import { testTree } from '@lezer/generator/test';
 import { spreadsheet } from 'codemirror-lang-spreadsheet';
 import { describe, expect, test } from 'vitest';
 
-import { defaultFunctions } from '@dxos/compute';
+import { defaultFunctions } from '@dxos/compute-hyperformula';
 
-import { sheetExtension } from './extension';
+import { sheetExtension } from './sheet-extension';
 
 describe('formula parser', () => {
   const {

package/src/extensions/editor/{extension.ts → sheet-extension.ts}

@@ -18,10 +18,10 @@ 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 { singleValueFacet } from '@dxos/react-ui-editor';
-import { mx } from '@dxos/react-ui-theme';
+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';
 
 /**
  * https://codemirror.net/examples/styling
@@ -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',
   },
 ]);
 
@@ -75,7 +75,10 @@ export type SheetExtensionOptions = {
  * https://hyperformula.handsontable.com/guide/key-concepts.html#grammar
  */
 export const sheetExtension = ({ debug, functions = [] }: SheetExtensionOptions): Extension => {
-  const { extension, language } = spreadsheet({ idiom: 'en-US', decimalSeparator: '.' });
+  const { extension, language } = spreadsheet({
+    idiom: 'en-US',
+    decimalSeparator: '.',
+  });
 
   const createCompletion = (name: string) => {
     const { section = 'Custom', description, syntax } = functions.find((value) => value.name === name) ?? {};
@@ -94,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) {
@@ -107,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);
         }
 
@@ -166,8 +169,8 @@ export const sheetExtension = ({ debug, functions = [] }: SheetExtensionOptions)
       icons: false,
       tooltipClass: () =>
         mx(
-          '!-left-[1px] !top-[33px] !-m-0 border !border-t-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-bg',
           'border-separator',
         ),
     }),

package/src/index.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export { SheetCapabilities } from './capabilities';
 export * from './meta';
-export * from './SheetPlugin';
+export * from './operations';
+export * from './paths';
+export * from './types';

package/src/integrations/thread-ranges.ts

@@ -2,28 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema, pipe } from 'effect';
 import { useCallback, useEffect, useMemo } from 'react';
 
-import {
-  createIntent,
-  createResolver,
-  LayoutAction,
-  useIntentResolver,
-  useIntentDispatcher,
-  chain,
-} 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, fullyQualifiedId, getSpace, Query, useQuery } from '@dxos/react-client/echo';
-import { type DxGridElement, type DxGridPosition, 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 { CommentOperation } from '@dxos/plugin-comments/types';
+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 { SHEET_PLUGIN } 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}`;
@@ -42,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(SHEET_PLUGIN, 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) => {
@@ -90,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 {
@@ -99,25 +57,26 @@ export const useSelectThreadOnCellFocus = () => {
       });
 
       if (closestThread) {
-        const primary = fullyQualifiedId(model.sheet);
-        const intent = pipe(
-          createIntent(ThreadAction.Select, { current: fullyQualifiedId(closestThread) }),
-          chain(DeckAction.ChangeCompanion, { primary, companion: `${primary}${ATTENDABLE_PATH_SEPARATOR}comments` }),
-        );
-        void dispatch(intent);
+        void (async () => {
+          await invokePromise(CommentOperation.Select, { current: Relation.getURI(closestThread) });
+          await invokePromise(LayoutOperation.UpdateCompanion, {
+            subject: linkedSegment('comments'),
+          });
+        })();
       }
     },
-    [dispatch, anchors],
+    [invokePromise, anchors],
   );
 
   const debounced = useMemo(() => {
-    return debounce((cellCoords: DxGridPosition) => requestAnimationFrame(() => selectClosestThread(cellCoords)), 50);
+    return debounce((cellCoords: CellAddress) => requestAnimationFrame(() => selectClosestThread(cellCoords)), 50);
   }, [selectClosestThread]);
 
   useEffect(() => {
     if (!cursor) {
       return;
     }
+
     debounced(cursor);
   }, [cursor, debounced]);
 };

package/src/meta.ts

@@ -2,16 +2,30 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { DXN } from '@dxos/keys';
+import { trim } from '@dxos/util';
 
-export const SHEET_PLUGIN = 'dxos.org/plugin/sheet';
-
-export const meta: PluginMeta = {
-  id: SHEET_PLUGIN,
+export const meta = Plugin.makeMeta({
+  key: DXN.make('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. ',
+  author: 'DXOS',
+  description: trim`
+    Full-featured spreadsheet for DXOS Composer backed by ECHO for local-first, real-time collaborative editing.
+    Cells, row/column metadata, and range-based formatting are all stored as ECHO objects and replicated to peers instantly.
+
+    Formula evaluation is powered by HyperFormula, providing over 400 built-in functions covering arithmetic, statistics,
+    text manipulation, date/time, financial, and logical operations. Formulas are stored with internal cell indices and
+    translated to A1-notation on display, keeping references stable across row and column insertions.
+
+    The plugin integrates with plugin-markdown to expose formula results inside document fenced code blocks, and
+    contributes anchor-navigation support so other plugins can scroll and highlight specific cell ranges by DXN reference.
+    AI agents can invoke sheet operations — insert/drop axes, scroll to anchor, and read or write cell values — through
+    the standard operations framework.
+  `,
   icon: 'ph--grid-nine--regular',
+  iconHue: 'indigo',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-sheet',
+  spec: 'PLUGIN.mdl',
   screenshots: ['https://dxos.network/plugin-details-sheet-dark.png'],
-};
+});

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

@@ -5,19 +5,20 @@
 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 { Sheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '#types';
+
 import { SheetModel } from './sheet-model';
 import { createTestGrid } from './testing';
-import { createSheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '../types';
 
 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 () => {
@@ -30,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());
@@ -59,6 +60,34 @@ describe('SheetModel', () => {
     expect(graph.context.info.invocations.TEST).to.eq(1);
   });
 
+  test('drop row shifts values and updates sum', async () => {
+    const space = await testBuilder.client.spaces.create();
+    const graph = testBuilder.registry.createGraph(space);
+    await graph.open();
+
+    const sheet = Sheet.make({ rows: 10, columns: 5 });
+    const model = new SheetModel(graph, sheet);
+    await model.open();
+    onTestFinished(() => void model.close());
+
+    // Column A: rows 0..2 = 123, 789, 567; row 3 = SUM(A0:A2).
+    model.setValue({ col: 0, row: 0 }, 123);
+    model.setValue({ col: 0, row: 1 }, 789);
+    model.setValue({ col: 0, row: 2 }, 567);
+    model.setValue({ col: 0, row: 3 }, '=SUM(A1:A3)');
+
+    expect(model.getValue({ col: 0, row: 3 })).to.eq(123 + 789 + 567);
+
+    // Delete the middle row (789).
+    const rowId = sheet.rows[1];
+    model.dropRow(rowId);
+
+    // Values shift up: row 1 = 567, row 2 = SUM(123 + 567).
+    expect(model.getValue({ col: 0, row: 0 })).to.eq(123);
+    expect(model.getValue({ col: 0, row: 1 })).to.eq(567);
+    expect(model.getValue({ col: 0, row: 2 })).to.eq(123 + 567);
+  });
+
   test('formula', async () => {
     const space = await testBuilder.client.spaces.create();
     const graph = testBuilder.registry.createGraph(space);