@dxos/plugin-simple-layout 0.8.4-main.d05673bc65 → 0.8.4-main.dfabb4ec29

package/src/components/SimpleLayout/SimpleLayout.tsx

@@ -2,58 +2,57 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useLayoutEffect, useRef, useState } from 'react';
 
 import { Splitter, type SplitterMode } from '@dxos/react-ui';
 import { Mosaic } from '@dxos/react-ui-mosaic';
 
-import { useSimpleLayoutState } from '../../hooks';
+import { useSimpleLayoutState } from '#hooks';
+
+import { DebugOverlay } from '../DebugOverlay';
 import { Dialog } from '../Dialog';
 import { MobileLayout } from '../MobileLayout';
 import { PopoverContent, PopoverRoot } from '../Popover';
-
 import { Drawer } from './Drawer';
 import { Main } from './Main';
 
-// TODO(burdon): Mobile/Desktop variance?
 export const SimpleLayout = () => {
   const { state } = useSimpleLayoutState();
   const [keyboardOpen, setKeyboardOpen] = useState(false);
-  const [splitterMode, setSplitterMode] = useState<SplitterMode>('upper');
+  const [splitterMode, setSplitterMode] = useState<SplitterMode>('top');
 
   const drawerRef = useRef<HTMLDivElement>(null);
-  useEffect(() => {
-    if (keyboardOpen) {
-      // Determine which panel has focus and expand that one.
-      const activeElement = document.activeElement;
-      const drawerHasFocus = drawerRef.current?.contains(activeElement);
-      setSplitterMode(drawerHasFocus ? 'lower' : 'upper');
-    } else {
-      setSplitterMode(state.drawerState === 'closed' ? 'upper' : state.drawerState === 'open' ? 'both' : 'lower');
+
+  // Restore Splitter mode when keyboard closes.
+  useLayoutEffect(() => {
+    if (!keyboardOpen) {
+      setSplitterMode(state.drawerState === 'closed' ? 'top' : state.drawerState === 'open' ? 'split' : 'bottom');
     }
   }, [state.drawerState, keyboardOpen]);
 
   return (
-    <Mosaic.Root classNames='contents'>
-      <MobileLayout.Root
-        classNames='bg-toolbar-surface'
-        onKeyboardOpenChange={(keyboardOpen: boolean) => setKeyboardOpen(keyboardOpen)}
-      >
-        <MobileLayout.Panel safe={{ top: true, bottom: splitterMode === 'upper' }}>
-          <PopoverRoot>
-            <Splitter.Root mode={splitterMode} ratio={0.55}>
-              <Splitter.Panel position='upper'>
-                <Main />
-              </Splitter.Panel>
-              <Splitter.Panel position='lower' ref={drawerRef}>
-                <Drawer />
-              </Splitter.Panel>
-            </Splitter.Root>
-            <Dialog />
-            <PopoverContent />
-          </PopoverRoot>
-        </MobileLayout.Panel>
-      </MobileLayout.Root>
-    </Mosaic.Root>
+    <DebugOverlay.Root enabled={false}>
+      <PopoverRoot>
+        <Mosaic.Root>
+          <MobileLayout.Root
+            classNames='dx-container grid relative bg-toolbar-surface'
+            onKeyboardOpenChange={(nextKeyboardOpen) => setKeyboardOpen(nextKeyboardOpen)}
+          >
+            <MobileLayout.Panel safe={{ top: true, bottom: splitterMode === 'top' }}>
+              <Splitter.Root mode={splitterMode} ratio={0.55}>
+                <Splitter.Panel position='top'>
+                  <Main />
+                </Splitter.Panel>
+                <Splitter.Panel position='bottom' ref={drawerRef}>
+                  <Drawer />
+                </Splitter.Panel>
+              </Splitter.Root>
+              <Dialog />
+              <PopoverContent />
+            </MobileLayout.Panel>
+          </MobileLayout.Root>
+        </Mosaic.Root>
+      </PopoverRoot>
+    </DebugOverlay.Root>
   );
 };

package/src/components/hooks.ts

@@ -4,9 +4,9 @@
 
 import { useEffect } from 'react';
 
-import { expandAttendableId } from '@dxos/react-ui-attention';
 import { useAppGraph } from '@dxos/app-toolkit/ui';
 import { Graph } from '@dxos/plugin-graph';
+import { expandAttendableId } from '@dxos/react-ui-attention';
 
 /**
  * Expand graph nodes along the full path from root to the given node ID.

package/src/components/index.ts

@@ -2,8 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './ContentLoading';
+export * from './DebugOverlay';
 export * from './Home';
+export * from './Loading';
 export * from './MobileLayout';
 export * from './Popover';
 export * from './SimpleLayout';

package/src/hooks/actions.ts

@@ -5,12 +5,13 @@
 import { type Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 
-import { type AppCapabilities, getCompanionVariant } from '@dxos/app-toolkit';
+import { type AppCapabilities } from '@dxos/app-toolkit';
 import { Node } from '@dxos/plugin-graph';
+import { getLinkedVariant } from '@dxos/react-ui-attention';
 import { type ActionGraphProps } from '@dxos/react-ui-menu';
 import { byPosition } from '@dxos/util';
 
-import { type SimpleLayoutState } from '../types';
+import { SimpleLayoutCapabilities } from '#types';
 
 // TODO(wittjosiah): Factor out to shared location with plugin-deck.
 export const PLANK_COMPANION_TYPE = 'org.dxos.plugin.deck.plank-companion';
@@ -21,7 +22,9 @@ export type CompanionActionsConfig = {
   /** Optional: highlight companion with this variant */
   selectedVariant?: string;
   /** State updater for toggling the drawer. */
-  updateState: (fn: (state: SimpleLayoutState) => SimpleLayoutState) => void;
+  updateState: (
+    fn: (state: SimpleLayoutCapabilities.SimpleLayoutState) => SimpleLayoutCapabilities.SimpleLayoutState,
+  ) => void;
 };
 
 /**
@@ -31,7 +34,7 @@ export type CompanionActionsConfig = {
 // TODO(burdon): Use builder pattern.
 export const createCompanionActions = (
   graph: AppCapabilities.AppGraph['graph'],
-  stateAtom: Atom.Atom<SimpleLayoutState>,
+  stateAtom: Atom.Atom<SimpleLayoutCapabilities.SimpleLayoutState>,
   get: (atom: Atom.Atom<any>) => any,
   config: CompanionActionsConfig,
 ): Pick<ActionGraphProps, 'nodes' | 'edges'> => {
@@ -51,7 +54,7 @@ export const createCompanionActions = (
   const edges: ActionGraphProps['edges'] = [];
 
   companions.forEach((companion: Node.Node) => {
-    const companionVariant = getCompanionVariant(companion.id);
+    const companionVariant = getLinkedVariant(companion.id);
     const companionAction = {
       id: `${idPrefix}-companion-${companion.id}`,
       type: Node.ActionType,

package/src/hooks/useAppBarProps.ts

@@ -3,7 +3,6 @@
 //
 
 import { Atom, useAtomValue } from '@effect-atom/atom-react';
-import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 import { useCallback, useMemo } from 'react';
 
@@ -14,9 +13,9 @@ import { Graph, Node, useActionRunner, useNode } from '@dxos/plugin-graph';
 import { toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { type ActionGraphProps } from '@dxos/react-ui-menu';
 
-import { type AppBarProps } from '../components';
-import { meta } from '../meta';
-import { SimpleLayoutState as SimpleLayoutStateCapability } from '../types';
+import { type AppBarProps } from '#components';
+import { meta } from '#meta';
+import { SimpleLayoutCapabilities } from '#types';
 
 /**
  * Hook that computes all AppBar props from the app graph.
@@ -24,10 +23,10 @@ import { SimpleLayoutState as SimpleLayoutStateCapability } from '../types';
  */
 export const useAppBarProps = (): Omit<AppBarProps, 'classNames'> => {
   const { t } = useTranslation(meta.id);
-  const stateAtom = useCapability(SimpleLayoutStateCapability);
+  const stateAtom = useCapability(SimpleLayoutCapabilities.State);
   const state = useAtomValue(stateAtom);
   const { graph } = useAppGraph();
-  const { invokeSync } = useOperationInvoker();
+  const { invokePromise } = useOperationInvoker();
   const runAction = useActionRunner();
 
   // Derive activeId from state.
@@ -55,25 +54,6 @@ export const useAppBarProps = (): Omit<AppBarProps, 'classNames'> => {
           relation: 'child',
         }));
 
-        // Add alternate-tree action (e.g. Settings) from the workspace node.
-        const workspaceConnections = state.workspace ? get(graph.connections(state.workspace, 'child')) : [];
-        const alternateTreeNode = workspaceConnections.find(
-          (node: Node.Node) => node.properties.disposition === 'alternate-tree',
-        );
-        if (alternateTreeNode && activeId !== alternateTreeNode.id) {
-          const settingsAction = {
-            id: `appbar-settings-${alternateTreeNode.id}`,
-            type: Node.ActionType,
-            data: () => Effect.sync(() => invokeSync(LayoutOperation.Open, { subject: [alternateTreeNode.id] })),
-            properties: {
-              label: alternateTreeNode.properties.label ?? alternateTreeNode.id,
-              icon: alternateTreeNode.properties.icon ?? 'ph--placeholder--regular',
-            },
-          };
-          nodes.push(settingsAction);
-          edges.push({ source: 'root', target: settingsAction.id, relation: 'child' });
-        }
-
         return { nodes, edges };
       }),
     [graph, stateAtom],
@@ -91,15 +71,15 @@ export const useAppBarProps = (): Omit<AppBarProps, 'classNames'> => {
 
       // If history is empty and this is a workspace, go to home.
       if (state.history.length === 0 && isWorkspace) {
-        invokeSync(LayoutOperation.SwitchWorkspace, { subject: Node.RootId });
+        void invokePromise(LayoutOperation.SwitchWorkspace, { subject: Node.RootId });
       } else {
         // Otherwise, close (which will pop from history or clear active).
-        invokeSync(LayoutOperation.Close, { subject: [state.active] });
+        void invokePromise(LayoutOperation.Close, { subject: [state.active] });
       }
     } else {
-      invokeSync(LayoutOperation.SwitchWorkspace, { subject: Node.RootId });
+      void invokePromise(LayoutOperation.SwitchWorkspace, { subject: Node.RootId });
     }
-  }, [graph, invokeSync, state.active, state.history.length]);
+  }, [graph, invokePromise, state.active, state.history.length]);
 
   // Compute popover anchor ID.
   const popoverAnchorId = node && state.popoverAnchorId === `${meta.id}:${node.id}` ? state.popoverAnchorId : undefined;

package/src/hooks/useDrawerActions.ts

@@ -12,9 +12,9 @@ import { Node, useActionRunner } from '@dxos/plugin-graph';
 import { useTranslation } from '@dxos/react-ui';
 import { type ActionExecutor, type ActionGraphProps, createGapSeparator } from '@dxos/react-ui-menu';
 
-import { useMobileLayout } from '../components';
-import { meta } from '../meta';
-import { SimpleLayoutState as SimpleLayoutStateCapability } from '../types';
+import { useMobileLayout } from '#components';
+import { meta } from '#meta';
+import { SimpleLayoutCapabilities } from '#types';
 
 import { createCompanionActions } from './actions';
 import { useSimpleLayoutState } from './useSimpleLayoutState';
@@ -31,7 +31,7 @@ export type DrawerActions = {
  */
 export const useDrawerActions = (consumerName: string): DrawerActions => {
   const { t } = useTranslation(meta.id);
-  const stateAtom = useCapability(SimpleLayoutStateCapability);
+  const stateAtom = useCapability(SimpleLayoutCapabilities.State);
   const { graph } = useAppGraph();
   const runAction = useActionRunner();
   const { updateState } = useSimpleLayoutState();
@@ -47,7 +47,7 @@ export const useDrawerActions = (consumerName: string): DrawerActions => {
         // Add companion tab actions.
         const { nodes, edges } = createCompanionActions(graph, stateAtom, get, {
           idPrefix: 'drawer',
-          selectedVariant: state.companionVariant,
+          selectedVariant: state.drawerState !== 'closed' ? state.companionVariant : undefined,
           updateState,
         });
 
@@ -64,7 +64,7 @@ export const useDrawerActions = (consumerName: string): DrawerActions => {
             type: Node.ActionType,
             properties: {
               icon: isExpanded ? 'ph--arrow-down--regular' : 'ph--arrow-up--regular',
-              label: isExpanded ? t('collapse drawer label') : t('expand drawer label'),
+              label: isExpanded ? t('collapse-drawer.label') : t('expand-drawer.label'),
               iconOnly: true,
             },
             data: () =>
@@ -80,7 +80,7 @@ export const useDrawerActions = (consumerName: string): DrawerActions => {
           type: Node.ActionType,
           properties: {
             icon: 'ph--x--regular',
-            label: t('close drawer label'),
+            label: t('close-drawer.label'),
             iconOnly: true,
           },
           data: () =>

package/src/hooks/useNavbarActions.ts

@@ -16,8 +16,8 @@ import {
   createMenuItemGroup,
 } from '@dxos/react-ui-menu';
 
-import { meta } from '../meta';
-import { SimpleLayoutState } from '../types';
+import { meta } from '#meta';
+import { SimpleLayoutCapabilities } from '#types';
 
 import { createCompanionActions } from './actions';
 import { useSimpleLayoutState } from './useSimpleLayoutState';
@@ -39,7 +39,7 @@ export const useNavbarActions = (): NavbarActions => {
   const { t } = useTranslation(meta.id);
   const { graph } = useAppGraph();
   const runAction = useActionRunner();
-  const stateAtom = useCapability(SimpleLayoutState);
+  const stateAtom = useCapability(SimpleLayoutCapabilities.State);
   const { updateState } = useSimpleLayoutState();
 
   // Create a computed atom that derives everything from graph connections and state.
@@ -62,7 +62,7 @@ export const useNavbarActions = (): NavbarActions => {
           variant: 'dropdownMenu',
           icon: 'ph--list--regular',
           iconOnly: true,
-          label: t('main menu label'),
+          label: t('main-menu.label'),
           testId: 'simpleLayoutPlugin.addSpace',
         });
         nodes.push(mainMenuGroup);

package/src/hooks/useSimpleLayoutState.ts

@@ -7,20 +7,22 @@ import { useCallback, useContext } from 'react';
 
 import { useCapability } from '@dxos/app-framework/ui';
 
-import { SimpleLayoutState } from '../types';
+import { SimpleLayoutCapabilities } from '#types';
 
 export type UseSimpleLayoutState = {
-  state: SimpleLayoutState;
-  updateState: (fn: (current: SimpleLayoutState) => SimpleLayoutState) => void;
+  state: SimpleLayoutCapabilities.SimpleLayoutState;
+  updateState: (
+    fn: (current: SimpleLayoutCapabilities.SimpleLayoutState) => SimpleLayoutCapabilities.SimpleLayoutState,
+  ) => void;
 };
 
 export const useSimpleLayoutState = (): UseSimpleLayoutState => {
   const registry = useContext(RegistryContext);
-  const stateAtom = useCapability(SimpleLayoutState);
+  const stateAtom = useCapability(SimpleLayoutCapabilities.State);
   const state = useAtomValue(stateAtom);
 
   const updateState = useCallback(
-    (fn: (current: SimpleLayoutState) => SimpleLayoutState) => {
+    (fn: (current: SimpleLayoutCapabilities.SimpleLayoutState) => SimpleLayoutCapabilities.SimpleLayoutState) => {
       registry.set(stateAtom, fn(registry.get(stateAtom)));
     },
     [registry, stateAtom],

package/src/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './SimpleLayoutPlugin';
+export * from './meta';
+export * from './types';

package/src/meta.ts

@@ -6,11 +6,12 @@ import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
 export const meta: Plugin.Meta = {
-  id: 'org.dxos.plugin.simple-layout',
+  id: 'org.dxos.plugin.simpleLayout',
   name: 'Simple Layout',
   description: trim`
     Minimal layout plugin for simplified UI contexts like popover windows.
     Provides basic content rendering without sidebars or complex navigation.
   `,
   icon: 'ph--layout--regular',
+  tags: ['system'],
 };

package/src/operations/close.ts

@@ -0,0 +1,34 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.Close> = LayoutOperation.Close.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const { updateState } = yield* layoutStateAccess;
+
+      updateState((state) => {
+        if (state.history.length > 0) {
+          const newHistory = [...state.history];
+          const previousActive = newHistory.pop();
+          return {
+            ...state,
+            active: previousActive,
+            history: newHistory,
+          };
+        }
+        return {
+          ...state,
+          active: undefined,
+        };
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,16 @@
+// Copyright 2025 DXOS.org
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const SimpleLayoutOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./close'),
+  () => import('./open'),
+  () => import('./revert-workspace'),
+  () => import('./set'),
+  () => import('./set-layout-mode'),
+  () => import('./switch-workspace'),
+  () => import('./update-complementary'),
+  () => import('./update-dialog'),
+  () => import('./update-popover'),
+  () => import('./update-sidebar'),
+);

package/src/operations/open.ts

@@ -0,0 +1,63 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  LayoutOperation,
+  createEdgeExistenceChecker,
+  validateNavigationTarget,
+} from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Context } from '@dxos/context';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.Open> = LayoutOperation.Open.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+      const { updateState } = yield* layoutStateAccess;
+      const id = input.subject[0];
+
+      // Validate navigation target, redirecting to 404 if not found.
+      const capabilities = yield* Capability.Service;
+      const pathResolvers = capabilities.getAll(AppCapabilities.NavigationPathResolver);
+      const checkRemoteExistence = yield* Capability.get(ClientCapabilities.Client).pipe(
+        Effect.map((client) =>
+          createEdgeExistenceChecker((spaceId, body) => client.edge.http.execQuery(new Context(), spaceId, body)),
+        ),
+        Effect.catchAll(() => Effect.succeed(undefined)),
+      );
+
+      const validatedId =
+        input.navigation === 'immediate'
+          ? id
+          : yield* validateNavigationTarget({
+              graph,
+              subjectId: id,
+              pathResolvers,
+              checkRemoteExistence,
+            });
+
+      updateState((state) => {
+        const newHistory = state.active ? [...state.history, state.active] : state.history;
+        const trimmedHistory =
+          newHistory.length > MAX_HISTORY_LENGTH ? newHistory.slice(-MAX_HISTORY_LENGTH) : newHistory;
+        return {
+          ...state,
+          active: validatedId,
+          history: trimmedHistory,
+        };
+      });
+
+      return [validatedId];
+    }),
+  ),
+);
+
+export default handler;
+
+const MAX_HISTORY_LENGTH = 50;

package/src/operations/revert-workspace.ts

@@ -0,0 +1,22 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.RevertWorkspace> = LayoutOperation.RevertWorkspace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const { getState } = yield* layoutStateAccess;
+      const state = getState();
+      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
+        subject: state.previousWorkspace,
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/set-layout-mode.ts

@@ -0,0 +1,12 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.SetLayoutMode> = LayoutOperation.SetLayoutMode.pipe(
+  Operation.withHandler(Effect.fnUntraced(function* () {})),
+);
+
+export default handler;

package/src/operations/set.ts

@@ -0,0 +1,23 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.Set> = LayoutOperation.Set.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { updateState } = yield* layoutStateAccess;
+
+      updateState((state) => ({
+        ...state,
+        active: input.subject[0],
+      }));
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/state-access.ts

@@ -0,0 +1,21 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+
+import { SimpleLayoutCapabilities } from '../types';
+
+export const layoutStateAccess = Effect.gen(function* () {
+  const registry = yield* Capability.get(Capabilities.AtomRegistry);
+  const stateAtom = yield* Capability.get(SimpleLayoutCapabilities.State);
+
+  return {
+    getState: () => registry.get(stateAtom),
+    updateState: (
+      fn: (current: SimpleLayoutCapabilities.SimpleLayoutState) => SimpleLayoutCapabilities.SimpleLayoutState,
+    ) => {
+      registry.set(stateAtom, fn(registry.get(stateAtom)));
+    },
+  };
+});

package/src/operations/switch-workspace.ts

@@ -0,0 +1,26 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { isPinnedWorkspace, LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.SwitchWorkspace> = LayoutOperation.SwitchWorkspace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { updateState } = yield* layoutStateAccess;
+
+      updateState((state) => ({
+        ...state,
+        previousWorkspace: !isPinnedWorkspace(state.workspace) ? state.workspace : state.previousWorkspace,
+        workspace: input.subject,
+        active: undefined,
+        history: [],
+      }));
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/update-complementary.ts

@@ -0,0 +1,35 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { getLinkedVariant } from '@dxos/react-ui-attention';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.UpdateComplementary> =
+  LayoutOperation.UpdateComplementary.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* (input) {
+        const { updateState } = yield* layoutStateAccess;
+
+        if (input.state === 'closed') {
+          updateState((state) => ({
+            ...state,
+            drawerState: 'closed',
+            companionVariant: undefined,
+          }));
+        } else if (input.subject) {
+          const variant = getLinkedVariant(input.subject);
+          updateState((state) => ({
+            ...state,
+            companionVariant: variant,
+            drawerState: input.state === 'expanded' ? 'expanded' : 'open',
+          }));
+        }
+      }),
+    ),
+  );
+
+export default handler;

package/src/operations/update-dialog.ts

@@ -0,0 +1,28 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { layoutStateAccess } from './state-access';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.UpdateDialog> = LayoutOperation.UpdateDialog.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { updateState } = yield* layoutStateAccess;
+
+      updateState((state) => ({
+        ...state,
+        dialogOpen: input.state ?? Boolean(input.subject),
+        dialogType: input.type ?? 'default',
+        dialogBlockAlign: input.blockAlign ?? 'center',
+        dialogOverlayClasses: input.overlayClasses,
+        dialogOverlayStyle: input.overlayStyle,
+        dialogContent: input.subject ? { component: input.subject, props: input.props } : undefined,
+      }));
+    }),
+  ),
+);
+
+export default handler;