@dxos/plugin-sheet 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/src/components/SheetToolbar/SheetToolbar.tsx

@@ -2,18 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import React, { type PropsWithChildren, useMemo } from 'react';
+import { Atom, type Registry, RegistryContext } from '@effect-atom/atom-react';
+import React, { type PropsWithChildren, useContext, useMemo } from 'react';
 
-import { useAppGraph } from '@dxos/app-framework';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
 import { type CompleteCellRange } from '@dxos/compute';
-import { type ThemedClassName } from '@dxos/react-ui';
 import {
   type ActionGraphProps,
   MenuProvider,
   ToolbarMenu,
   createGapSeparator,
-  rxFromSignal,
   useMenuActions,
 } from '@dxos/react-ui-menu';
 
@@ -22,23 +20,28 @@ import { useSheetContext } from '../SheetContext';
 
 import { createAlign, useAlignState } from './align';
 import { createStyle, useStyleState } from './style';
-import { type ToolbarState, useToolbarState } from './useToolbarState';
+import { type ToolbarStateAtom, useToolbarState } from './useToolbarState';
 
-//
-// Root
-//
-
-export type SheetToolbarProps = ThemedClassName<PropsWithChildren<{ id: string }>>;
+type ToolbarActionsContext = {
+  model: SheetModel;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+  customActions?: Atom.Atom<ActionGraphProps>;
+};
 
-const createToolbarActions = (
-  model: SheetModel,
-  state: ToolbarState,
-  cursorFallbackRange?: CompleteCellRange,
-  customActions?: Rx.Rx<ActionGraphProps>,
-): Rx.Rx<ActionGraphProps> => {
-  return Rx.make((get) => {
-    const align = get(rxFromSignal(() => createAlign(model, state, cursorFallbackRange)));
-    const style = get(rxFromSignal(() => createStyle(model, state, cursorFallbackRange)));
+const createToolbarActions = ({
+  model,
+  stateAtom,
+  registry,
+  cursorFallbackRange,
+  customActions,
+}: ToolbarActionsContext): Atom.Atom<ActionGraphProps> => {
+  return Atom.make((get) => {
+    const state = get(stateAtom);
+    const context = { model, state, stateAtom, registry, cursorFallbackRange };
+    const align = createAlign(context);
+    const style = createStyle(context);
     const gap = createGapSeparator();
 
     const graph: ActionGraphProps = {
@@ -56,30 +59,36 @@ const createToolbarActions = (
   });
 };
 
-export const SheetToolbar = ({ id, classNames }: SheetToolbarProps) => {
+export type SheetToolbarProps = PropsWithChildren<{ id: string }>;
+
+export const SheetToolbar = ({ id }: SheetToolbarProps) => {
   const { model, cursorFallbackRange } = useSheetContext();
-  const state = useToolbarState({});
-  useAlignState(state);
-  useStyleState(state);
+  const stateAtom = useToolbarState({});
+  const registry = useContext(RegistryContext);
+  useAlignState(stateAtom);
+  useStyleState(stateAtom);
 
   const { graph } = useAppGraph();
   const customActions = useMemo(() => {
-    return Rx.make((get) => {
+    return Atom.make((get) => {
       const actions = get(graph.actions(id));
       const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
-      return { nodes, edges: nodes.map((node) => ({ source: 'root', target: node.id })) };
+      return {
+        nodes,
+        edges: nodes.map((node) => ({ source: 'root', target: node.id })),
+      };
     });
-  }, [graph]);
+  }, [graph, id]);
 
   const actionsCreator = useMemo(
-    () => createToolbarActions(model, state, cursorFallbackRange, customActions),
-    [model, state, cursorFallbackRange, customActions],
+    () => createToolbarActions({ model, stateAtom, registry, cursorFallbackRange, customActions }),
+    [model, stateAtom, registry, cursorFallbackRange, customActions],
   );
   const menu = useMenuActions(actionsCreator);
 
   return (
     <MenuProvider {...menu} attendableId={id}>
-      <ToolbarMenu classNames={classNames} />
+      <ToolbarMenu />
     </MenuProvider>
   );
 };

package/src/components/SheetToolbar/align.ts

@@ -2,17 +2,24 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useEffect } from 'react';
+import { type Registry, RegistryContext } from '@effect-atom/atom-react';
+import { useContext, useEffect } from 'react';
 
 import { type CompleteCellRange, inRange } from '@dxos/compute';
-import { type ToolbarMenuActionGroupProperties, createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
+import { Obj } from '@dxos/echo';
+import {
+  type ActionGraphProps,
+  type ToolbarMenuActionGroupProperties,
+  createMenuAction,
+  createMenuItemGroup,
+} from '@dxos/react-ui-menu';
 
 import { meta } from '../../meta';
 import { type SheetModel } from '../../model';
 import { type AlignKey, type AlignValue, alignKey, rangeFromIndex, rangeToIndex } from '../../types';
 import { useSheetContext } from '../SheetContext';
 
-import { type ToolbarState } from './useToolbarState';
+import { type ToolbarState, type ToolbarStateAtom } from './useToolbarState';
 
 export type AlignAction = { key: AlignKey; value: AlignValue };
 
@@ -24,18 +31,21 @@ const aligns: Record<AlignValue, string> = {
   end: 'ph--text-align-right--regular',
 };
 
-export const useAlignState = (state: Partial<AlignState>) => {
+export const useAlignState = (stateAtom: ToolbarStateAtom) => {
+  const registry = useContext(RegistryContext);
   const { cursor, model } = useSheetContext();
   useEffect(() => {
     // TODO(thure): Can this O(n) call be memoized?
-    state[alignKey] = (
+    const alignValue = (
       cursor
         ? model.sheet.ranges?.findLast(
             ({ range, key }) => key === alignKey && inRange(rangeFromIndex(model.sheet, range), cursor),
           )?.value
         : undefined
     ) as AlignValue | undefined;
-  }, [cursor, model.sheet]);
+    const prev = registry.get(stateAtom);
+    registry.set(stateAtom, { ...prev, [alignKey]: alignValue });
+  }, [cursor, model.sheet, registry, stateAtom]);
 };
 
 const createAlignGroupAction = (value?: AlignValue) =>
@@ -46,7 +56,15 @@ const createAlignGroupAction = (value?: AlignValue) =>
     value: `${alignKey}--${value}`,
   } as ToolbarMenuActionGroupProperties);
 
-const createAlignActions = (model: SheetModel, state: ToolbarState, cursorFallbackRange?: CompleteCellRange) =>
+type AlignActionsContext = {
+  model: SheetModel;
+  state: ToolbarState;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+};
+
+const createAlignActions = ({ model, state, stateAtom, registry, cursorFallbackRange }: AlignActionsContext) =>
   Object.entries(aligns).map(([alignValue, icon]) => {
     return createMenuAction<AlignAction>(
       `${alignKey}--${alignValue}`,
@@ -64,15 +82,22 @@ const createAlignActions = (model: SheetModel, state: ToolbarState, cursorFallba
           key: alignKey,
           value: alignValue as AlignValue,
         };
+        const currentState = registry.get(stateAtom);
         if (index < 0) {
-          model.sheet.ranges?.push(nextRangeEntity);
-          state[alignKey] = nextRangeEntity.value;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.push(nextRangeEntity);
+          });
+          registry.set(stateAtom, { ...currentState, [alignKey]: nextRangeEntity.value });
         } else if (model.sheet.ranges![index].value === nextRangeEntity.value) {
-          model.sheet.ranges?.splice(index, 1);
-          state[alignKey] = undefined;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.splice(index, 1);
+          });
+          registry.set(stateAtom, { ...currentState, [alignKey]: undefined });
         } else {
-          model.sheet.ranges?.splice(index, 1, nextRangeEntity);
-          state[alignKey] = nextRangeEntity.value;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.splice(index, 1, nextRangeEntity);
+          });
+          registry.set(stateAtom, { ...currentState, [alignKey]: nextRangeEntity.value });
         }
       },
       {
@@ -86,9 +111,9 @@ const createAlignActions = (model: SheetModel, state: ToolbarState, cursorFallba
     );
   });
 
-export const createAlign = (model: SheetModel, state: ToolbarState, cursorFallbackRange?: CompleteCellRange) => {
-  const alignGroup = createAlignGroupAction(state[alignKey]);
-  const alignActions = createAlignActions(model, state, cursorFallbackRange);
+export const createAlign = (context: AlignActionsContext): ActionGraphProps => {
+  const alignGroup = createAlignGroupAction(context.state[alignKey]);
+  const alignActions = createAlignActions(context);
   return {
     nodes: [alignGroup, ...alignActions],
     edges: [

package/src/components/SheetToolbar/style.ts

@@ -2,16 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useEffect } from 'react';
+import { type Registry, RegistryContext } from '@effect-atom/atom-react';
+import { useContext, useEffect } from 'react';
 
 import { type CompleteCellRange, inRange } from '@dxos/compute';
-import { type ToolbarMenuActionGroupProperties, createMenuAction, createMenuItemGroup } from '@dxos/react-ui-menu';
+import { Obj } from '@dxos/echo';
+import {
+  type ActionGraphProps,
+  type ToolbarMenuActionGroupProperties,
+  createMenuAction,
+  createMenuItemGroup,
+} from '@dxos/react-ui-menu';
 
 import { meta } from '../../meta';
 import { type SheetModel } from '../../model';
 import { type StyleKey, type StyleValue, rangeFromIndex, rangeToIndex } from '../../types';
 import { useSheetContext } from '../SheetContext';
 
+import { type ToolbarState, type ToolbarStateAtom } from './useToolbarState';
+
 export type StyleState = Partial<Record<StyleValue, boolean>>;
 
 export type StyleAction = { key: StyleKey; value: StyleValue };
@@ -21,22 +30,30 @@ const styles: Record<StyleValue, string> = {
   softwrap: 'ph--paragraph--regular',
 };
 
-export const useStyleState = (state: StyleState) => {
+export const useStyleState = (stateAtom: ToolbarStateAtom) => {
+  const registry = useContext(RegistryContext);
   const { cursorFallbackRange, model } = useSheetContext();
 
   useEffect(() => {
-    state.highlight = false;
-    state.softwrap = false;
+    let highlight = false;
+    let softwrap = false;
     if (cursorFallbackRange && model.sheet.ranges) {
       model.sheet.ranges
         .filter(
           ({ range, key }) => key === 'style' && inRange(rangeFromIndex(model.sheet, range), cursorFallbackRange.from),
         )
         .forEach(({ value }) => {
-          state[value as StyleValue] = true;
+          if (value === 'highlight') {
+            highlight = true;
+          }
+          if (value === 'softwrap') {
+            softwrap = true;
+          }
         });
     }
-  }, [cursorFallbackRange, model.sheet]);
+    const prev = registry.get(stateAtom);
+    registry.set(stateAtom, { ...prev, highlight, softwrap });
+  }, [cursorFallbackRange, model.sheet, registry, stateAtom]);
 };
 
 const createStyleGroup = (state: StyleState) => {
@@ -49,7 +66,15 @@ const createStyleGroup = (state: StyleState) => {
   } as ToolbarMenuActionGroupProperties);
 };
 
-const createStyleActions = (model: SheetModel, state: StyleState, cursorFallbackRange?: CompleteCellRange) =>
+type StyleActionsContext = {
+  model: SheetModel;
+  state: ToolbarState;
+  stateAtom: ToolbarStateAtom;
+  registry: Registry.Registry;
+  cursorFallbackRange?: CompleteCellRange;
+};
+
+const createStyleActions = ({ model, state, stateAtom, registry, cursorFallbackRange }: StyleActionsContext) =>
   Object.entries(styles).map(([styleValue, icon]) => {
     return createMenuAction<StyleAction>(
       `style--${styleValue}`,
@@ -67,6 +92,7 @@ const createStyleActions = (model: SheetModel, state: StyleState, cursorFallback
           key: 'style',
           value: styleValue as StyleValue,
         };
+        const currentState = registry.get(stateAtom);
         if (
           model.sheet.ranges
             .filter(
@@ -77,12 +103,16 @@ const createStyleActions = (model: SheetModel, state: StyleState, cursorFallback
         ) {
           // this value should be unset
           if (index >= 0) {
-            model.sheet.ranges?.splice(index, 1);
+            Obj.change(model.sheet, (obj) => {
+              obj.ranges?.splice(index, 1);
+            });
           }
-          state[nextRangeEntity.value] = false;
+          registry.set(stateAtom, { ...currentState, [nextRangeEntity.value]: false });
         } else {
-          model.sheet.ranges?.push(nextRangeEntity);
-          state[nextRangeEntity.value] = true;
+          Obj.change(model.sheet, (obj) => {
+            obj.ranges?.push(nextRangeEntity);
+          });
+          registry.set(stateAtom, { ...currentState, [nextRangeEntity.value]: true });
         }
       },
       {
@@ -95,9 +125,9 @@ const createStyleActions = (model: SheetModel, state: StyleState, cursorFallback
     );
   });
 
-export const createStyle = (model: SheetModel, state: StyleState, cursorFallbackRange?: CompleteCellRange) => {
-  const styleGroupAction = createStyleGroup(state);
-  const styleActions = createStyleActions(model, state, cursorFallbackRange);
+export const createStyle = (context: StyleActionsContext): ActionGraphProps => {
+  const styleGroupAction = createStyleGroup(context.state);
+  const styleActions = createStyleActions(context);
   return {
     nodes: [styleGroupAction, ...styleActions],
     edges: [

package/src/components/SheetToolbar/useToolbarState.ts

@@ -2,15 +2,32 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useMemo } from 'react';
-
-import { live } from '@dxos/live-object';
+import { Atom, type Registry, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
+import { useContext, useMemo } from 'react';
 
 import { type AlignState } from './align';
 import { type StyleState } from './style';
 
 export type ToolbarState = Partial<StyleState & AlignState>;
+export type ToolbarStateAtom = Atom.Writable<ToolbarState>;
+
+/**
+ * Creates a reactive toolbar state Atom.
+ */
+export const useToolbarState = (initialState: ToolbarState = {}): ToolbarStateAtom => {
+  return useMemo(() => Atom.make<ToolbarState>(initialState).pipe(Atom.keepAlive), []);
+};
+
+/**
+ * Hook to read the current toolbar state value.
+ */
+export const useToolbarStateValue = (stateAtom: ToolbarStateAtom): ToolbarState => {
+  return useAtomValue(stateAtom);
+};
 
-export const useToolbarState = (initialState: ToolbarState = {}) => {
-  return useMemo(() => live<ToolbarState>(initialState), []);
+/**
+ * Hook to get the registry for updating toolbar state.
+ */
+export const useToolbarStateRegistry = (): Registry.Registry => {
+  return useContext(RegistryContext);
 };

package/src/extensions/compute.stories.tsx

@@ -5,27 +5,27 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useEffect, useMemo } from 'react';
 
-import { IntentPlugin } from '@dxos/app-framework';
+import { OperationPlugin, RuntimePlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { PublicKey } from '@dxos/keys';
 import { useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { useThemeContext } from '@dxos/react-ui';
 import { withTheme } from '@dxos/react-ui/testing';
+import { useTextEditor } from '@dxos/react-ui-editor';
 import {
   createBasicExtensions,
   createMarkdownExtensions,
   createThemeExtensions,
   decorateMarkdown,
   documentId,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
+} from '@dxos/ui-editor';
 import { isNonNullable } from '@dxos/util';
 
 import { GridSheet, SheetProvider, useComputeGraph } from '../components';
 import { useSheetModel } from '../model';
 import { useTestSheet, withComputeGraphDecorator } from '../testing';
-import { SheetType } from '../types';
+import { Sheet } from '../types';
 
 import { compute, computeGraphFacet } from './compute';
 
@@ -63,7 +63,7 @@ const DefaultStory = ({ text }: EditorProps) => {
     [computeGraph, themeMode],
   );
 
-  return <div className='w-[40rem] overflow-hidden' ref={parentRef} {...focusAttributes} />;
+  return <div className='is-[40rem] overflow-hidden' ref={parentRef} {...focusAttributes} />;
 };
 
 const Grid = () => {
@@ -73,7 +73,12 @@ const Grid = () => {
   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,7 +87,7 @@ const Grid = () => {
   }
 
   return (
-    <div className='flex w-[40rem] overflow-hidden'>
+    <div className='flex is-[40rem] overflow-hidden'>
       <SheetProvider graph={graph} sheet={sheet}>
         <GridSheet />
       </SheetProvider>
@@ -102,10 +107,14 @@ const GraphStory = (props: EditorProps) => {
 const meta = {
   title: 'plugins/plugin-sheet/extensions',
   decorators: [
-    withTheme,
-    withClientProvider({ types: [SheetType], createIdentity: true, createSpace: true }),
+    withTheme(),
+    withClientProvider({
+      types: [Sheet.Sheet],
+      createIdentity: true,
+      createSpace: true,
+    }),
     // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
-    withPluginManager({ plugins: [IntentPlugin()] }),
+    withPluginManager({ plugins: [OperationPlugin(), RuntimePlugin()] }),
     withComputeGraphDecorator(),
   ],
   parameters: {

package/src/extensions/compute.ts

@@ -23,7 +23,7 @@ import {
   createSheetName,
 } from '@dxos/compute';
 import { invariant } from '@dxos/invariant';
-import { documentId, singleValueFacet } from '@dxos/react-ui-editor';
+import { documentId, singleValueFacet } from '@dxos/ui-editor';
 
 const LANGUAGE_TAG = 'dx';
 

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

@@ -20,8 +20,8 @@ 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 { singleValueFacet } from '@dxos/ui-editor';
+import { mx } from '@dxos/ui-theme';
 
 /**
  * https://codemirror.net/examples/styling
@@ -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) ?? {};
@@ -166,7 +169,7 @@ export const sheetExtension = ({ debug, functions = [] }: SheetExtensionOptions)
       icons: false,
       tooltipClass: () =>
         mx(
-          '!-left-[1px] !top-[33px] !-m-0 border !border-t-0 [&>ul]:!min-w-[198px]',
+          '!-left-[1px] !top-[33px] !-m-0 border !border-bs-0 [&>ul]:!min-w-[198px]',
           '[&>ul>li[aria-selected]]:!bg-accentSurface',
           'border-separator',
         ),

package/src/index.ts

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

package/src/integrations/thread-ranges.ts

@@ -2,26 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
+import * as Effect from 'effect/Effect';
 import { useCallback, useEffect, useMemo } from 'react';
 
-import {
-  LayoutAction,
-  chain,
-  createIntent,
-  createResolver,
-  useIntentDispatcher,
-  useIntentResolver,
-} from '@dxos/app-framework';
+import { useOperationInvoker, useOperationResolver } 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 { OperationResolver } from '@dxos/operation';
+import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from '@dxos/plugin-deck/types';
+import { ThreadOperation } from '@dxos/plugin-thread/types';
+import { Filter, Query, useQuery } from '@dxos/react-client/echo';
 import { type DxGridElement, type GridContentProps } from '@dxos/react-ui-grid';
-import { AnchoredTo } from '@dxos/schema';
+import { AnchoredTo, Thread } from '@dxos/types';
 
 import { useSheetContext } from '../components';
 import { meta } from '../meta';
@@ -45,43 +39,37 @@ export const parseThreadAnchorAsCellRange = (cursor: string): CompleteCellRange
 
 export const useUpdateFocusedCellOnThreadSelection = (grid: DxGridElement | null) => {
   const { model, setActiveRefs } = useSheetContext();
-  const scrollIntoViewResolver = useMemo(
+  const sheetId = Obj.getDXN(model.sheet).toString();
+
+  const scrollIntoViewHandler = useMemo(
     () =>
-      createResolver({
-        intent: LayoutAction.ScrollIntoView,
+      OperationResolver.make({
+        operation: LayoutOperation.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);
-        },
+        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);
+            }
+          }),
       }),
-    [model.sheet, setActiveRefs],
+    [sheetId, setActiveRefs, grid],
   );
 
-  useIntentResolver(meta.id, scrollIntoViewResolver);
+  useOperationResolver(meta.id, scrollIntoViewHandler);
 };
 
 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 +79,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 +88,17 @@ 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);
+        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`,
+          });
+        })();
       }
     },
-    [dispatch, anchors],
+    [invokePromise, anchors],
   );
 
   const debounced = useMemo(() => {