@dxos/plugin-deck 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/hooks/useDeckState.ts

@@ -11,11 +11,11 @@ import { invariant } from '@dxos/invariant';
 
 import {
   DeckCapabilities,
-  type DeckEphemeralStateProps,
+  type EphemeralDeckState,
   type DeckPluginState,
   type DeckState,
-  type DeckStateProps,
-} from '../types';
+  type StoredDeckState,
+} from '#types';
 
 export type DeckStateHook = {
   /** Combined state value (reactive). Includes both persisted and ephemeral state. */
@@ -23,9 +23,9 @@ export type DeckStateHook = {
   /** The active deck, computed from decks[activeDeck]. */
   deck: DeckState;
   /** Update persisted state. */
-  updateState: (fn: (current: DeckStateProps) => DeckStateProps) => void;
+  updateState: (fn: (current: StoredDeckState) => StoredDeckState) => void;
   /** Update ephemeral state. */
-  updateEphemeral: (fn: (current: DeckEphemeralStateProps) => DeckEphemeralStateProps) => void;
+  updateEphemeral: (fn: (current: EphemeralDeckState) => EphemeralDeckState) => void;
 };
 
 /**
@@ -36,15 +36,14 @@ export const useDeckState = (): DeckStateHook => {
   const registry = useCapability(Capabilities.AtomRegistry);
   const stateAtom = useCapability(DeckCapabilities.State);
   const ephemeralAtom = useCapability(DeckCapabilities.EphemeralState);
-
   const persistedState = useAtomValue(stateAtom);
   const ephemeralState = useAtomValue(ephemeralAtom);
 
   // Compute deck from decks[activeDeck] to ensure it's always current.
   const deck = useMemo(() => {
-    const d = persistedState.decks[persistedState.activeDeck];
-    invariant(d, `Deck not found: ${persistedState.activeDeck}`);
-    return d;
+    const deck = persistedState.decks[persistedState.activeDeck];
+    invariant(deck, `Deck not found: ${persistedState.activeDeck}`);
+    return deck;
   }, [persistedState.decks, persistedState.activeDeck]);
 
   // Combine persisted and ephemeral state into a unified view.
@@ -57,26 +56,18 @@ export const useDeckState = (): DeckStateHook => {
   );
 
   const updateState = useCallback(
-    (fn: (current: DeckStateProps) => DeckStateProps) => {
+    (fn: (current: StoredDeckState) => StoredDeckState) => {
       registry.set(stateAtom, fn(registry.get(stateAtom)));
     },
     [registry, stateAtom],
   );
 
   const updateEphemeral = useCallback(
-    (fn: (current: DeckEphemeralStateProps) => DeckEphemeralStateProps) => {
+    (fn: (current: EphemeralDeckState) => EphemeralDeckState) => {
       registry.set(ephemeralAtom, fn(registry.get(ephemeralAtom)));
     },
     [registry, ephemeralAtom],
   );
 
-  return useMemo(
-    () => ({
-      state,
-      deck,
-      updateState,
-      updateEphemeral,
-    }),
-    [state, deck, updateState, updateEphemeral],
-  );
+  return useMemo(() => ({ state, deck, updateState, updateEphemeral }), [state, deck, updateState, updateEphemeral]);
 };

package/src/hooks/useSelectedCompanion.ts

@@ -4,8 +4,8 @@
 
 import { useMemo } from 'react';
 
-import { getCompanionVariant } from '@dxos/app-toolkit';
 import { type Node } from '@dxos/plugin-graph';
+import { getLinkedVariant } from '@dxos/react-ui-attention';
 
 /**
  * Resolves which companion to show based on variant preference.
@@ -19,14 +19,14 @@ export const useSelectedCompanion = (companions: Node.Node[], preferredVariant?:
 
     // Try to find companion matching the preferred variant.
     if (preferredVariant) {
-      const preferred = companions.find((companion) => getCompanionVariant(companion.id) === preferredVariant);
+      const preferred = companions.find((companion) => getLinkedVariant(companion.id) === preferredVariant);
       if (preferred) {
-        return { companionId: preferred.id, variant: getCompanionVariant(preferred.id) };
+        return { companionId: preferred.id, variant: getLinkedVariant(preferred.id) };
       }
     }
 
     // Fallback to first companion.
     const first = companions[0];
-    return { companionId: first.id, variant: getCompanionVariant(first.id) };
+    return { companionId: first.id, variant: getLinkedVariant(first.id) };
   }, [companions, preferredVariant]);
 };

package/src/index.ts

@@ -2,7 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export { DeckCapabilities, DeckEvents } from './types';
-export * from './DeckPlugin';
 export * from './meta';
-export { useCompanions } from './hooks';
+export * from './types';

package/src/layout.test.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { openEntry, openSubjectsOnActiveDeck } from './layout';
+
+describe('openEntry', () => {
+  test('pushes new id to the end', () => {
+    expect(openEntry(['a', 'b'], 'c')).toEqual(['a', 'b', 'c']);
+  });
+
+  test('no-op when id already present', () => {
+    expect(openEntry(['a', 'b'], 'a')).toEqual(['a', 'b']);
+  });
+
+  test('replaces by key prefix when key matches', () => {
+    expect(openEntry(['foo+1', 'b'], 'foo+2', { key: 'foo' })).toEqual(['foo+2', 'b']);
+  });
+});
+
+describe('openSubjectsOnActiveDeck', () => {
+  test('truncates after pivot then appends one subject', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b', 'c', 'd'], ['e'], { pivotId: 'a' })).toEqual(['a', 'e']);
+  });
+
+  test('appends to end when pivot not in deck', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b'], ['c'], { pivotId: 'missing' })).toEqual(['a', 'b', 'c']);
+  });
+
+  test('without pivotId appends each subject to the end', () => {
+    expect(openSubjectsOnActiveDeck(['a'], ['b', 'c'], {})).toEqual(['a', 'b', 'c']);
+  });
+
+  test('with pivot keeps all new subjects after truncate', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b', 'c'], ['x', 'y'], { pivotId: 'a' })).toEqual(['a', 'x', 'y']);
+  });
+
+  test('passes key through to openEntry', () => {
+    expect(openSubjectsOnActiveDeck(['foo+1'], ['foo+2'], { key: 'foo' })).toEqual(['foo+2']);
+  });
+
+  test('returns deck unchanged when subject is already open (no pivot)', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b', 'c'], ['b'])).toEqual(['a', 'b', 'c']);
+  });
+
+  test('returns deck unchanged when subject is already open (with pivot)', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b', 'c'], ['c'], { pivotId: 'a' })).toEqual(['a', 'b', 'c']);
+  });
+
+  test('returns deck unchanged when all subjects are already open', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b', 'c'], ['b', 'c'], { pivotId: 'a' })).toEqual(['a', 'b', 'c']);
+  });
+
+  test('truncates after pivot when subject is new even if some are already open', () => {
+    expect(openSubjectsOnActiveDeck(['a', 'b', 'c'], ['b', 'd'], { pivotId: 'a' })).toEqual(['a', 'b', 'd']);
+  });
+});

package/src/layout.ts

@@ -4,25 +4,23 @@
 
 import { produce } from 'immer';
 
-import { type DeckAction, type NewPlankPositioning } from './types';
+import { type DeckAction } from '#types';
 
 type OpenLayoutEntryOptions = {
   key?: string;
-  positioning?: NewPlankPositioning;
-  pivotId?: string;
 };
 
-export const openEntry = (deck: string[], entryId: string, options?: OpenLayoutEntryOptions): string[] => {
-  return produce(deck, (draft) => {
-    // Check that the entry is not already in the part
+/**
+ * Mutates a deck list using stack semantics: new items open to the right (`push`).
+ * Callers that open from a pivot must truncate the deck first (see deck `open` operation).
+ */
+export const openEntry = (deck: readonly string[], entryId: string, options?: OpenLayoutEntryOptions): string[] => {
+  return produce([...deck], (draft) => {
     if (draft.find((id) => id === entryId)) {
       return;
     }
 
     const key = options?.key;
-    const plankPositioning = options?.positioning ?? 'start';
-    const pivotId = options?.pivotId;
-
     if (key) {
       const index = draft.findIndex((id) => id.split('+')[0] === key);
       if (index !== -1) {
@@ -31,27 +29,40 @@ export const openEntry = (deck: string[], entryId: string, options?: OpenLayoutE
       }
     }
 
-    if (pivotId) {
-      const pivotIndex = draft.findIndex((id) => id === pivotId);
-      if (pivotIndex !== -1) {
-        if (plankPositioning === 'start') {
-          draft.splice(pivotIndex, 0, entryId);
-        } else {
-          draft.splice(pivotIndex + 1, 0, entryId);
-        }
-        return;
-      }
-    }
-
-    // If no pivot found or provided, fall back to original behavior
-    if (plankPositioning === 'start') {
-      draft.unshift(entryId);
-    } else {
-      draft.push(entryId);
-    }
+    draft.push(entryId);
   });
 };
 
+export type OpenSubjectsOnActiveDeckOptions = {
+  pivotId?: string;
+  key?: string;
+};
+
+/**
+ * Computes the next multi-mode `active` list for {@link LayoutOperation.Open}.
+ * If `pivotId` is present and found, truncates the deck after that id.
+ * Applies each subject with {@link openEntry}.
+ * If the pivot is missing, appends onto the full `active` list.
+ *
+ * When all subjects are already present in the active deck, the deck is returned
+ * unchanged so that pivot truncation does not discard open planks when navigating
+ * to something that is already visible.
+ */
+export const openSubjectsOnActiveDeck = (
+  active: readonly string[],
+  subject: readonly string[],
+  options?: OpenSubjectsOnActiveDeckOptions,
+): string[] => {
+  if (subject.length > 0 && subject.every((id) => active.includes(id))) {
+    return [...active];
+  }
+
+  const { pivotId, key } = options ?? {};
+  const pivotIndex = pivotId ? active.findIndex((id) => id === pivotId) : -1;
+  const baseDeck = pivotIndex !== -1 ? active.slice(0, pivotIndex + 1) : [...active];
+  return subject.reduce((acc, entryId) => openEntry(acc, entryId, { key }), baseDeck);
+};
+
 export const closeEntry = (deck: string[], entryId: string): string[] => {
   return produce(deck, (draft) => {
     const index = draft.findIndex((id) => id === entryId);

package/src/meta.ts

@@ -8,9 +8,11 @@ import { trim } from '@dxos/util';
 export const meta: Plugin.Meta = {
   id: 'org.dxos.plugin.deck',
   name: 'Layout',
+  author: 'DXOS',
   description: trim`
     Flexible layout system for arranging workspace views in tabs, splits, and panels.
     Customize your workspace organization with drag-and-drop layout management.
   `,
   icon: 'ph--layout--regular',
+  tags: ['system'],
 };

package/src/operations/add-toast.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { DeckCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.AddToast> = LayoutOperation.AddToast.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+        ...state,
+        toasts: [...state.toasts, input as LayoutOperation.Toast],
+      }));
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/adjust.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { Graph } from '@dxos/plugin-graph';
+import { byPosition } from '@dxos/util';
+
+import { incrementPlank } from '../layout';
+import { DeckCapabilities, DeckOperation, PLANK_COMPANION_TYPE } from '../types';
+import { computeActiveUpdates } from '../util';
+import { updateActiveDeck } from './helpers';
+
+const handler: Operation.WithHandler<typeof DeckOperation.Adjust> = DeckOperation.Adjust.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const _state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+      const deck = yield* DeckCapabilities.getDeck();
+      const attention = yield* Capability.get(AttentionCapabilities.Attention);
+      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+
+      let soloOperation:
+        | { type: 'solo'; entryId: string; mode: string }
+        | { type: 'unsolo'; entryId: string }
+        | undefined;
+
+      if (input.type === 'increment-end' || input.type === 'increment-start') {
+        const next = incrementPlank(deck.active, input);
+        const { deckUpdates } = computeActiveUpdates({ next, deck, attention });
+        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+      }
+
+      if (input.type.startsWith('solo')) {
+        const entryId = input.id;
+        if (!deck.solo) {
+          soloOperation = { type: 'solo', entryId, mode: input.type };
+        } else {
+          if (input.type === 'solo--fullscreen') {
+            soloOperation = { type: 'solo', entryId, mode: 'solo--fullscreen' };
+          } else if (input.type === 'solo') {
+            soloOperation = { type: 'unsolo', entryId };
+          }
+        }
+      }
+
+      if (soloOperation?.type === 'solo') {
+        yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
+          subject: soloOperation.entryId,
+          mode: soloOperation.mode,
+        });
+      } else if (soloOperation?.type === 'unsolo') {
+        yield* Operation.invoke(LayoutOperation.SetLayoutMode, { mode: 'multi' });
+        yield* Operation.invoke(LayoutOperation.Open, { subject: [soloOperation.entryId] });
+      }
+
+      if (input.type === 'companion') {
+        const companion = Function.pipe(
+          Graph.getNode(graph, input.id),
+          Option.map((node) =>
+            Graph.getConnections(graph, node.id, 'child')
+              .filter((n) => n.type === PLANK_COMPANION_TYPE)
+              .toSorted((a, b) => byPosition(a.properties, b.properties)),
+          ),
+          Option.flatMap((companions) => (companions.length > 0 ? Option.some(companions[0]) : Option.none())),
+        );
+
+        if (Option.isSome(companion)) {
+          yield* Operation.invoke(LayoutOperation.UpdateCompanion, { subject: companion.value.id });
+        }
+      }
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/close.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+
+import { closeEntry } from '../layout';
+import { DeckCapabilities } from '../types';
+import { computeActiveUpdates } from '../util';
+import { updateActiveDeck } from './helpers';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.Close> = LayoutOperation.Close.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const deck = yield* DeckCapabilities.getDeck();
+      const attention = yield* Capability.get(AttentionCapabilities.Attention);
+
+      const active = deck.solo ? [deck.solo] : deck.active;
+      const next = input.subject.reduce((acc, id) => closeEntry(acc, id), active);
+      const { deckUpdates, toAttend } = computeActiveUpdates({ next, deck, attention });
+      yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+
+      if (toAttend) {
+        yield* Operation.schedule(LayoutOperation.ScrollIntoView, { subject: toAttend });
+      }
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/helpers.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+
+import { type DeckState, type StoredDeckState } from '../types';
+
+export const updateActiveDeck = (current: StoredDeckState, deckUpdates: Partial<DeckState>): StoredDeckState => {
+  const currentDeck = current.decks[current.activeDeck];
+  invariant(currentDeck, `Deck not found: ${current.activeDeck}`);
+  return {
+    ...current,
+    decks: {
+      ...current.decks,
+      [current.activeDeck]: {
+        ...currentDeck,
+        ...deckUpdates,
+      },
+    },
+  };
+};

package/src/operations/index.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const DeckOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./add-toast'),
+  () => import('./adjust'),
+  () => import('./close'),
+  () => import('./open'),
+  () => import('./revert-workspace'),
+  () => import('./scroll-into-view'),
+  () => import('./set'),
+  () => import('./set-layout-mode'),
+  () => import('./show-undo'),
+  () => import('./switch-workspace'),
+  () => import('./update-companion'),
+  () => import('./update-complementary'),
+  () => import('./update-dialog'),
+  () => import('./update-plank-size'),
+  () => import('./update-popover'),
+  () => import('./update-sidebar'),
+);

package/src/operations/open.ts

@@ -0,0 +1,186 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  LayoutOperation,
+  createEdgeExistenceChecker,
+  expandPath,
+  validateNavigationTarget,
+} from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Context } from '@dxos/context';
+import { Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { Graph } from '@dxos/plugin-graph';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+
+import { openSubjectsOnActiveDeck } from '../layout';
+import { DeckCapabilities } from '../types';
+import { computeActiveUpdates } from '../util';
+import { updateActiveDeck } from './helpers';
+
+const handler: Operation.WithHandler<typeof LayoutOperation.Open> = LayoutOperation.Open.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      log('LayoutOperation.Open handler start');
+      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+      const attention = yield* Capability.get(AttentionCapabilities.Attention);
+
+      // Validate navigation targets, 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)),
+      );
+
+      // Immediate: skip 404 / resolver checks but still expand the path (same as validate’s first step).
+      if (input.navigation === 'immediate') {
+        for (const subjectId of input.subject) {
+          expandPath(graph, subjectId);
+        }
+      }
+
+      const validatedSubjects = yield* Effect.all(
+        input.subject.map((subjectId) =>
+          input.navigation === 'immediate'
+            ? Effect.succeed(subjectId)
+            : validateNavigationTarget({ graph, subjectId, pathResolvers, checkRemoteExistence }),
+        ),
+      );
+      input = { ...input, subject: validatedSubjects };
+
+      {
+        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        if (input.workspace && state.activeDeck !== input.workspace) {
+          yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: input.workspace });
+        }
+      }
+
+      // Dedup subjects against the active deck using DXN identity.
+      // The same object can appear under different graph paths (e.g., via collections vs types).
+      // Resolve each subject's DXN and, if it matches an already-open deck item, remap the
+      // subject to the existing deck entry so that openEntry's exact-match check succeeds.
+      // Only needed in multi (deck) mode; solo mode replaces the single visible item anyway.
+      {
+        const deck = yield* DeckCapabilities.getDeck();
+        const active = !deck.solo && deck.initialized ? deck.active : [];
+        if (active.length > 0 && input.subject.length > 0) {
+          const resolveDXN = (qualifiedPath: string) =>
+            Effect.reduce(pathResolvers, Option.none<string>(), (acc, resolver) =>
+              Option.isSome(acc)
+                ? Effect.succeed(acc)
+                : resolver(qualifiedPath).pipe(
+                    Effect.map((opt) => Option.map(opt, (dxn) => dxn.toString())),
+                    Effect.catchAll(() => Effect.succeed(Option.none<string>())),
+                  ),
+            );
+
+          // Build DXN → deck item ID map for active items.
+          const deckDxnMap = new Map<string, string>();
+          yield* Effect.all(
+            active.map((deckId) =>
+              resolveDXN(deckId).pipe(
+                Effect.map((opt) => {
+                  if (Option.isSome(opt)) {
+                    deckDxnMap.set(opt.value, deckId);
+                  }
+                }),
+              ),
+            ),
+            { concurrency: 'unbounded' },
+          );
+
+          // Remap subjects whose DXN matches an existing deck item.
+          if (deckDxnMap.size > 0) {
+            const remapped = yield* Effect.all(
+              input.subject.map((subjectId) =>
+                resolveDXN(subjectId).pipe(
+                  Effect.map((opt) => {
+                    if (Option.isSome(opt)) {
+                      const existing = deckDxnMap.get(opt.value);
+                      if (existing && existing !== subjectId) {
+                        return existing;
+                      }
+                    }
+                    return subjectId;
+                  }),
+                ),
+              ),
+              { concurrency: 'unbounded' },
+            );
+            input = { ...input, subject: remapped };
+          }
+        }
+      }
+
+      // Compute the next active deck state and apply it.
+      // In solo or uninitialized mode the subject list replaces the deck entirely.
+      // In multi (deck) mode, subjects are merged via openSubjectsOnActiveDeck which
+      // uses stack semantics (truncate after pivot, then push new entries).
+      let previouslyOpenIds: Set<string>;
+      {
+        const deck = yield* DeckCapabilities.getDeck();
+        previouslyOpenIds = new Set<string>(deck.solo ? [deck.solo] : deck.active);
+        const next =
+          deck.solo || !deck.initialized
+            ? [...input.subject]
+            : openSubjectsOnActiveDeck(deck.active, input.subject, {
+                pivotId: input.pivotId,
+                key: input.key,
+              });
+
+        const { deckUpdates, toAttend: _toAttend } = computeActiveUpdates({ next, deck, attention });
+        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+      }
+
+      // Schedule side-effects for the newly opened items: scroll into view, expose in
+      // the navigation sidebar, and emit observability events.
+      // When nothing is newly opened (subject was already visible), the fallback
+      // `input.subject[0]` still triggers scroll and expose so the user is taken there.
+      {
+        const deck = yield* DeckCapabilities.getDeck();
+        const ids = deck.solo ? [deck.solo] : deck.active;
+        const newlyOpen = ids.filter((i: string) => !previouslyOpenIds.has(i));
+
+        if (input.scrollIntoView !== false && (newlyOpen[0] ?? input.subject[0])) {
+          yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+            subject: newlyOpen[0] ?? input.subject[0],
+          });
+        }
+
+        if (newlyOpen[0] ?? input.subject[0]) {
+          yield* Operation.schedule(LayoutOperation.Expose, { subject: newlyOpen[0] ?? input.subject[0] });
+        }
+
+        for (const subjectId of newlyOpen) {
+          const typename = Option.match(Graph.getNode(graph, subjectId), {
+            onNone: () => undefined,
+            onSome: (node) => {
+              const active = node.data;
+              return Obj.isObject(active) ? Obj.getTypename(active) : undefined;
+            },
+          });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: 'navigation.activate',
+            properties: { subjectId, typename },
+          });
+        }
+      }
+
+      return validatedSubjects;
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/revert-workspace.ts

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