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

package/src/types/DeckOperation.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { meta } from '#meta';
+
+const PartAdjustmentSchema = Schema.Union(
+  Schema.Literal('close').annotations({ description: 'Close the plank.' }),
+  Schema.Literal('companion').annotations({ description: 'Open the companion plank.' }),
+  Schema.Literal('solo').annotations({ description: 'Solo the plank.' }),
+  Schema.Literal('solo--fullscreen').annotations({ description: 'Fullscreen the plank.' }),
+  Schema.Literal('increment-start').annotations({ description: 'Move the plank towards the start of the deck.' }),
+  Schema.Literal('increment-end').annotations({ description: 'Move the plank towards the end of the deck.' }),
+);
+
+export type PartAdjustment = Schema.Schema.Type<typeof PartAdjustmentSchema>;
+
+export const Adjust = Operation.make({
+  meta: {
+    key: `${meta.id}.operation.adjust`,
+    name: 'Adjust',
+    description: 'Adjust the layout of a plank.',
+  },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    id: Schema.String.annotations({ description: 'The id of the plank to adjust.' }),
+    type: PartAdjustmentSchema.annotations({ description: 'The type of adjustment to make.' }),
+  }),
+  output: Schema.Void,
+});
+
+export const UpdatePlankSize = Operation.make({
+  meta: {
+    key: `${meta.id}.operation.update-plank-size`,
+    name: 'Update Plank Size',
+    description: 'Update the size of a plank.',
+  },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    id: Schema.String.annotations({ description: 'The id of the plank to resize.' }),
+    size: Schema.Number.annotations({ description: 'The new size of the plank.' }),
+  }),
+  output: Schema.Void,
+});

package/src/types/Settings.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+export const Settings = Schema.Struct({
+  enableDeck: Schema.optional(
+    Schema.Boolean.annotations({
+      title: 'Enable Deck',
+      description: 'Display multiple panels side by side instead of one at a time.',
+    }),
+  ),
+  // TODO(burdon): Rename layoutMode? (e.g., bento/encapsulated or floating/compact, etc.)
+  encapsulatedPlanks: Schema.optional(
+    Schema.Boolean.annotations({
+      title: 'Encapsulated planks',
+      description: 'Render each plank inside its own isolated container.',
+    }),
+  ),
+  showHints: Schema.optional(
+    Schema.Boolean.annotations({
+      title: 'Show hints',
+      description: 'Show helpful tips and keyboard shortcut hints in the interface.',
+    }),
+  ),
+  enableNativeRedirect: Schema.optional(
+    Schema.Boolean.annotations({
+      title: 'Enable native url redirect',
+      description: 'Redirect supported URLs to the native desktop application.',
+    }),
+  ),
+}).pipe(Schema.mutable);
+export interface Settings extends Schema.Schema.Type<typeof Settings> {}

package/src/types/index.ts

@@ -2,6 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './capabilities';
-export * from './events';
 export * from './schema';
+
+export * as DeckCapabilities from './DeckCapabilities';
+export * as DeckEvents from './DeckEvents';
+export * as DeckOperation from './DeckOperation';
+export * as Settings from './Settings';

package/src/types/schema.ts

@@ -4,52 +4,37 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Capability } from '@dxos/app-framework';
 import { Label, LayoutOperation } from '@dxos/app-toolkit';
-import { Operation } from '@dxos/operation';
 import { type DeepReadonly } from '@dxos/util';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
-export const PLANK_COMPANION_TYPE = `${meta.id}.plank-companion`;
-export const DECK_COMPANION_TYPE = `${meta.id}.deck-companion`;
+export { PLANK_COMPANION_TYPE, DECK_COMPANION_TYPE } from '@dxos/app-toolkit';
 
-// TODO(Zan): In the future we should consider adding new planks adjacent to the attended plank.
-export const NewPlankPositions = ['start', 'end'] as const;
-export type NewPlankPositioning = (typeof NewPlankPositions)[number];
-
-export const OverScrollToProps = ['none', 'centering'] as const;
-export type Overscroll = (typeof OverScrollToProps)[number];
-
-export type Part = 'solo' | 'deck' | 'complementary';
+export type Part = 'solo' | 'multi' | 'complementary';
 export type ResolvedPart = Part | 'solo-primary' | 'solo-companion';
 
-export const DeckSettingsSchema = Schema.Struct({
-  showHints: Schema.optional(Schema.Boolean),
-  enableDeck: Schema.optional(Schema.Boolean),
-  enableStatusbar: Schema.optional(Schema.Boolean),
-  enableNativeRedirect: Schema.optional(Schema.Boolean),
-  newPlankPositioning: Schema.optional(Schema.Literal(...NewPlankPositions)),
-  overscroll: Schema.optional(Schema.Literal(...OverScrollToProps)),
-  // TODO(burdon): Rename layoutMode? (e.g., bento | encapsulated?)
-  encapsulatedPlanks: Schema.optional(Schema.Boolean),
-}).pipe(Schema.mutable);
-export type DeckSettingsProps = Schema.Schema.Type<typeof DeckSettingsSchema>;
-
 export const PlankSizing = Schema.Record({ key: Schema.String, value: Schema.Number });
 export type PlankSizing = Schema.Schema.Type<typeof PlankSizing>;
 
-// State of an individual deck.
 export const DeckState = Schema.Struct({
   /** If false, the deck has not yet left solo mode and new planks should be soloed. */
   initialized: Schema.Boolean,
+  /** Item IDs of planks currently displayed in multi-mode. */
   active: Schema.mutable(Schema.Array(Schema.String)),
-  companionOpen: Schema.Boolean,
-  companionVariant: Schema.optional(Schema.String),
+  /** Item IDs of planks that have been closed; used for state persistence and reopening. */
   inactive: Schema.mutable(Schema.Array(Schema.String)),
+  /** Item ID of the single plank displayed in solo or fullscreen mode. */
   solo: Schema.optional(Schema.String),
+  /** Whether the solo plank is displayed in fullscreen mode (no heading or sidebars). */
   fullscreen: Schema.Boolean,
+  /** Persisted plank widths in rem, keyed by item ID. */
   plankSizing: Schema.mutable(PlankSizing),
+  /** Whether the companion pane is visible alongside the active plank(s). */
+  companionOpen: Schema.Boolean,
+  /** Which companion variant to display when the companion pane is open. */
+  companionVariant: Schema.optional(Schema.String),
+  /** Persisted companion frame widths in rem, keyed by frame ID. */
   companionFrameSizing: Schema.mutable(PlankSizing),
 });
 export type DeckState = Schema.Schema.Type<typeof DeckState>;
@@ -57,29 +42,32 @@ export type DeckState = Schema.Schema.Type<typeof DeckState>;
 export const defaultDeck: DeckState = {
   initialized: false,
   active: [],
-  companionOpen: false,
-  companionVariant: undefined,
   inactive: [],
   solo: undefined,
   fullscreen: false,
   plankSizing: {},
+  companionOpen: false,
+  companionVariant: undefined,
   companionFrameSizing: {},
 };
 
-const LayoutMode = Schema.Literal('deck', 'solo', 'solo--fullscreen');
+//
+// Layout
+//
+
+const LayoutMode = Schema.Literal('multi', 'solo', 'solo--fullscreen');
 export type LayoutMode = Schema.Schema.Type<typeof LayoutMode>;
 export const isLayoutMode = (value: any): value is LayoutMode => Schema.is(LayoutMode)(value);
-
 export const getMode = (deck: DeckState | DeepReadonly<DeckState>): LayoutMode => {
   if (deck.solo) {
     return deck.fullscreen ? 'solo--fullscreen' : 'solo';
   }
 
-  return 'deck';
+  return 'multi';
 };
 
 // Persisted plugin state (stored in KVS/localStorage).
-export const DeckStateSchema = Schema.Struct({
+export const StoredDeckState = Schema.Struct({
   sidebarState: Schema.Literal('closed', 'collapsed', 'expanded'),
   complementarySidebarState: Schema.Literal('closed', 'collapsed', 'expanded'),
   complementarySidebarPanel: Schema.optional(Schema.String),
@@ -88,19 +76,17 @@ export const DeckStateSchema = Schema.Struct({
   decks: Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.mutable(DeckState) })),
   previousMode: Schema.mutable(Schema.Record({ key: Schema.String, value: LayoutMode })),
 }).pipe(Schema.mutable);
-export type DeckStateProps = Schema.Schema.Type<typeof DeckStateSchema>;
+export type StoredDeckState = Schema.Schema.Type<typeof StoredDeckState>;
 
-// TODO(burdon): Factor out state (in common with other layouts?)
 // Transient/ephemeral plugin state (not persisted).
-export const DeckEphemeralStateSchema = Schema.Struct({
+export const EphemeralDeckState = Schema.Struct({
   dialogOpen: Schema.Boolean,
   dialogType: Schema.optional(Schema.Literal('default', 'alert')),
   dialogBlockAlign: Schema.optional(Schema.Literal('start', 'center', 'end')),
   dialogOverlayClasses: Schema.optional(Schema.String),
   dialogOverlayStyle: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
   /** Data to be passed to the dialog Surface. */
-  dialogContent: Schema.optional(Schema.Any),
-
+  dialogContent: Schema.NullOr(Schema.Struct({ component: Schema.String, props: Schema.optional(Schema.Any) })),
   popoverOpen: Schema.Boolean,
   popoverSide: Schema.optional(Schema.Literal('top', 'right', 'bottom', 'left')),
   popoverAnchor: Schema.optional(Schema.Any),
@@ -110,18 +96,21 @@ export const DeckEphemeralStateSchema = Schema.Struct({
   /** Ref of the subject to be passed to the popover Surface. */
   popoverContentRef: Schema.optional(Schema.String),
   /** Data to be passed to the popover Surface. */
-  popoverContent: Schema.optional(Schema.Any),
-
+  popoverContent: Schema.NullOr(
+    Schema.Union(
+      Schema.Struct({ component: Schema.String, props: Schema.optional(Schema.Any) }),
+      Schema.Struct({ subject: Schema.Any }),
+    ),
+  ),
   toasts: Schema.mutable(Schema.Array(LayoutOperation.Toast)),
   currentUndoId: Schema.optional(Schema.String),
-
   /** The identifier of a component to scroll into view when it is mounted. */
   scrollIntoView: Schema.optional(Schema.String),
 }).pipe(Schema.mutable);
-export type DeckEphemeralStateProps = Schema.Schema.Type<typeof DeckEphemeralStateSchema>;
+export type EphemeralDeckState = Schema.Schema.Type<typeof EphemeralDeckState>;
 
 // Combined state type (for convenience in components that need both).
-export type DeckPluginState = DeckStateProps & DeckEphemeralStateProps;
+export type DeckPluginState = StoredDeckState & EphemeralDeckState;
 
 export namespace DeckAction {
   const PartAdjustmentSchema = Schema.Union(
@@ -149,73 +138,4 @@ export namespace DeckAction {
     }),
     output: Schema.Void,
   }) {}
-
-  export class ChangeCompanion extends Schema.TaggedClass<ChangeCompanion>()(`${meta.id}.action.change-companion`, {
-    input: Schema.Struct({
-      companion: Schema.Union(Schema.String, Schema.Null),
-    }),
-    output: Schema.Void,
-  }) {}
-}
-
-/**
- * Operations for the Deck plugin.
- */
-export namespace DeckOperation {
-  const PartAdjustmentSchema = Schema.Union(
-    Schema.Literal('close').annotations({ description: 'Close the plank.' }),
-    Schema.Literal('companion').annotations({ description: 'Open the companion plank.' }),
-    Schema.Literal('solo').annotations({ description: 'Solo the plank.' }),
-    Schema.Literal('solo--fullscreen').annotations({ description: 'Fullscreen the plank.' }),
-    Schema.Literal('increment-start').annotations({ description: 'Move the plank towards the start of the deck.' }),
-    Schema.Literal('increment-end').annotations({ description: 'Move the plank towards the end of the deck.' }),
-  );
-  export type PartAdjustment = Schema.Schema.Type<typeof PartAdjustmentSchema>;
-
-  export const Adjust = Operation.make({
-    meta: {
-      key: `${meta.id}.operation.adjust`,
-      name: 'Adjust',
-      description: 'Adjust the layout of a plank.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        id: Schema.String.annotations({ description: 'The id of the plank to adjust.' }),
-        type: PartAdjustmentSchema.annotations({ description: 'The type of adjustment to make.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const UpdatePlankSize = Operation.make({
-    meta: {
-      key: `${meta.id}.operation.update-plank-size`,
-      name: 'Update Plank Size',
-      description: 'Update the size of a plank.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        id: Schema.String.annotations({ description: 'The id of the plank to resize.' }),
-        size: Schema.Number.annotations({ description: 'The new size of the plank.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const ChangeCompanion = Operation.make({
-    meta: {
-      key: `${meta.id}.operation.change-companion`,
-      name: 'Change Companion',
-      description: 'Change the companion plank for a primary plank.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        companion: Schema.Union(Schema.String, Schema.Null),
-      }),
-      output: Schema.Void,
-    },
-  });
 }

package/src/util/index.ts

@@ -3,5 +3,6 @@
 //
 
 export * from './layoutAppliesTopbar';
-export * from './overscroll';
+export * from './plank-url-params';
+export * from './sanitize-persisted-state';
 export * from './set-active';

package/src/util/layoutAppliesTopbar.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type LayoutMode } from '../types';
+import { type LayoutMode } from '#types';
 
 export const layoutAppliesTopbar = (breakpoint: string, layoutMode?: LayoutMode) => {
   return (

package/src/util/plank-url-params.test.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { deserializePlanks, serializePlanks, stripPlanks } from './plank-url-params';
+
+describe('serializePlanks', () => {
+  test('serializes active IDs as plank query params', ({ expect }) => {
+    const result = serializePlanks(['root/space1/types/doc/all/obj1', 'root/space1/types/doc/all/obj2'], '');
+    expect(result).toBe('?plank=%2Fspace1%2Ftypes%2Fdoc%2Fall%2Fobj1&plank=%2Fspace1%2Ftypes%2Fdoc%2Fall%2Fobj2');
+  });
+
+  test('returns empty string for empty active array with no existing params', ({ expect }) => {
+    expect(serializePlanks([], '')).toBe('');
+  });
+
+  test('preserves non-plank params', ({ expect }) => {
+    const result = serializePlanks(['root/space1/types/doc/all/obj1'], '?ref=abc');
+    expect(result).toContain('ref=abc');
+    expect(result).toContain('plank=');
+  });
+
+  test('preserves non-plank params when active array is empty', ({ expect }) => {
+    const result = serializePlanks([], '?ref=abc');
+    expect(result).toBe('?ref=abc');
+  });
+
+  test('replaces existing plank params', ({ expect }) => {
+    const result = serializePlanks(['root/space1/types/doc/all/obj2'], '?plank=%2Fspace1%2Ftypes%2Fdoc%2Fall%2Fobj1');
+    expect(result).not.toContain('obj1');
+    expect(result).toContain('obj2');
+  });
+});
+
+describe('deserializePlanks', () => {
+  test('deserializes plank query params to qualified IDs', ({ expect }) => {
+    const url = new URL(
+      'http://localhost/?plank=%2Fspace1%2Ftypes%2Fdoc%2Fall%2Fobj1&plank=%2Fspace1%2Ftypes%2Fdoc%2Fall%2Fobj2',
+    );
+    const result = deserializePlanks(url);
+    expect(result).toEqual(['root/space1/types/doc/all/obj1', 'root/space1/types/doc/all/obj2']);
+  });
+
+  test('returns empty array when no plank params', ({ expect }) => {
+    const url = new URL('http://localhost/?ref=abc');
+    expect(deserializePlanks(url)).toEqual([]);
+  });
+
+  test('preserves order', ({ expect }) => {
+    const url = new URL('http://localhost/?plank=%2Fa&plank=%2Fb&plank=%2Fc');
+    expect(deserializePlanks(url)).toEqual(['root/a', 'root/b', 'root/c']);
+  });
+});
+
+describe('stripPlanks', () => {
+  test('removes plank params', ({ expect }) => {
+    expect(stripPlanks('?plank=%2Fa&plank=%2Fb')).toBe('');
+  });
+
+  test('preserves non-plank params', ({ expect }) => {
+    expect(stripPlanks('?ref=abc&plank=%2Fa')).toBe('?ref=abc');
+  });
+
+  test('returns empty string when no params', ({ expect }) => {
+    expect(stripPlanks('')).toBe('');
+  });
+});
+
+describe('round-trip', () => {
+  test('serialize then deserialize returns original IDs', ({ expect }) => {
+    const ids = ['root/space1/types/doc/all/obj1', 'root/space1/types/doc/all/obj2'];
+    const search = serializePlanks(ids, '');
+    const url = new URL(`http://localhost/${search}`);
+    expect(deserializePlanks(url)).toEqual(ids);
+  });
+
+  test('handles special characters in IDs', ({ expect }) => {
+    const ids = ['root/!dxos:settings', 'root/~personal/types/doc/all/obj1'];
+    const search = serializePlanks(ids, '');
+    const url = new URL(`http://localhost/${search}`);
+    expect(deserializePlanks(url)).toEqual(ids);
+  });
+});

package/src/util/plank-url-params.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { fromUrlPath, toUrlPath } from '@dxos/app-toolkit';
+
+const PLANK_PARAM = 'plank';
+
+/**
+ * Serialize deck active qualified IDs into a URL search string.
+ * Preserves non-plank query params from the existing search string.
+ */
+export const serializePlanks = (active: readonly string[], existingSearch: string): string => {
+  const params = new URLSearchParams(existingSearch);
+  params.delete(PLANK_PARAM);
+  for (const id of active) {
+    params.append(PLANK_PARAM, toUrlPath(id));
+  }
+  return params.size > 0 ? `?${params.toString()}` : '';
+};
+
+/**
+ * Deserialize plank query params from a URL back to qualified graph IDs.
+ */
+export const deserializePlanks = (url: URL): string[] => {
+  return url.searchParams.getAll(PLANK_PARAM).map(fromUrlPath);
+};
+
+/**
+ * Strip plank query params from a search string, preserving all others.
+ */
+export const stripPlanks = (existingSearch: string): string => {
+  const params = new URLSearchParams(existingSearch);
+  params.delete(PLANK_PARAM);
+  return params.size > 0 ? `?${params.toString()}` : '';
+};

package/src/util/sanitize-persisted-state.test.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { defaultDeck, type DeckState, type StoredDeckState } from '#types';
+
+import { sanitizePersistedState } from './sanitize-persisted-state';
+
+const makeState = (decks: Record<string, Partial<DeckState>>): StoredDeckState => ({
+  sidebarState: 'expanded',
+  complementarySidebarState: 'collapsed',
+  complementarySidebarPanel: undefined,
+  activeDeck: Object.keys(decks)[0] ?? 'default',
+  previousDeck: 'default',
+  decks: Object.fromEntries(Object.entries(decks).map(([id, overrides]) => [id, { ...defaultDeck, ...overrides }])),
+  previousMode: {},
+});
+
+describe('sanitizePersistedState', () => {
+  test('returns same reference when no cleanup needed', ({ expect }) => {
+    const state = makeState({ default: {} });
+    expect(sanitizePersistedState(state)).toBe(state);
+  });
+
+  test('clears fullscreen on any deck', ({ expect }) => {
+    const state = makeState({ ws1: { fullscreen: true } });
+    const result = sanitizePersistedState(state);
+    expect(result.decks.ws1?.fullscreen).toBe(false);
+  });
+
+  test('clears active for solo-mode decks', ({ expect }) => {
+    const state = makeState({ ws1: { solo: 'item-a', active: ['item-b', 'item-c'] } });
+    const result = sanitizePersistedState(state);
+    expect(result.decks.ws1?.active).toEqual([]);
+    expect(result.decks.ws1?.solo).toBe('item-a');
+  });
+
+  test('preserves active for deck-mode decks (no solo)', ({ expect }) => {
+    const state = makeState({ ws1: { active: ['item-a', 'item-b'], initialized: true } });
+    const result = sanitizePersistedState(state);
+    expect(result).toBe(state);
+  });
+
+  test('does not clear active when it is already empty', ({ expect }) => {
+    const state = makeState({ ws1: { solo: 'item-a', active: [] } });
+    expect(sanitizePersistedState(state)).toBe(state);
+  });
+
+  test('cleans multiple decks independently', ({ expect }) => {
+    const state = makeState({
+      ws1: { solo: 'item-a', active: ['item-b'] },
+      ws2: { active: ['item-c'], initialized: true },
+      ws3: { fullscreen: true, solo: 'item-d', active: ['item-e'] },
+    });
+    const result = sanitizePersistedState(state);
+
+    // ws1: solo with active → active cleared.
+    expect(result.decks.ws1?.active).toEqual([]);
+    expect(result.decks.ws1?.solo).toBe('item-a');
+
+    // ws2: deck mode, no solo → untouched.
+    expect(result.decks.ws2?.active).toEqual(['item-c']);
+
+    // ws3: fullscreen + solo with active → both cleared.
+    expect(result.decks.ws3?.fullscreen).toBe(false);
+    expect(result.decks.ws3?.active).toEqual([]);
+    expect(result.decks.ws3?.solo).toBe('item-d');
+  });
+
+  test('does not mutate the original state', ({ expect }) => {
+    const state = makeState({ ws1: { solo: 'item-a', active: ['item-b'], fullscreen: true } });
+    const originalActive = [...state.decks.ws1!.active];
+    sanitizePersistedState(state);
+    expect(state.decks.ws1?.active).toEqual(originalActive);
+    expect(state.decks.ws1?.fullscreen).toBe(true);
+  });
+});

package/src/util/sanitize-persisted-state.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type StoredDeckState } from '#types';
+
+/**
+ * Sanitizes persisted deck state on startup.
+ *
+ * Persisted state may contain values that are inappropriate to restore across sessions:
+ *
+ * - **Fullscreen**: Cleared unconditionally to prevent the user from getting stuck in fullscreen
+ *   mode if the app was closed (or crashed) while fullscreen was active.
+ *
+ * - **Active planks in solo-mode decks**: When a deck is in solo mode, any items in `active`
+ *   represent planks that were kept mounted (hidden) during the session for fast deck↔solo
+ *   switching. After a restart these planks would need to fully remount anyway, so retaining
+ *   them only adds unnecessary load. Clearing `active` for solo-mode decks avoids rendering
+ *   stale planks in the background on startup.
+ *
+ * Returns a new state object if any changes were made, or the original state if clean.
+ */
+export const sanitizePersistedState = (state: StoredDeckState): StoredDeckState => {
+  let needsUpdate = false;
+  const cleanedDecks = { ...state.decks };
+
+  for (const [id, deck] of Object.entries(cleanedDecks)) {
+    if (!deck) {
+      continue;
+    }
+
+    let updated = false;
+    let cleanedDeck = deck;
+
+    if (deck.fullscreen) {
+      cleanedDeck = { ...cleanedDeck, fullscreen: false };
+      updated = true;
+    }
+
+    if (deck.solo && deck.active.length > 0) {
+      cleanedDeck = { ...cleanedDeck, active: [] };
+      updated = true;
+    }
+
+    if (updated) {
+      cleanedDecks[id] = cleanedDeck;
+      needsUpdate = true;
+    }
+  }
+
+  return needsUpdate ? { ...state, decks: cleanedDecks } : state;
+};